What are the performance characteristics of sending big messages in Distributed Erlang?

Suppose I create new local process in an Erlang application, and i want to send to it a big message.

-module(chain_hello). 

start(N, Some_big_data)->                                    
   Pid1 = spawn(chain_hello, some_fun, [N]),
   Pid1 ! Some_big_data,
   io:format("done \n").

despite Some_big_data is a reference to rea开发者_如何转开发lly big data (eg. content of a file) - is it copied when sending? Are there big penalties for performance?

Normally I would use some thread safe shared object (and/or mutex). Is there any solution in Erlang to avoid copying message content?

ADDED:

Interesting case is when Some_big_data is structured content - to be specific: map, on which I can perform some operations.

ADDED2

Ok, I see there is no such solution for Erlang (sharing some structured data like map in worker process) - because of Erlang design. But I think it is justified by solid work, and easily concurrence management.

---

From the Erlang Efficiency Guide:

All data in messages between Erlang processes is copied, with the exception of refc binaries on the same Erlang node.

Yes, you should avoid sending big terms between processes. If you need to send a lot of data, send it as a binary.

---

As a suggestion, you can send only the pid of the current process (self()) to the process that you want to handle that some_big_data. That way, when you want to use that some_big_data, you can reference it back to it from the 2nd process.

For instance:

-module(proc1).

send_big_data() ->
  BigData = get_some_big_data(),
  Pid = spawn(fun proc2:start/0),
  Pid ! {process_big_data, self()},
  loop(Pid, BigData).

loop(Pid,BigData) ->
  receive
    get_first_element ->
      [H|T] = BigData,
      Pid ! {response, H};
    _ ->
      Pid ! {nothing}
   end,
   loop(Pid).

(Sorry for the eventual syntax mistakes).