files or pipes use for data exchange? or something else?

[Marco Driusso]

Dear all,
I'm embedding octave in a c++ program. I use the octave_embed packet to
initialize and call the octave functions I need, but in this packet I
haven't found a way to pass to octave my c++ variables. My first own
solution was:
- c++ code -> octave: convert my double arrays in string and evaluate them
with the octave_embed's
octave_call(char*)
so the evaluated strings became variables in the octave workspace;
- octave -> c++ code: save the elaborated variables in a file with the
octave's save and read them from the c++ code with operator >>.

In my c++ program I have to call the octave functions many times, so this
way was not efficient (because implies write and read into/from the file
sistem many times). So I thought that using named pipes (fifos) was a better
solution:
- c++ code -> octave:

    FILE* fifoW;
    pid_t pid=fork();

    if(pid==0)
    {
        fifoW=fopen("/../fifo","w");
        fwrite(datas,sizeof(double),tot,fifoW);//datas is a double array of
dimentions tot
        fclose(fifoW);
        exit(1);
    }
    else if(pid>0)
    {
        octave_call("fifoR = fopen(\"/../fifo\",\"r\");");
        octave_call("data=fread(fifoR,\"double\")");
        octave_call("fclose(fifoR);");
    }

- octave -> c++ code:
    FILE* fifoR;
    pid_t pid=fork();

    if(pid==0)
    {
        octave_call("fifoW = fopen(\"/../fifo\",\"w\");");
        octave_call("scrivo = fwrite(fifoW,elData,\"double\");");
        octave_call("fclose(fifoW);");
        exit(1);
    }
    else if(pid>0)
    {
        fifoR=fopen("/../fifo","r");
        fread(elData,sizeof(double),dim,fifoR);//elData is a double array of
diment dim
        fclose(fifoR);
    }
(I've omitted all error check). Timing this and the other solution I've
founded that the pipe solution is slower than the file solution and I don't
know why. The two solution take similar times when the dimentions of the
arrays became bigger (but the file solution remane faster than the  pipe
solution). The questions are:
-Does anyone know why pipes are in this case slower than files?
-Has anyone a better solution than pipes or files?
Thanks.

Marco
-------------- next part --------------
An HTML attachment was scrubbed...
URL: https://www-old.cae.wisc.edu/pipermail/help-octave/attachments/20090324/d95c206a/attachment.html