跨平台虚拟机的C内存管理

我问了一个 question 关于C型尺寸,我得到了一个很好的答案,但我意识到我可能无法很好地阐述问题,以便对我的目的有用。

我的背景是从计算机工程师到软件工程师,所以我喜欢计算机体系结构,总是在考虑制造虚拟机。我刚刚完成了一个有趣的项目,用Java制作VM,我很自豪。但是有一些法律问题我现在不能开源,我现在有一些空闲时间。所以我想看看我是否能在C上制作另一个虚拟机(速度更快),只是为了好玩和教育。

问题是我不是一个C程序,我上一次写一个非琐碎的C问题是在10多年前。我是Pascal,Delphi,现在是Java和PHP程序员。

有许多障碍我可以预见,我正在尝试解决一个问题,那就是访问现有的图书馆(在爪哇,反射解决了这个问题)。

我计划通过拥有数据缓冲区(类似于堆栈)来解决这个问题。我的虚拟机的客户机可以在给我提供指向本机函数的指针之前编程将数据放入这些堆栈中。

int main(void) {
    // Prepare stack
    int   aStackSize = 1024*4;
    char *aStackData = malloc(aStackSize);

    // Initialise stack
    VMStack aStack;
    VMStack_Initialize(&aStack, (char *)aStackData, aStackSize);

    // Push in the parameters
    char *Params = VMStack_CurrentPointer(&aStack);
    VMStack_Push_int   (&aStack, 10  ); // Push an int
    VMStack_Push_double(&aStack, 15.3); // Push a double

    // Prepare space for the expected return
    char *Result = VMStack_CurrentPointer(&aStack);
    VMStack_Push_double(&aStack, 0.0); // Push an empty double for result

    // Execute
    void (*NativeFunction)(char*, char*) = &Plus;
    NativeFunction(Params, Result); // Call the function

    // Show the result
    double ResultValue = VMStack_Pull_double(&aStack); // Get the result
    printf("Result:  %5.2f\n", ResultValue);               // Print the result

    // Remove the previous parameters
    VMStack_Pull_double(&aStack); // Pull to clear space of the parameter
    VMStack_Pull_int   (&aStack); // Pull to clear space of the parameter

    // Just to be sure, print out the pointer and see if it is `0`
    printf("Pointer: %d\n", aStack.Pointer);

    free(aStackData);
    return EXIT_SUCCESS;
}

本地函数的推、拉和调用可以由一个字节代码触发(这就是稍后生成VM的方法)。

为了完整性(以便您可以在计算机上进行尝试),下面是用于堆栈的代码:

typedef struct {
    int  Pointer;
    int  Size;
    char *Data;
} VMStack;

inline void   VMStack_Initialize(VMStack *pStack, char *pData, int pSize) __attribute__((always_inline));
inline char   *VMStack_CurrentPointer(VMStack *pStack)                    __attribute__((always_inline));
inline void   VMStack_Push_int(VMStack *pStack, int pData)                __attribute__((always_inline));
inline void   VMStack_Push_double(VMStack *pStack, double pData)          __attribute__((always_inline));
inline int    VMStack_Pull_int(VMStack *pStack)                           __attribute__((always_inline));
inline double VMStack_Pull_double(VMStack *pStack)                        __attribute__((always_inline));

inline void VMStack_Initialize(VMStack *pStack, char *pData, int pSize) {
    pStack->Pointer = 0;
    pStack->Data    = pData;
    pStack->Size    = pSize;
}

inline char *VMStack_CurrentPointer(VMStack *pStack) {
    return (char *)(pStack->Pointer + pStack->Data);
}

inline void VMStack_Push_int(VMStack *pStack, int pData) {
    *(int *)(pStack->Data + pStack->Pointer) = pData;
    pStack->Pointer += sizeof pData; // Should check the overflow
}
inline void VMStack_Push_double(VMStack *pStack, double pData) {
    *(double *)(pStack->Data + pStack->Pointer) = pData;
    pStack->Pointer += sizeof pData; // Should check the overflow
}

inline int VMStack_Pull_int(VMStack *pStack) {
    pStack->Pointer -= sizeof(int);// Should check the underflow
    return *((int *)(pStack->Data + pStack->Pointer));
}
inline double VMStack_Pull_double(VMStack *pStack) {
    pStack->Pointer -= sizeof(double);// Should check the underflow
    return *((double *)(pStack->Data + pStack->Pointer));
}

在本机函数方面,我创建了以下内容用于测试:

// These two structures are there so that Plus will not need to access its parameter using
//    arithmetic-pointer operation (to reduce mistake and hopefully for better speed).
typedef struct {
    int    A;
    double B;
} Data;
typedef struct {
    double D;
} DDouble;

// Here is a helper function for displaying
void PrintData(Data *pData, DDouble *pResult) {
    printf("%5.2f + %5.2f = %5.2f\n", pData->A*1.0, pData->B, pResult->D);
}

// Some native function
void Plus(char* pParams, char* pResult) {
    Data    *D  = (Data    *)pParams; // Access data without arithmetic-pointer operation
    DDouble *DD = (DDouble *)pResult; // Same for return
    DD->D = D->A + D->B;
    PrintData(D, DD);
}

执行时,上述代码返回:

10.00 + 15.30 = 25.30
Result:  25.30
Pointer: 0

这在我的机器(Linuxx86 32位GCC-C99)上工作得很好。如果在其他操作系统/体系结构上也能工作,那将是非常好的。但是至少有三个与内存相关的问题我们必须注意。

1)。数据大小-如果我在相同的体系结构上使用相同的编译器编译VM和本机函数,那么大小类型应该是相同的。

2)。endianness-与数据大小相同。

3)。内存对齐-这是一个问题,因为填充字节可以添加到结构中,但是在准备参数堆栈as时很难对其进行同步(除了硬编码之外,没有办法知道如何添加填充)。

我的问题是:

1)。如果我知道类型的大小,有没有方法修改push和pull函数以与结构填充完全同步?(修改以让编译器处理数据大小和endian问题等问题)。

2)。如果我一个一个地包装结构(使用 #pragma pack(1) )(2.1)性能罚款是否可以接受?(2.2)项目的稳定性是否有风险?

3)。填充2、4或8怎么样?对于一般的32位或64位系统,哪一个比较好?

4)。你能给我介绍一个关于精确填充算法的文档吗,比如说x86上的gcc?

5)。有更好的方法吗?

注意:跨平台不是我的最终目标,但我无法抗拒。而且,只要表现不那么难看,就不是我的目标。所有这些都是为了娱乐和学习。

抱歉我的英语和很长的帖子。

提前感谢大家。