c# - sensorial - tipos de memoria a largo plazo
¿Cuál es la huella de memoria de un Nullable<T> (7)
Un int ( Int32 ) tiene una huella de memoria de 4 bytes. Pero ¿cuál es la huella de memoria de:
int? i = null;
y:
int? i = 3;
¿Es esto en general o tipo dependiente?
El tamaño de Nullable<T> es definitivamente dependiente del tipo. La estructura tiene dos miembros.
- boolean: para el hasValue
- valor: para el valor subyacente
El tamaño de la estructura generalmente se asignará a 4 más el tamaño del parámetro de tipo T.
El tipo anulable es una estructura que contiene la variable regular y una bandera para el estado nulo.
Para un int anulable, eso significaría que contiene cinco bytes de datos, pero por supuesto se rellena para completar palabras, por lo que usa ocho bytes.
En general, puede esperar que cualquier tipo anulable sea cuatro bytes más grande que el tipo normal, a excepción de los tipos pequeños como byte y boolean.
Máquinas de 32 bits y 64 bits:
- int == 4 bytes
- ¿En t? == 8 bytes == 4 para int + 4 para el contenedor de tipo anulable.
El contenedor de tipo anulable requiere 4 bytes de almacenamiento. Y el entero requiere 4 bytes para cada elemento. Esta es una implementación eficiente. En una matriz, muchos tipos anulables se almacenan en memoria contigua.
Basado en una prueba personal (.NET Framework 4.6.1, x64, Release) y de - https://www.dotnetperls.com/nullable-memory
Además, si es interesante: ¿por qué int en x64 equivale a solo 4 bytes?
Nota: esto es válido solo para Nullable<int> , el tamaño de Nullable<T> depende totalmente del tipo.
No estoy 100% seguro, pero creo que debería ser de 8 bytes, 4 bytes para el int32, y (ya que todo tiene que estar alineado con 4 bytes en una máquina de 32 bits) 4 bytes para un booleano que indica si el entero El valor ha sido especificado o no.
En una máquina de 64 bits aún sería de 8 bytes (64 bits), ya que es la porción más pequeña de memoria que se puede direccionar ...
Puede verificar usando un código similar al que se encuentra en https://www.dotnetperls.com/nullable-memory .
Obtuve los siguientes resultados:
-
Int324 bytes -
Int32?8 bytes -
Int162 bytes -
Int16?4 bytes -
Int648 bytes -
Int64?16 bytes -
Byte1 bytes -
Byte?2 bytes -
bool1 bytes -
bool?2 bytes
Un int? es una estructura que contiene un valor booleano, y un int. Por lo tanto, tiene una huella de 5 bytes. Lo mismo se aplica a todas las instancias de un nullable<T> : size = sizeof(T)+sizeof(bool)
int? a = 3; 00000038 lea ecx,[ebp-48h] 0000003b mov edx,3 00000040 call 78BFD740 00000045 nop a = null; 00000046 lea edi,[ebp-48h] 00000049 pxor xmm0,xmm0 0000004d movq mmword ptr [edi],xmm0
Parece que la primera palabra es para el valor, y la segunda es para el indicador nulo. Entonces, 8 bytes en total.
Curioso, a BinaryWritter no le gusta escribir tipos anulables. Estaba vagando si podía empaquetarlo más apretado entonces 8 bytes ...