[JAVA] aiuto per conversione little endian big endian

[vatastala]

Ciao a tutti, ho il seguente problema: devo convertire un file con dei pesi codificati in double da Java per essere letti tramite C++. SIccome mi è stato detto che Java utilizza il sistema little endian e C++ big endian (o viceversa???) ho scritto il seguente codice:

static double var;
/**
* @param args the command line arguments
*/
public static void main(String[] args) throws NullPointerException {

try{

DataInputStream dis = new DataInputStream(new FileInputStream ("weights.dat"));

ByteBuffer bb = ByteBuffer.allocate(9000);
// bb.order(ByteOrder.LITTLE_ENDIAN);

for(int i=0;i<896.;i++)
{
var=dis.readDouble();
bb.order(ByteOrder.BIG_ENDIAN);
bb.putDouble(i,var);
System.out.println(var +"__"+ bb.order(ByteOrder.BIG_ENDIAN).getDouble(i) +"__"+i);
}


E questo è l'output relativo:

0.009182359616844394__0.009182359616844394__0
-0.002138954759412613__-0.002138954759412613__1
0.005195382598750681__0.005195382598750681__2
4.819424459599818__4.819424459599818__3
5.058553871334569__5.058553871334569__4
1.0871459521596347__1.0871459521596347__5
-1.0868843071228302__-1.0868843071228302__6
-0.0016712652843744874__-0.0016712652843744874__7
0.0012012366699741682__0.0012012366699741682__8
-0.001529889658280872__-0.001529889658280872__9
2.295218951725268__2.295218951725268__10


I valori sono quindi gli stessi, sapete indicarmi il problema???

[andbin]

Originariamente inviato da vatastala

SIccome mi è stato detto che Java utilizza il sistema little endian e C++ big endian (o viceversa???)

Non diciamo fesserie ...

Non è il linguaggio ad essere little/big-endian! Se parliamo dei dati memorizzati in memoria, allora centra solamente il processore. I processori x86 sono little-endian. Altre famiglie di processori possono avere un altro tipo di endian o possono gestire entrambi i modi (vedi PowerPC, se non sbaglio).

Se parliamo di dati scritti/inviati da qualunque altra parte (su file, su socket, ecc...) allora bisogna vedere le specifiche o comunque stabilire la questione del endian. È chiaro che le due parti devono "accordarsi" sul formato.

Java ha delle classi apposite DataOutputStream e DataInputStream per scrivere/leggere dei dati di diversi tipi in maniera indipendente dalla piattaforma. Queste classi scrivono/leggono dati in formato big-endian. In qualunque caso e su qualunque piattaforma. Questa è la specifica di queste classi.

Se con Java scrivo su file usando DataOutputStream, i tipi primitivi nel file saranno quindi in formato big-endian. Se voglio leggere questo file con un altro linguaggio (es. C++) su una qualunque piattaforma, dovrò sapere che i dati mi arrivano prima con il byte più significativo.

[vatastala]

Ho scritto in c++ un piccolo codice per fare vedere come viene letto il file dei pesi:

void leggiParametri()
{
FILE *file=fopen("weights.dat","r");

double input;

for(int i=0;i<10;i++){
fscanf(file,"%f",input);

// input=atoi(inputs);
cout << input <<endl;
}

fclose(file);

}


E l'output è:

2.36584e-310
2.36584e-310
2.36584e-310
2.36584e-310
2.36584e-310
2.36584e-310
2.36584e-310
2.36584e-310
2.36584e-310
2.36584e-310

Sempre lo stesso quindi...

[andbin]

Originariamente inviato da vatastala

FILE *file=fopen("weights.dat","r");

double input;

for(int i=0;i<10;i++){
fscanf(file,"%f",input);

No, non ci siamo proprio!!! fscanf legge da file di testo, non binari.
Cioè per poter leggere con questa funzione, il file deve contenere la rappresentazione testuale del numero. Un valore di 12.3 deve essere rappresentato nel file con 4 caratteri '1' poi '2', poi il punto, poi '3'.

Se hai dei dati binari (come quelli scritti da DataOutputStream di Java) la lettura va fatta in tutt'altro modo.

Facciamo un esempio: supponiamo che un file contenga dati di tipo double scritti dalla classe DataOutputStream di Java (quindi sempre big-endian). Si vuole leggere i dati usando il linguaggio "C" su una piattaforma little-endian (tra poco vedremo il perché di questa precisazione):

#include <stdio.h>

void swap_endian_double (double *pd)
{
    char *p = (char*) pd;
    char t;

    t = p[0];  p[0] = p[7];  p[7] = t;
    t = p[1];  p[1] = p[6];  p[6] = t;
    t = p[2];  p[2] = p[5];  p[5] = t;
    t = p[3];  p[3] = p[4];  p[4] = t;
}

int main (void)
{
    char buf[8];
    double val;
    FILE *f;

    if ((f = fopen ("dati.bin", "rb")) != NULL)
    {
        if (fread (buf, 1, 8, f) == 8)
        {
            val = *((double*) buf);
            swap_endian_double (&val);
            printf ("val = %f\n", val);
        }

        fclose (f);
    }

    return 0;
}

Lavorando in "C", posso sfruttare i puntatori e fare in modo che l'indirizzo dell'array di 8 char venga visto come un puntatore a double, quindi dereferenziato per ottenere il valore double.

Se l'architettura è little-endian, devo swappare il double (quindi uso la swap_endian_double). Se l'architettura fosse big-endian, lo swap non servirebbe, perché i dati letti dal file e depositati nell'array sarebbero già nell'ordine adatto per un processore big-endian.

Spero di aver chiarito la questione!

Vedere anche in <questo> thread, dove si parlava proprio dell'endian.