Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Re: [Caml-list] Troubles with marshaled/unmarshaled exception #8399

Closed
vicuna opened this issue Dec 4, 2003 · 1 comment
Closed

Re: [Caml-list] Troubles with marshaled/unmarshaled exception #8399

vicuna opened this issue Dec 4, 2003 · 1 comment

Comments

@vicuna
Copy link

vicuna commented Dec 4, 2003

Original bug ID: 1961
Reporter: administrator
Status: closed (set by @xclerc on 2009-09-16T12:45:50Z)
Resolution: won't fix
Priority: normal
Severity: feature
Category: ~DO NOT USE (was: OCaml general)
Has duplicate: #4978
Related to: #7413

Bug description

The short answer is: don't marshal exceptions.

The longer answer is that exception marshaling is nearly as hard as
function/closure marshaling. I'm sure the OCaml implementors can give a
more precise description, but here is my understanding.

First,
1. A program can have a large number of exceptions.
2. Exception names are scoped. The following exceptions
A.Foo and B.Foo are different. The same holds for
compilation units/files that are separately compiled.

   module A = struct exception Foo end
   module B = struct exception Foo end

Just like normal unions, the exceptions are eventually represented as a
block with a tag and some values, but exception tags are resolved at
link time.

This explains why you can't marshal an exception in one process, send it
over a channel, unmarshal it in another process, and expect it to make
any sense at all, because the linker's tag selection is likely to be
different in the two processes.

Why doesn't it work within the same process? This is most likely
because the exception tag is a (pointer to a) normal OCaml value, but
pattern matching on the exception value uses pointer equality for the
tag. When you marshal/unmarshal, you deep-copy the tag, and pointer
equality no longer works (though normal equality works just fine).
There are excellent implementation reasons to use pointer equality on
tags; and faithfulness of marshaling is a low priority.

So, it is likely the marshaler could be changed so that exception
marshaling would work as you might expect, but it would be hard, and not
very worthwhile. Don't expect exception marshaling to work in a
portable manner...

Jason

Artem Prisyznuk wrote:

Hello,

I found strange behavior of pattern matching of
marshaled/unmarshaled exception.

Next code describe problem:

let e = Failure "test";;
let e' = Marshal.from_string (Marshal.to_string e []) 0;;
let print_fun exc =
  match exc with
    Failure _ -> print_endline "Matching OK"
  | exc -> print_endline "Matching Fail";;

print_fun e;;
print_fun e';;
  Printf.printf "e = e' is %b\n" (e=e');;

Output:

Matching OK
Matching Fail
  e = e' is true

So second call print missing value.

--
Jason Hickey http://www.cs.caltech.edu/~jyh
Caltech Computer Science Tel: 626-395-6568 FAX: 626-792-4257

@vicuna
Copy link
Author

vicuna commented Dec 8, 2003

Comment author: administrator

answer to #8396

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Projects
None yet
Development

No branches or pull requests

1 participant