[Caml-list] questions about marshalling

[Caml-list] questions about marshalling

[eijiro_sumii]

I have questions about marshaling in ocaml-3.0x:

(1) Is it safe to marshal values of a statically polymorphic type, like

      let f x = Marshal.to_channel outchan (x, x) [Marshal.Closures]

    for example, provided that the marshaled values will be unmarshaled as
    values of the right types at runtime?

(2) Is it safe to *un*marshal a value at a statically polymorphic type
    and use it later at a statically monomorphic type, like

      let g x = fst x
      let y : int = g (Marshal.from_channel inchan)

    for example, provided that the value has the right type at runtime?

My guess is that both of these are safe, even though the document says

  The programmer should explicitly give the expected type of the
  returned value, using the following syntax: `(Marshal.from_channel
  chan : type)'.

because the (un)marshaling function itself works on the basis of the
runtime tag rather than the static type of a value -- a catastrophe
may be caused *later* when the value is actually used at a wrong type.
Am I correct?

(3) Yet another question: in a program using marhsaling (via ocamlmpi,
    actually), I get the following error:

      Fatal error: uncaught exception Failure("input_value: ill-formed message")

    What does this mean?  I am quite sure that all the hosts are
    running the same binary, and I am using only ocamlmpi for
    communication.  Does this necessarily mean that I gave a wrong
    type for the unmarshaled value (in Mpi.receive, to be specific),
    or are there other possibilities?  It seems that this assertion
    failure occurs at line 272 in byterun/intern.c, examining the
    runtime tag of the value.

Many thanks in advance,

   Eijiro
-------------------
To unsubscribe, mail caml-list-request@inria.fr.  Archives: http://caml.inria.fr

Re: [Caml-list] questions about marshalling

[Xavier Leroy]

> (1) Is it safe to marshal values of a statically polymorphic type, like
> 
>       let f x = Marshal.to_channel outchan (x, x) [Marshal.Closures]
> 
>     for example, provided that the marshaled values will be unmarshaled as
>     values of the right types at runtime?

Yes, it is safe.

> (2) Is it safe to *un*marshal a value at a statically polymorphic type
>     and use it later at a statically monomorphic type, like
> 
>       let g x = fst x
>       let y : int = g (Marshal.from_channel inchan)
> 
>     for example, provided that the value has the right type at runtime?

Again, provided the run-time type is correct, this is safe.

> My guess is that both of these are safe, even though the document says
> 
>   The programmer should explicitly give the expected type of the
>   returned value, using the following syntax: `(Marshal.from_channel
>   chan : type)'.
> 
> because the (un)marshaling function itself works on the basis of the
> runtime tag rather than the static type of a value -- a catastrophe
> may be caused *later* when the value is actually used at a wrong type.
> Am I correct?

Yes.  The documentation perhaps needs to be worded differently.
Constraining immediately the return value of Marshal.from_channel to
the correct type is a good way to reduce the probability of
programming errors induced by the fake polymorphic type of this
function, but it is not an absolute requirement.

> (3) Yet another question: in a program using marhsaling (via ocamlmpi,
>     actually), I get the following error:
> 
>   Fatal error: uncaught exception Failure("input_value: ill-formed message")
> 
>     What does this mean?  I am quite sure that all the hosts are
>     running the same binary, and I am using only ocamlmpi for
>     communication.  Does this necessarily mean that I gave a wrong
>     type for the unmarshaled value (in Mpi.receive, to be specific),
>     or are there other possibilities?

No, this is not a "wrong type" error.  It means that the binary data
given to the unmarshaler is not valid, e.g. was not produced by the
marshaller, or got corrupted, or truncated, or padded, or whatever
change, during transmission.  This might indicate a bug in ocamlmpi,
or a problem in the underlying MPI implementation or transport layers.

If you have a test program that reproduces the error, you can send it
to me and I'll have a look.

Hope this helps,

- Xavier Leroy
-------------------
To unsubscribe, mail caml-list-request@inria.fr.  Archives: http://caml.inria.fr