关于联合和堆分配内存的问题

Question

我试图使用联合来更新一个线程中的字段，然后读取另一个线程中的所有字段。在实际系统中，我有互斥体来确保一切都是安全的。问题出在 fieldB 上，在我不得不更改它之前，fieldB 的声明方式与字段 A 和 C 类似。但是，由于第三方驱动程序，fieldB 必须与页边界对齐。当我将字段 B 更改为使用 valloc 分配时，我遇到了问题。

问题： 1）有没有办法静态声明 fieldB 在页​​面边界上对齐。基本上与 valloc 做同样的事情，但是在堆栈上？

2）当字段B或任何字段在堆上分配时是否可以进行联合？不确定这是否合法。

这是我正在尝试的一个简单的测试程序。除非您像字段 A 和 C 一样声明字段 B，并在公共方法中进行明显的更改，否则这不起作用。

#include <iostream>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>

class Test
{
   public:
      Test(void)
      {
         // field B must be alligned to page boundary
         // Is there a way to do this on the stack???
         this->field.fieldB = (unsigned char*) valloc(10);
      };

      //I know this is bad, this class is being treated like 
      //a global structure. Its self contained in another class.
      unsigned char* PointerToFieldA(void)
      {
         return &this->field.fieldA[0];
      }

      unsigned char* PointerToFieldB(void)
      {
         return this->field.fieldB;
      }

      unsigned char* PointerToFieldC(void)
      {
         return &this->field.fieldC[0];
      }

      unsigned char* PointerToAllFields(void)
      {
         return &this->allFields[0];
      }

   private:
      // Is this union possible with field B being 
      // allocated on the heap?
      union
      {
         struct
         {
            unsigned char  fieldA[10];

            //This field has to be alligned to page boundary
            //Is there way to be declared on the stack
            unsigned char* fieldB;
            unsigned char  fieldC[10];
         } field;

         unsigned char allFields[30];
      };
};


int main()
{
   Test test;

   strncpy((char*) test.PointerToFieldA(), "0123456789", 10);
   strncpy((char*) test.PointerToFieldB(), "1234567890", 10);
   strncpy((char*) test.PointerToFieldC(), "2345678901", 10);

   char dummy[11];
   dummy[10] = '\0';

   strncpy(dummy, (char*) test.PointerToFieldA(), 10);
   printf("%s\n", dummy);

   strncpy(dummy, (char*) test.PointerToFieldB(), 10);
   printf("%s\n", dummy);

   strncpy(dummy, (char*) test.PointerToFieldC(), 10);
   printf("%s\n", dummy);

   char allFields[31];
   allFields[30] = '\0';
   strncpy(allFields, (char*) test.PointerToAllFields(), 30);
   printf("%s\n", allFields);

   return 0;
}

Answer 1

我认为您不能将 fieldB 声明为指针并获得所需的行为（假设我正确理解了问题）。为了使联合在使用时有意义，您需要将其声明为联合中的数组。

我有点好奇是否可以重载该类的 new 运算符以强制特定成员位于页面边界上。我很快就将重载的运算符拼凑在一起来做到这一点。它会导致每次分配整个额外页面。它找到该字段所在位置的偏移量，然后按该量调整地址。由于分配了额外的内存（假设我计算正确），所以它是安全的。不过，非常丑陋。

它将分配偏移量填充到类中的成员中，以便它知道“取消偏移”指针以释放它的量。这真是一段可怕的代码。作为一个实验似乎还不错，但在生产代码中却不太好。

#define PAGE_SIZE 0x1000

class test
{
public:
   int allocoffset;
   void* operator new( size_t );
   void operator delete( void* );
    union
      {
         __declspec( align(4096)) struct
         {
            unsigned char  fieldA[10];

            //This field has to be alligned to page boundary
            //Is there way to be declared on the stack
            unsigned char  fieldB[10];
            unsigned char  fieldC[10];
         } field;

         unsigned char allFields[30];
      };
};

void* test::operator new(size_t size)
{
   // Allocate an entire extra page so we can offset it by any amount
   // less than the page size to ensure alignment of fieldB
   unsigned char *p = (unsigned char*)malloc( sizeof( test ) + PAGE_SIZE );
   uintptr_t addr;
   uintptr_t diff;

   std::cout << "new " << (void*)p << std::endl;

   // now offset the returned memory by the amount needed to align
   // fieldB on a page boundary.
   addr = (uintptr_t)p + (uintptr_t)( offsetof( test, field.fieldB ));

   diff = PAGE_SIZE - ( addr & (PAGE_SIZE - 1 ));

   p += diff;

   ((test*)p)->allocoffset = diff;

   return p;
}

void test::operator delete( void *p )
{
   // offset by appropriate amount that we allocated it by
   p = (void*)( (unsigned char*)p - ((test*)p)->allocoffset );
   std::cout << "delete " << p << std::endl;
   free(p);
}

int main()
{
   test *t;

   t = new test;

   std::cout << "allocation offset " << t->allocoffset << std::endl;
   std::cout << "address of fieldB " << (void*)&t->field.fieldB << std::endl;

   delete t;
}

这是示例输出：

new 00353FA0
allocation offset 86
address of fieldB 00355000
delete 00353FA0

Answer 2

我不这么认为 - 在堆栈上对齐有点复杂，因为您需要知道当前的位置，分配足够的字节来消耗“当前”内存页，然后分配数据。在堆栈上，这不是通常的操作（即，您不对齐堆栈上的任何内容）。

但是，某些编译器具有会对齐结构的编译指示，MSVC 具有 '__declspecalign'，您可以在其中指定数据成员的对齐方式，编译器将插入适当的字节数。

可以建立一个联合，其中在堆上分配 1 个成员 - 联合将像往常一样包含所有字段，但堆分配的成员将只是一个指针。

最后，valloc 已过时 - 您应该使用 memalign 或 posix_memalign 代替。