¿Qué considerar con respecto a la alineación cuando se diseña un grupo de memoria?

Question

Estoy trabajando en un grupo de memoria para un motor de juegos pequeños.

El uso principal será como un almacenamiento segregado; un grupo contiene un objeto de un tipo y tamaño específico. Actualmente, las agrupaciones se pueden usar para almacenar cualquier cosa, pero las asignaciones se realizarán en bloques de un tamaño específico. La mayor parte de la necesidad de memoria se asignará a la vez, pero se puede habilitar el "crecimiento excesivo" si es necesario para ayudar en la sintonización (tamaño casi fijo).

El problema es que comencé a sentirme un tanto paranoico al contemplar la alineación de la memoria. Solo estoy acostumbrado a la administración de memoria sin procesar en procesadores de 8 bits donde todo está alineado por bytes.

Voy a dejar que el usuario (me) especifique el tamaño deseado de los bloques, que en el caso de almacenamiento segregados sería el tamaño de los objetos que voy a almacenar en él.

El enfoque actual es asignar un trozo de memoria blocks * (desired_size + header_size) grande y colocar los objetos en él, con un encabezado para cada bloque; Obviamente, los objetos se ubicarían directamente detrás de este encabezado.

¿Qué debo tener en cuenta con respecto a la alineación de memoria en mi escenario?

La respuesta que he encontrado hasta el momento es que el tiempo que representa desired_sizen -byte datos alineados; el encabezado está correctamente alineado y empaquetado por el compilador, así como los datos reales, todo lo almacenado en el bloque será n -byte alineado.

n es cualquier límite requerido por la plataforma. Me estoy orientando a x86 por el momento, pero no me gusta hacer ninguna suposición sobre la plataforma en mi código.

Algunos de los recursos que he utilizado:

• http://www.ibm.com/developerworks/library/pa-dalign/
• http://en.wikipedia.org/wiki/Data_structure_alignment
• Memory alignment on a 32-bit Intel processor
• docs Boost piscina en busca de inspiración en el diseño general. Me gustaría evitar arrastrar impulso en este proyecto; y estoy viendo esto como una oportunidad de aprendizaje también.

Editar

Subido código de ejemplo pequeña que puede nadie útiles tan confundido como mí en el futuro here.

Answer 1

Las asignaciones con malloc están garantizadas para alinearse para cualquier tipo proporcionado por el compilador y, por lo tanto, cualquier objeto [*].

El peligro es cuando su encabezado tiene un requisito de alineación menor que el requisito de alineación máxima para su implementación. Entonces su tamaño podría no ser un múltiplo del máximo. alineación, por lo que cuando intente usar/fundir buf + header_size como un puntero a algo que tiene tiene el máximo. alineación, está desalineada. En lo que respecta a C, es un comportamiento indefinido. En Intel, funciona pero es más lento. En algunos ARM provoca una excepción de hardware. En algunos ARM, silenciosamente da la respuesta incorrecta. Entonces, si no quiere hacer suposiciones acerca de la plataforma en su código, debe lidiar con eso.

Básicamente, hay tres trucos que yo sepa para asegurar que su cabecera no causa desalineación:

• Uso Pragma una alineación específica de la implementación de forzar el asunto.
• Utilice el conocimiento específico de la plataforma sobre el diseño y la alineación de la estructura para asegurarse de que su tamaño sea un múltiplo del requisito de alineación máxima en el sistema. Típicamente esto significa, "pegar un extra int en relleno si es necesario para convertirlo en un múltiplo 8 en lugar de solo un 4".
• Haga que el encabezado sea union de cada tipo estándar, junto con la estructura que realmente desea usar. Funciona bien en C, pero tendría problemas en C++ si su encabezado no es válido para ser miembro de uniones.

Como alternativa, puede simplemente definir header_size no ser sizeof(header), pero para ser de ese tamaño se redondearán a un múltiplo de algún poder grueso de 2 que es "suficientemente bueno". Si desperdicia un poco de memoria, que así sea, y siempre puede tener un "encabezado de portabilidad" que define este tipo de cosas de una manera que no es puramente independiente de la plataforma, sino que hace que sea más fácil adaptarse a las nuevas plataformas.

[*] con una excepción común siendo los tipos SIMD sobredimensionados. Dado que no son estándares, y sería un derroche alinear cada asignación solo por ellos, se les quita la mano a un lado, y se necesitan funciones de asignación especiales para ellos.

Answer 2

Su compilador ya alineará los miembros de los objetos y las estructuras que se almacenarán en la agrupación. Usar el empaque predeterminado que sea apropiado para su arquitectura, generalmente 8 para un núcleo de 32 bits. Solo debe asegurarse de que la dirección que genere de su grupo de servidores esté alineada en consecuencia. Que en un sistema operativo de 32 bits debe ser un múltiplo de 8 bytes.

La alineación incorrecta de los objetos puede ser muy costosa cuando cruzan un límite de la línea de caché de la CPU. Un doble que se extiende a dos líneas de caché tarda tanto como tres veces más en leerse o escribirse.

Answer 3

Use http://msdn.microsoft.com/en-us/library/bb982233.aspx - std :: alignment_of. Esto asegura que por cada T que asigne a su grupo, sabrá la alineación y puede asegurarse de que encaja. No voy a pretender saber/entender la lógica real que utilizaría para convertir esta información en garantías de alineación, pero existe y está disponible para su uso.

Answer 4

Por lo que sé, boost :: pool se basa en el 'asignador de pequeños objetos' de alexandrescu explicado en su libro "diseño moderno de C++". Tengo que leer el libro (ya que también está escribiendo esto para aprender)

Answer 5

He alterado la alineación de la memoria también. Lo primero que debe entender es que cada objeto tiene sus propios requisitos de alineación de memoria, que es (como máximo) el tamaño del objeto en sí. Afortunadamente, a menudo es más pequeño.

Hay instalaciones de dos tipos para ayudar a escribir asignadores de memoria correctas (C++ 0x, que se puede encontrar en std::tr1 en la mayoría STL):

• std::alignment_of da la alineación como un valor de tiempo de compilación
• std::aligned_storage da un almacenamiento alineadas según sus parámetros

Trabajar con los dos de ellos, obtendrá lo que necesita.

Sin embargo, su diseño es un poco fuera de base, no por mucho, porque su encabezado no tendrá el mismo requisito de alineación (en general) que los objetos almacenados.

template <class T, size_t N> 
struct Block 
{ 
    // Header bits 

    typedef std::aligned_storage< 
     N*sizeof(T), 
     std::alignment_of<T>::value 
    >::type buffer_type; 
    buffer_type mBuffer; 
}; 

Dos notas:

• Block sí pueden tener una alineación diferente, pero no importa
• usted podría utilizar sizeof para la alineación, que está garantizado para trabajar, aunque un poco derrochador

Finalmente, también puede tener éxito sin todos estos, y algunos aritmética de punteros, pero ya que se ofrece ....