10 respuestas en este tema

[Delphius]

Hoy les vengo con una duda a la que no se como responderme. Hasta el momento no había prestado atención al tema del endianess pero cuando uno va a almacenar valores en un archivo y los cuáles puede ser compartidos o leerse en diferentes equipos pueden empezar los peros si justamente sus procesadores son de distinto endian.

No me había percatado de esto sino fuera porque durante una de mis investigaciones para mi proyecto personal comentaba de esto. Y se me prendió la alarma.

 

¿Que es eso del endian? Pues básicamente el formato en como se representan los números de más de un byte en el procesador. Basicamente hay dos tipos: big-endian y litte-endian.

En el primero los bits más representativos están al principio, mientras que para little-endian en cambio son los menos representativos. Es decir están invertidos.

 

Ya estuve leyendo en la documentación de Lazarus que efectivamente hay maneras seguras de poder ir de un tipo de endian a otro. Y hay un buen repertorio de funciones para trabajar con los tipos enteros:

delphi

function SwapEndian(const AValue: SmallInt): SmallInt;{$ifdef SYSTEMINLINE}inline;{$endif}
function SwapEndian(const AValue: Word): Word;{$ifdef SYSTEMINLINE}inline;{$endif}
function SwapEndian(const AValue: LongInt): LongInt;
function SwapEndian(const AValue: DWord): DWord;
function SwapEndian(const AValue: Int64): Int64;
function SwapEndian(const AValue: QWord): QWord;
 
function BEtoN(const AValue: SmallInt): SmallInt;{$ifdef SYSTEMINLINE}inline;{$endif}
function BEtoN(const AValue: Word): Word;{$ifdef SYSTEMINLINE}inline;{$endif}
function BEtoN(const AValue: LongInt): LongInt;{$ifdef SYSTEMINLINE}inline;{$endif}
function BEtoN(const AValue: DWord): DWord;{$ifdef SYSTEMINLINE}inline;{$endif}
function BEtoN(const AValue: Int64): Int64;{$ifdef SYSTEMINLINE}inline;{$endif}
function BEtoN(const AValue: QWord): QWord;{$ifdef SYSTEMINLINE}inline;{$endif}
 
function LEtoN(const AValue: SmallInt): SmallInt;{$ifdef SYSTEMINLINE}inline;{$endif}
function LEtoN(const AValue: Word): Word;{$ifdef SYSTEMINLINE}inline;{$endif}
function LEtoN(const AValue: LongInt): LongInt;{$ifdef SYSTEMINLINE}inline;{$endif}
function LEtoN(const AValue: DWord): DWord;{$ifdef SYSTEMINLINE}inline;{$endif}
function LEtoN(const AValue: Int64): Int64;{$ifdef SYSTEMINLINE}inline;{$endif}
function LEtoN(const AValue: QWord): QWord;{$ifdef SYSTEMINLINE}inline;{$endif}
 
function NtoBE(const AValue: SmallInt): SmallInt;{$ifdef SYSTEMINLINE}inline;{$endif}
function NtoBE(const AValue: Word): Word;{$ifdef SYSTEMINLINE}inline;{$endif}
function NtoBE(const AValue: LongInt): LongInt;{$ifdef SYSTEMINLINE}inline;{$endif}
function NtoBE(const AValue: DWord): DWord;{$ifdef SYSTEMINLINE}inline;{$endif}
function NtoBE(const AValue: Int64): Int64;{$ifdef SYSTEMINLINE}inline;{$endif}
function NtoBE(const AValue: QWord): QWord;{$ifdef SYSTEMINLINE}inline;{$endif}
 
function NtoLE(const AValue: SmallInt): SmallInt;{$ifdef SYSTEMINLINE}inline;{$endif}
function NtoLE(const AValue: Word): Word;{$ifdef SYSTEMINLINE}inline;{$endif}
function NtoLE(const AValue: LongInt): LongInt;{$ifdef SYSTEMINLINE}inline;{$endif}
function NtoLE(const AValue: DWord): DWord;{$ifdef SYSTEMINLINE}inline;{$endif}
function NtoLE(const AValue: Int64): Int64;{$ifdef SYSTEMINLINE}inline;{$endif}
function NtoLE(const AValue: QWord): QWord;{$ifdef SYSTEMINLINE}inline;{$endif}

Gracias las funciones XtoN es posible leer ya sea BE (Big-endian) o LE (Litte-endian) y pasarlo al tipo nativo del procesador. Y a su inverso NtoX hacer lo opuesto.

 

De esta forma uno por ejemplo puede definir que sus archivos siempre se guarden en big-endian por ejemplo y proceder a emplear BEtoN() para leerlo y recuperar el dato sin problemas. Y usar NtoBE() al momento de guardarlo.

 

Hasta ahí todo bien... con los enteros. Pero luego recordé el hilo en el que escafandra daba una advertencia sobre como leer el signo de un doble y "adivinar" en que "mitad" saber leer.

 

Y ahora me asalta la duda ¿En los tipos flotantes también rige el sistema endianess? Porque me llama poderosamente la atención que si efectivamente es asi, ¿porqué es que no existe entonces las funciones sobrecargadas para los flotantes? O es que yo soy medio lento y no las encuentro.

 

Esto me lleva entonces a considerar a escribir mi propia implementación análogas a las detalladas anteriormente. Pensé en estudiar por el comienzo... a ver que es lo que hace en IsNan() y en IsInfinite():

delphi

function IsNan(const d : Double): Boolean;
  var
    fraczero, expMaximal: boolean;
  begin
{$if defined(FPC_BIG_ENDIAN) or defined(FPC_DOUBLE_HILO_SWAPPED)}
    expMaximal := ((TSplitDouble(d).cards[0] shr 20) and $7ff) = 2047;
    fraczero:= (TSplitDouble(d).cards[0] and $fffff = 0) and
                (TSplitDouble(d).cards[1] = 0);
{$else FPC_BIG_ENDIAN}
    expMaximal := ((TSplitDouble(d).cards[1] shr 20) and $7ff) = 2047;
    fraczero := (TSplitDouble(d).cards[1] and $fffff = 0) and
                (TSplitDouble(d).cards[0] = 0);
{$endif FPC_BIG_ENDIAN}
    Result:=expMaximal and not(fraczero);
  end;

delphi

function IsInfinite(const d : Double): Boolean;
  var
    fraczero, expMaximal: boolean;
  begin
{$if defined(FPC_BIG_ENDIAN) or defined(FPC_DOUBLE_HILO_SWAPPED)}
    expMaximal := ((TSplitDouble(d).cards[0] shr 20) and $7ff) = 2047;
    fraczero:= (TSplitDouble(d).cards[0] and $fffff = 0) and
                (TSplitDouble(d).cards[1] = 0);
{$else FPC_BIG_ENDIAN}
    expMaximal := ((TSplitDouble(d).cards[1] shr 20) and $7ff) = 2047;
    fraczero := (TSplitDouble(d).cards[1] and $fffff = 0) and
                (TSplitDouble(d).cards[0] = 0);
{$endif FPC_BIG_ENDIAN}
    Result:=expMaximal and fraczero;
  end;

Siendo TSplitDouble un simple record:

delphi

type
  TSplitDouble = packed record
    cards: Array[0..1] of cardinal;
  end;

Y Cardinal un simple alias del LongWord.

 

Pero hago aguas, al intentar razonarlo. ¿Alguna guía?

 

Saludos,

[Delphius]

¿Alguien tiene algún norte para tirar?

He estado entre ayer y hoy tratando de entender fielmente como es que interviene el proceso de intercambio de los bytes entre el Big-Endian y Little-Endian y que rol cumple en ello la función IsNan() y/o IsInfinite().

La teoría dice que en Little-Endian los bytes están ordenados de forma inversa. Es decir que dado un número double 0xaabbccddeeffgghh como lo conocemos habitualmente, en Litte-Endian estará ordenado entonces como hhggffeeddccbbaa. De este modo entonces ya que el formato del double es:

 

[63][62..52][51..0] para el signo, exponente, y fracción respectivamente. En 0xaa tendremos lo siguiente: seee|eeee es decir el bit de signo, seguido de los 7 bits más significativos del exponente. En 0xbb tendremos eeee|ffff es decir los 4bits más bajos y restantes del exponente y a continuación los 4 bits más significativos de la fracción. El resto de los bytes hacen a la fracción.

 

Pues, al poner esto en práctica y para entender el funcionamiento de IsNan() hice a mano una prueba de escritorio a con la representación binaria del NAN: 7F..F pero o es que hago mal el dezplazamiento a la derecha de la parte alta (Cards[1] = [eeffgghh]) o metí mal el dedo al calcular el binario de $FFFFF, 2047 y $7FF.

 

He tratado de localizar fuentes precisas que traten el tema de endianness con los flotantes pero no he llegado a algo concreto, preciso y sea digerible. Incluso he probado a ver si por casualidad ya hay algo en Delphi. Y si bien encontré un hilo en el foro de Embarcadero, no se termina enteniendo. Esto es lo último, y que parece más rescatable, de entender. Claro está: no expone el concepto desde el aspecto de los tipos flotantes pero es algo.

 

Por si sirve de ayuda. Esto es lo que hace BEtoN()

delphi

function BEtoN(const AValue: Int64): Int64;{$ifdef SYSTEMINLINE}inline;{$endif}
  begin
    {$IFDEF ENDIAN_BIG}
      Result := AValue;
    {$ELSE}
      Result := SwapEndian(AValue);
    {$ENDIF}
  end;

Y si inverso NtoBE():

delphi

function NtoBE(const AValue: Int64): Int64;{$ifdef SYSTEMINLINE}inline;{$endif}
  begin
    {$IFDEF ENDIAN_BIG}
      Result := AValue;
    {$ELSE}
      Result := SwapEndian(AValue);
    {$ENDIF}
  end;

La versión análoga para el caso de LE es casi idéntica. Lo que cambia es el IFDEF que en lugar de ser BIG es el ENDIAN_LITTLE.

 

Lo importante de todo, como pueden ver, es esa función de intercambio:

delphi

function SwapEndian(const AValue: LongInt): LongInt; assembler; nostackframe;
asm
{$ifdef win64}
  movl %ecx, %eax
{$else win64}
  movl %edi, %eax
{$endif win64}
  bswap %eax
end;
 
 
function SwapEndian(const AValue: DWord): DWord; assembler; nostackframe;
asm
{$ifdef win64}
  movl %ecx, %eax
{$else win64}
  movl %edi, %eax
{$endif win64}
  bswap %eax
end;
 
 
function SwapEndian(const AValue: Int64): Int64; assembler; nostackframe;
asm
{$ifdef win64}
  movq %rcx, %rax
{$else win64}
  movq %rdi, %rax
{$endif win64}
  bswap %rax
end;
 
 
function SwapEndian(const AValue: QWord): QWord; assembler; nostackframe;
asm
{$ifdef win64}
  movq %rcx, %rax
{$else win64}
  movq %rdi, %rax
{$endif win64}
  bswap %rax
end;

Mi objetivo es lograr algo parecido a eso, pero con los flotantes. A ver si con todo esto alguien puede darme más luz.

 

Saludos,

[enecumene]

Esta función lo tenía por ahí y creo que sirve para Big Endians con valores flotantes 4 bytes IEEE, espero te sirva:

delphi

function SwapEndian(value:single):single;
var
  h,i: TFloatRec;
begin
	h.floatvalue := value;
	i.bytevalues[0] := h.bytevalues[3];
	i.bytevalues[1] := h.bytevalues[2];
	i.bytevalues[2] := h.bytevalues[1];
	i.bytevalues[3] := h.bytevalues[0];
	result := i.floatvalue;
end;

[Delphius]

 

Esta función lo tenía por ahí y creo que sirve para Big Endians con valores flotantes 4 bytes IEEE, espero te sirva:

delphi

function SwapEndian(value:single):single;
var
  h,i: TFloatRec;
begin
	h.floatvalue := value;
	i.bytevalues[0] := h.bytevalues[3];
	i.bytevalues[1] := h.bytevalues[2];
	i.bytevalues[2] := h.bytevalues[1];
	i.bytevalues[3] := h.bytevalues[0];
	result := i.floatvalue;
end;

 

Gracias Fernando por esa muestra. ¿Por casualidad tienes la declaración del tipo TFloatRec?

 

En Lazarus existe un TFloatRec, pero quizá no sea el mismo que aparenta en tu código:

delphi

TFloatRec = Record
      Exponent: Integer;
      Negative: Boolean;
      Digits: Array[0..18] Of Char;
End;

Saludos,

[enecumene]

La que dispone de Delphi, tiene una pequeña diferencia:.

[Delphius]

Si, ya vi esa página. Y por eso te lo comento.

Porque evidentemente el TFloatRec de tu código es distinto, no tiene ningún campo con los nombres de tu ejemplo. Pareciera dar a entender algo como esto:

php

TFloatRec = record
floatvalue: single;
bytesvalues: array[0..3] of byte; // no estoy seguro del tipo!
end;

Algo me dice que TFloatRec es un registro variant, pero tu código no da pista de cual es el campo a modo de "bandera". Por lo general se hace algo así:

php

TRegistroVariant1 = record
case Campo: boolean of
true: (CampoX: tipoX)
false: (CampoY: tipoY)
end;

O algo como:

php

TRegistroVariant2 = record
case Campo: integer of
0: (Campo0: tipo0);
...
10: (Campo10: tipo10);
end;

Es decir, debe haber un campo que indique cual forma se va a emplear. La otra que quizá sea, es que quizá tenga puesta la cláusula absolute:

php

TFloatRec = record
floatvalue: single;
bytesvalues: array[0..3] of byte absolute floatvalue; // pero no estoy seguro si así es como se declararía
end;

Saludos,

[escafandra]

Yo no me preocuparía tanto por el tipo de dato.

Si recuerdas el tema del signo de un double en C, la función a bajo nivel que propuse era esta:

cpp

int Sign(double d)
{
  if(d==0) return 0;
  DWORD* R = (DWORD*)&d + 1;
  if(*R >> 31 & 1) return -1;
  return 1;
}

Esa función tiene en cuenta que los bytes están invertidos (little-endian) y que el tipo ocupa 64 bits. Lo primero que hace es buscar el segundo DWORD en memoria: (DWORD*)&d + 1. Puesto que al estar invertidos esa parte es la más significativa. Luego localiza el signo usando un simple desplazamiento.

 

Esto es así porque independientemente del tipo, los bytes están invertidos. Esta es la razón por la que no encuentras funciones SwapEndian que no reciban otra cosa que enteros. Un double es un "entero especial" de 64 bits en el que cada bit tiene un "significado especial" en la notación IEEE.

 

Las funciones que encontraste para Lazarus sirven para cualquier tipo numérico, solo debes conocer su tamaño y aplicar la que corresponda a cada caso.

 

Realiza algún experimento y nos cuentas.

 

PD/ Para el problema de leer y escribir números en un archivo que sea interpretable en cualquier plataforma, quizás lo más simple sea escribirlos en modo texto.

 

 

Saludos.

[Delphius]

Yo no me preocuparía tanto por el tipo de dato.

Si recuerdas el tema del signo de un double en C, la función a bajo nivel que propuse era esta:

cpp

int Sign(double d)
{
  if(d==0) return 0;
  DWORD* R = (DWORD*)&d + 1;
  if(*R >> 31 & 1) return -1;
  return 1;
}

Esa función tiene en cuenta que los bytes están invertidos (little-endian) y que el tipo ocupa 64 bits. Lo primero que hace es buscar el segundo DWORD en memoria: (DWORD*)&d + 1. Puesto que al estar invertidos esa parte es la más significativa. Luego localiza el signo usando un simple desplazamiento.

 

Esto es así porque independientemente del tipo, los bytes están invertidos. Esta es la razón por la que no encuentras funciones SwapEndian que no reciban otra cosa que enteros. Un double es un "entero especial" de 64 bits en el que cada bit tiene un "significado especial" en la notación IEEE.

 

Las funciones que encontraste para Lazarus sirven para cualquier tipo numérico, solo debes conocer su tamaño y aplicar la que corresponda a cada caso.

 

Realiza algún experimento y nos cuentas.

 

PD/ Para el problema de leer y escribir números en un archivo que sea interpretable en cualquier plataforma, quizás lo más simple sea escribirlos en modo texto.

 

 

Saludos.

 

En cuanto pueda darme un tiempo para hacer unas pruebas lo veo. Se que debería ser fácil la cosa... se trata de intercambiar la posición de bytes. Pero por algún motivo que no logro descifrar tal intercambio de bytes debe ser congruente y compatible a su vez con la función IsNan() y es que por ésta empecé a hacer pruebas de escritorio y me he dado algunos golpes de porqué algo no me estaba cuadrando.

 

Una de las primeras cosas que podría probar sería algo como:

delphi

function floatBEToN(AValue: Double): Double;
var IntDouble: Int64 absolute AValue; // tengo entendido que con absolute se consigue que la variable IntDouble apunte a la misma memoria concreta de AValue
begin
   result := Double(BEToN(IntDouble));
end;

O cosas como BetoN(Int64(AValue)) aunque tengo mis reservas de que algo así funcione apropiadamente.

 

Quizá sea como dices que al final de todo no interesa si los bytes que se leen hacen a un entero o un número flotante, pero para mi no estaría mal que se pudiera evitar indirecciones y casteos y que existan funciones que trabajen con los flotantes. Si fuera viable concebir una función floatSwapEndian() sería buenísimo.

 

Mi problema es que la mejor forma de saber que esto funciona sería usarlo esto mismo en un equipo BIG-ENDIAN pero yo no dispongo de uno.

 

Lo de guardar en modo texto también tiene sus cosas... el problema de encode a más de uno puede dejarlo desvelado.

 

Saludos,

[escafandra]

...

Quizá sea como dices que al final de todo no interesa si los bytes que se leen hacen a un entero o un número flotante, pero para mi no estaría mal que se pudiera evitar indirecciones y casteos y que existan funciones que trabajen con los flotantes. Si fuera viable concebir
 
Mi problema es que la mejor forma de saber que esto funciona sería usarlo esto mismo en un equipo BIG-ENDIAN pero yo no dispongo de uno. 
...

 
Ten en cuenta que al trabajar a bajo nivel es inevitable realizar cast de tipos mediante punteros. Puedes usar la versión de SwapEndian int64 con el cast necesario para crearte tu función para double y listo. Un simple cast y una llamada.

 

Tampoco dispongo de un equipo BIG-ENDIAN pero el análisis de lo que ocurre en memoria en nuestros equipos little-endian basta para ver el asunto de la conversión.

 

Saludos.

[Delphius]

 
Ten en cuenta que al trabajar a bajo nivel es inevitable realizar cast de tipos mediante punteros. Puedes usar la versión de SwapEndian int64 con el cast necesario para crearte tu función para double y listo. Un simple cast y una llamada.

 

Tampoco dispongo de un equipo BIG-ENDIAN pero el análisis de lo que ocurre en memoria en nuestros equipos little-endian basta para ver el asunto de la conversión.

 

Saludos.

 

¿Entonces lo que estuve pensando en vos alta sobre hacer un Int64(BEtoN) podría resultar?

Umm. Lo voy a ver. Anoche había probado descifrar la función IsNan() y en como es que lee la mitad y aplica el desplazo de bits para compararlo con el byte donde se localiza el exponente según el formato IEEE. No guardé esa prueba pero recuerdo que estuve haciendo estos tipos de cast, y mostraba en edits en forma binaria el Cards[1] antes y después de aplicar shr. El original tenía 13 bits 1, y el corrimiento tenía 12. Uno de los 1 pasó a ser 0. Me animo a jurarlo. Los conté 3 veces.

Probaba justamente con el valor Nan para que la prueba diera true.

Tendré que volver sobre mis pasos. Algo se me escapa.

 

A falta de equipo BIG-ENDIAN no queda más que probar y confiar en que el hacer un IntToHex() muestre la cosa perfectamente cambiada.

 

Saludos,

[escafandra]

Ahora que estoy en casa, te pongo un ejemplo de como implementar una versión Double de SwapEndian. El cast debe hacerse sobre punteros y no sobre valores:

delphi

function SwapEndianD(const AValue: Double): Double;
var
  I: Int64;
begin
  I:= SwapEndian(Pint64(@AValue)^);
  Result:= PDouble(@I)^;
end;

Saludos.