if you do not care about non-Python languages you could also use "pickle" or use Numpy.load/save directly via io.BytesIO
Actually, looking at the code closer, socket.send(A, ...) I'm not sure how A is sent. maybe via pickle serialization
I'd figure out is non-Python code ever needs to be involved. If so, I'd not use a Python-specific serialization.
it's hard to say about performance without testing. often, things I think will be slow are not and vice versa.
what is the general application meant for?
as for SNDMORE vs packing, I don't think there's all that much difference. SNDMORE will make zeromq do the packing instead of your own code.
no. SNDMORE and use of JSON are orthogonal
SNDMORE tells zeromq you want to make a "multi part message"
on the wire a multi-part message looks like: [size|bytes][size|bytes] where each size gives the size of the bytes part.
without SNDMORE the message is simply "single part"
with JSON the bytes part is filled specifically with JSON text
so, I can send a single part message holding JSON or I can send a multi-part message with each part holding JSON (or some other format). the two choices are independent / orthogonal
Both sendmore and json can be used to implement message protocols.
though, you need not use sendmore. the "draft" sockets like SERVER/CLIENT do not even support multi-part messages.
and anytime you want something like multiple parts, you can always create them at the application layer
I doubt it. Both have been around for a long time. Is nanomsg even maintained anymore?
nanomsg has had one set of commits this year. so it's not neglected.
It was a question. Then, I checked it's github and see one group of commits this year. So, it seems still maintained.
yes and no. it has message queues inside each of its socket. but many people hear "message queue" and they think "centralized message broker". zeromq is NOT that, but zeromq can be used to make "centralized message brokers".
we can see many blogs or articles comparing zeromq and rabbitmq and other "centralized message brokers". These are "apples and oranges" comparisons. A more correct comparison would be "zeromq" (or nanomsg) and BSD sockets.
Is zeromq still being maintained? Does it support rmda?
zeromq is being maintained and new language bindings are in healthy development
I don't know about rdma. but I know that stock zeromq can saturate 25 Gbps and with more I/O threads can saturate 100 Gbps.
could you show some examples?
however, this leads to out-of-order messages which must then be handled by the application layer
easier would be to use multiple sockets
in the wiki there is some tests of 100 Gbps but since the hack that's not available
I have an informal report of a test I did
libzmq has latency and throughput test programs in the source tree. I also wrote my own https://github.com/brettviren/zperfmq
I don't think I've seen a test at 200 Gbps yet so if you test please share your results.