void *
zctx__socket_new (zctx_t *self, int type)
{
// Initialize context now if necessary
assert (self);
zmutex_lock (self->mutex);
if (!self->context)
self->context = zmq_init (self->iothreads);
zmutex_unlock (self->mutex);
if (!self->context)
return NULL;
// Create and register socket
void *zocket = zmq_socket (self->context, type);
if (!zocket)
return NULL;
#if (ZMQ_VERSION_MAJOR == 2)
// For ZeroMQ/2.x we use sndhwm for both send and receive
zsocket_set_hwm (zocket, self->sndhwm);
#else
// For later versions we use separate SNDHWM and RCVHWM
zsocket_set_sndhwm (zocket, self->sndhwm);
zsocket_set_rcvhwm (zocket, self->rcvhwm);
#endif
zmutex_lock (self->mutex);
if (zlist_push (self->sockets, zocket)) {
zmutex_unlock (self->mutex);
zmq_close (zocket);
return NULL;
}
zmutex_unlock (self->mutex);
return zocket;
}
static rsRetVal initZMQ(instanceData* pData) {
DEFiRet;
/* create the context if necessary. */
if (NULL == s_context) {
zsys_handler_set(NULL);
s_context = zctx_new();
if (s_workerThreads > 0) zctx_set_iothreads(s_context, s_workerThreads);
}
pData->socket = zsocket_new(s_context, pData->type);
if (NULL == pData->socket) {
errmsg.LogError(0, RS_RET_NO_ERRCODE,
"omzmq3: zsocket_new failed for %s: %s",
pData->description, zmq_strerror(errno));
ABORT_FINALIZE(RS_RET_NO_ERRCODE);
}
/* use czmq defaults for these, unless set to non-default values */
if(pData->identity) zsocket_set_identity(pData->socket, (char*)pData->identity);
if(pData->sndBuf > -1) zsocket_set_sndbuf(pData->socket, pData->sndBuf);
if(pData->rcvBuf > -1) zsocket_set_sndbuf(pData->socket, pData->rcvBuf);
if(pData->linger > -1) zsocket_set_linger(pData->socket, pData->linger);
if(pData->backlog > -1) zsocket_set_backlog(pData->socket, pData->backlog);
if(pData->sndTimeout > -1) zsocket_set_sndtimeo(pData->socket, pData->sndTimeout);
if(pData->rcvTimeout > -1) zsocket_set_rcvtimeo(pData->socket, pData->rcvTimeout);
if(pData->maxMsgSize > -1) zsocket_set_maxmsgsize(pData->socket, pData->maxMsgSize);
if(pData->rate > -1) zsocket_set_rate(pData->socket, pData->rate);
if(pData->recoveryIVL > -1) zsocket_set_recovery_ivl(pData->socket, pData->recoveryIVL);
if(pData->multicastHops > -1) zsocket_set_multicast_hops(pData->socket, pData->multicastHops);
if(pData->reconnectIVL > -1) zsocket_set_reconnect_ivl(pData->socket, pData->reconnectIVL);
if(pData->reconnectIVLMax > -1) zsocket_set_reconnect_ivl_max(pData->socket, pData->reconnectIVLMax);
if(pData->ipv4Only > -1) zsocket_set_ipv4only(pData->socket, pData->ipv4Only);
if(pData->affinity != 1) zsocket_set_affinity(pData->socket, pData->affinity);
if(pData->rcvHWM > -1) zsocket_set_rcvhwm(pData->socket, pData->rcvHWM);
if(pData->sndHWM > -1) zsocket_set_sndhwm(pData->socket, pData->sndHWM);
/* bind or connect to it */
if (pData->action == ACTION_BIND) {
/* bind asserts, so no need to test return val here
which isn't the greatest api -- oh well */
if(-1 == zsocket_bind(pData->socket, (char*)pData->description)) {
errmsg.LogError(0, RS_RET_NO_ERRCODE, "omzmq3: bind failed for %s: %s",
pData->description, zmq_strerror(errno));
ABORT_FINALIZE(RS_RET_NO_ERRCODE);
}
DBGPRINTF("omzmq3: bind to %s successful\n",pData->description);
} else {
if(-1 == zsocket_connect(pData->socket, (char*)pData->description)) {
errmsg.LogError(0, RS_RET_NO_ERRCODE, "omzmq3: connect failed for %s: %s",
pData->description, zmq_strerror(errno));
ABORT_FINALIZE(RS_RET_NO_ERRCODE);
}
DBGPRINTF("omzmq3: connect to %s successful", pData->description);
}
finalize_it:
RETiRet;
}
/**
* Connect the given socket to the given binding
* @param socket
* An existing socket
* @param binding
* A string binding
* @return
* If connection was successful
*/
bool BoomStick::ConnectToBinding(void* socket, const std::string& binding) {
if (nullptr == socket) {
return false;
}
zsocket_set_sndhwm(socket, mSendHWM);
zsocket_set_rcvhwm(socket, mRecvHWM);
return (zsocket_connect(socket, binding.c_str()) >= 0);
}
int main(int argc, char const * const *argv)
{
int rc;
zctx_t *context = zctx_new();
assert(context);
zctx_set_rcvhwm(context, 1000);
zctx_set_linger(context, 100);
void *socket = zsocket_new(context, ZMQ_PULL);
assert(socket);
zsocket_set_rcvhwm(socket, 100000);
zsocket_set_linger(socket, 500);
zsocket_set_reconnect_ivl(socket, 100); // 100 ms
zsocket_set_reconnect_ivl_max(socket, 10 * 1000); // 10 s
const char* host = "localhost";
if (argc>1) host = argv[1];
rc = zsocket_connect(socket, "tcp://%s:9651", host);
assert(rc==0);
zmsg_t *msg = NULL;
size_t received = 0;
size_t lost = 0;
size_t last_num = 0;
while (1) {
msg = zmsg_recv(socket);
if (zsys_interrupted)
break;
assert(msg);
received++;
// assert(zmsg_size(msg) == 3);
// zmsg_dump(msg);
zframe_t *last_frame = zmsg_last(msg);
char *str = zframe_strdup(last_frame);
size_t n = atol(str);
free(str);
if (n > last_num + 1 && last_num != 0) {
lost += n - (last_num + 1);
}
last_num = n;
zmsg_destroy(&msg);
}
zsocket_destroy(context, socket);
zctx_destroy(&context);
printf("\nlost: %7zu\nreceived: %7zu\n", lost, received);
return 0;
}
void *new_socket(zctx_t *ctx, int stype)
{
void *s;
s = zsocket_new(ctx, stype);
assert(s);
zsocket_set_linger(s, 0);
zsocket_set_sndhwm(s, 100000);
zsocket_set_rcvhwm(s, 100000);
return(s);
}
/**
* Setup the location to receive messages.
* @param location
*/
void Alien::PrepareToBeShot(const std::string& location) {
//Subscribe to everything
char dummy = '\0';
zsocket_set_subscribe(mBody, &dummy);
zsocket_set_rcvhwm(mBody, 32 * 1024);
zsocket_set_sndhwm(mBody, 32 * 1024);
int rc = zsocket_connect(mBody, location.c_str());
if (rc == -1) {
LOG(WARNING) << "location: " << location;
LOG(WARNING) << "connect socket rc == " << rc;
throw std::string("Failed to connect to socket");
}
}
static rsRetVal initZMQ(instanceData* pData) {
DEFiRet;
/* create the context if necessary. */
if (NULL == s_context) {
s_context = zctx_new();
if (s_workerThreads > 0) zctx_set_iothreads(s_context, s_workerThreads);
}
pData->socket = zsocket_new(s_context, pData->type);
/* ALWAYS set the HWM as the zmq3 default is 1000 and we default
to 0 (infinity) */
zsocket_set_rcvhwm(pData->socket, pData->rcvHWM);
zsocket_set_sndhwm(pData->socket, pData->sndHWM);
/* use czmq defaults for these, unless set to non-default values */
if(pData->identity) zsocket_set_identity(pData->socket, (char*)pData->identity);
if(pData->sndBuf > -1) zsocket_set_sndbuf(pData->socket, pData->sndBuf);
if(pData->rcvBuf > -1) zsocket_set_sndbuf(pData->socket, pData->rcvBuf);
if(pData->linger > -1) zsocket_set_linger(pData->socket, pData->linger);
if(pData->backlog > -1) zsocket_set_backlog(pData->socket, pData->backlog);
if(pData->sndTimeout > -1) zsocket_set_sndtimeo(pData->socket, pData->sndTimeout);
if(pData->rcvTimeout > -1) zsocket_set_rcvtimeo(pData->socket, pData->rcvTimeout);
if(pData->maxMsgSize > -1) zsocket_set_maxmsgsize(pData->socket, pData->maxMsgSize);
if(pData->rate > -1) zsocket_set_rate(pData->socket, pData->rate);
if(pData->recoveryIVL > -1) zsocket_set_recovery_ivl(pData->socket, pData->recoveryIVL);
if(pData->multicastHops > -1) zsocket_set_multicast_hops(pData->socket, pData->multicastHops);
if(pData->reconnectIVL > -1) zsocket_set_reconnect_ivl(pData->socket, pData->reconnectIVL);
if(pData->reconnectIVLMax > -1) zsocket_set_reconnect_ivl_max(pData->socket, pData->reconnectIVLMax);
if(pData->ipv4Only > -1) zsocket_set_ipv4only(pData->socket, pData->ipv4Only);
if(pData->affinity != 1) zsocket_set_affinity(pData->socket, pData->affinity);
/* bind or connect to it */
if (pData->action == ACTION_BIND) {
/* bind asserts, so no need to test return val here
which isn't the greatest api -- oh well */
zsocket_bind(pData->socket, (char*)pData->description);
} else {
if(zsocket_connect(pData->socket, (char*)pData->description) == -1) {
errmsg.LogError(0, RS_RET_SUSPENDED, "omzmq3: connect failed!");
ABORT_FINALIZE(RS_RET_SUSPENDED);
}
}
finalize_it:
RETiRet;
}
void *
zsys_socket (int type, const char *filename, size_t line_nbr)
{
// First time initialization; if the application is mixing
// its own threading calls with zsock, this may fail if two
// threads try to create sockets at the same time. In such
// apps, they MUST create a socket in the main program before
// starting any threads. If the app uses zactor for its threads
// then we can guarantee this to always be safe.
zsys_init ();
ZMUTEX_LOCK (s_mutex);
void *handle = zmq_socket (s_process_ctx, type);
// Configure socket with process defaults
zsocket_set_linger (handle, (int) s_linger);
#if (ZMQ_VERSION_MAJOR == 2)
// For ZeroMQ/2.x we use sndhwm for both send and receive
zsocket_set_hwm (handle, s_sndhwm);
#else
// For later versions we use separate SNDHWM and RCVHWM
zsocket_set_sndhwm (handle, (int) s_sndhwm);
zsocket_set_rcvhwm (handle, (int) s_rcvhwm);
# if defined (ZMQ_IPV6)
zsocket_set_ipv6 (handle, s_ipv6);
# else
zsocket_set_ipv4only (handle, s_ipv6 ? 0 : 1);
# endif
#endif
// Add socket to reference tracker so we can report leaks; this is
// done only when the caller passes a filename/line_nbr
if (filename) {
s_sockref_t *sockref = (s_sockref_t *) malloc (sizeof (s_sockref_t));
sockref->handle = handle;
sockref->type = type;
sockref->filename = filename;
sockref->line_nbr = line_nbr;
zlist_append (s_sockref_list, sockref);
}
s_open_sockets++;
ZMUTEX_UNLOCK (s_mutex);
return handle;
}
void *zeromq_create_socket (zctx_t *context, const char *endpoint, int type,
const char *topic, bool connect, int linger, int hwm)
{
void *socket = NULL;
assert(context);
assert(endpoint);
if (endpoint[0] == 0) {
errorLog("Trying to open NULL output socket !");
return NULL;
}
socket = zsocket_new (context, type);
if (hwm != -1) {
zsocket_set_sndhwm (socket, hwm);
zsocket_set_rcvhwm (socket, hwm);
}
if (linger != -1) {
zsocket_set_linger (socket, linger);
} else { // Set linger to 0 as default, safety measure
zsocket_set_linger (socket, 0);
}
// Allow for exponential backoff: up to 5 minutes and 1s minimum
zsocket_set_reconnect_ivl(socket, 1 * 1000);
zsocket_set_reconnect_ivl_max(socket, 5 * 60 * 1000);
if (type == ZMQ_SUB)
zsocket_set_subscribe (socket, (char*)(topic == NULL ? "" : topic));
if (connect) {
zsocket_connect (socket, "%s", endpoint);
} else {
zsocket_bind (socket, "%s", endpoint);
}
return socket;
}
mq_socket_t *zero_create_simple_router_socket(mq_socket_context_t *ctx)
{
mq_socket_t *s;
tbx_type_malloc_clear(s, mq_socket_t, 1);
s->type = MQ_SIMPLE_ROUTER;
s->arg = zsocket_new((zctx_t *)ctx->arg, ZMQ_ROUTER);
zsocket_set_linger(s->arg, 0);
zsocket_set_sndhwm(s->arg, 100000);
zsocket_set_rcvhwm(s->arg, 100000);
s->destroy = zero_native_destroy;
s->bind = zero_native_bind;
s->connect = zero_native_connect;
s->disconnect = zero_native_disconnect;
s->poll_handle = zero_native_poll_handle;
s->monitor = zero_native_monitor;
s->send = zero_native_send;
s->recv = zero_simple_router_recv;
return(s);
}
void
zsocket_set_hwm (void *self, int hwm)
{
zsocket_set_sndhwm (self, hwm);
zsocket_set_rcvhwm (self, hwm);
}
static rsRetVal createSocket(socket_info* info, void** sock) {
size_t ii;
int rv;
*sock = zsocket_new(s_context, info->type);
if (!sock) {
errmsg.LogError(0,
RS_RET_INVALID_PARAMS,
"zsocket_new failed: %s, for type %d",
strerror(errno),info->type);
/* DK: invalid params seems right here */
return RS_RET_INVALID_PARAMS;
}
/* Set options *before* the connect/bind. */
if (info->identity) zsocket_set_identity(*sock, info->identity);
if (info->sndBuf > -1) zsocket_set_sndbuf(*sock, info->sndBuf);
if (info->rcvBuf > -1) zsocket_set_rcvbuf(*sock, info->rcvBuf);
if (info->linger > -1) zsocket_set_linger(*sock, info->linger);
if (info->backlog > -1) zsocket_set_backlog(*sock, info->backlog);
if (info->sndTimeout > -1) zsocket_set_sndtimeo(*sock, info->sndTimeout);
if (info->rcvTimeout > -1) zsocket_set_rcvtimeo(*sock, info->rcvTimeout);
if (info->maxMsgSize > -1) zsocket_set_maxmsgsize(*sock, info->maxMsgSize);
if (info->rate > -1) zsocket_set_rate(*sock, info->rate);
if (info->recoveryIVL > -1) zsocket_set_recovery_ivl(*sock, info->recoveryIVL);
if (info->multicastHops > -1) zsocket_set_multicast_hops(*sock, info->multicastHops);
if (info->reconnectIVL > -1) zsocket_set_reconnect_ivl(*sock, info->reconnectIVL);
if (info->reconnectIVLMax > -1) zsocket_set_reconnect_ivl_max(*sock, info->reconnectIVLMax);
if (info->ipv4Only > -1) zsocket_set_ipv4only(*sock, info->ipv4Only);
if (info->affinity > -1) zsocket_set_affinity(*sock, info->affinity);
/* since HWM have defaults, we always set them. No return codes to check, either.*/
zsocket_set_sndhwm(*sock, info->sndHWM);
zsocket_set_rcvhwm(*sock, info->rcvHWM);
/* Set subscriptions.*/
if (info->type == ZMQ_SUB) {
for (ii = 0; ii < sizeof(info->subscriptions)/sizeof(char*); ++ii)
zsocket_set_subscribe(*sock, info->subscriptions[ii]);
}
/* Do the bind/connect... */
if (info->action==ACTION_CONNECT) {
rv = zsocket_connect(*sock, info->description);
if (rv < 0) {
errmsg.LogError(0,
RS_RET_INVALID_PARAMS,
"zmq_connect using %s failed: %s",
info->description, strerror(errno));
return RS_RET_INVALID_PARAMS;
}
} else {
rv = zsocket_bind(*sock, info->description);
if (rv <= 0) {
errmsg.LogError(0,
RS_RET_INVALID_PARAMS,
"zmq_bind using %s failed: %s",
info->description, strerror(errno));
return RS_RET_INVALID_PARAMS;
}
}
return RS_RET_OK;
}
int
zsockopt_test (bool verbose)
{
printf (" * zsockopt: ");
// @selftest
zctx_t *ctx = zctx_new ();
assert (ctx);
void *zocket;
#if (ZMQ_VERSION_MAJOR == 2)
# if defined (ZMQ_HWM)
zocket = zsocket_new (ctx, ZMQ_SUB);
assert (zocket);
zsocket_set_hwm (zocket, 1);
assert (zsocket_hwm (zocket) == 1);
zsocket_hwm (zocket);
zsocket_destroy (ctx, zocket);
# endif
# if defined (ZMQ_SWAP)
zocket = zsocket_new (ctx, ZMQ_SUB);
assert (zocket);
zsocket_set_swap (zocket, 1);
assert (zsocket_swap (zocket) == 1);
zsocket_swap (zocket);
zsocket_destroy (ctx, zocket);
# endif
# if defined (ZMQ_AFFINITY)
zocket = zsocket_new (ctx, ZMQ_SUB);
assert (zocket);
zsocket_set_affinity (zocket, 1);
assert (zsocket_affinity (zocket) == 1);
zsocket_affinity (zocket);
zsocket_destroy (ctx, zocket);
# endif
# if defined (ZMQ_IDENTITY)
zocket = zsocket_new (ctx, ZMQ_SUB);
assert (zocket);
zsocket_set_identity (zocket, "test");
char *identity = zsocket_identity (zocket);
assert (identity);
free (identity);
zsocket_destroy (ctx, zocket);
# endif
# if defined (ZMQ_RATE)
zocket = zsocket_new (ctx, ZMQ_SUB);
assert (zocket);
zsocket_set_rate (zocket, 1);
assert (zsocket_rate (zocket) == 1);
zsocket_rate (zocket);
zsocket_destroy (ctx, zocket);
# endif
# if defined (ZMQ_RECOVERY_IVL)
zocket = zsocket_new (ctx, ZMQ_SUB);
assert (zocket);
zsocket_set_recovery_ivl (zocket, 1);
assert (zsocket_recovery_ivl (zocket) == 1);
zsocket_recovery_ivl (zocket);
zsocket_destroy (ctx, zocket);
# endif
# if defined (ZMQ_RECOVERY_IVL_MSEC)
zocket = zsocket_new (ctx, ZMQ_SUB);
assert (zocket);
zsocket_set_recovery_ivl_msec (zocket, 1);
assert (zsocket_recovery_ivl_msec (zocket) == 1);
zsocket_recovery_ivl_msec (zocket);
zsocket_destroy (ctx, zocket);
# endif
# if defined (ZMQ_MCAST_LOOP)
zocket = zsocket_new (ctx, ZMQ_SUB);
assert (zocket);
zsocket_set_mcast_loop (zocket, 1);
assert (zsocket_mcast_loop (zocket) == 1);
zsocket_mcast_loop (zocket);
zsocket_destroy (ctx, zocket);
# endif
# if (ZMQ_VERSION_MINOR == 2)
# if defined (ZMQ_RCVTIMEO)
zocket = zsocket_new (ctx, ZMQ_SUB);
assert (zocket);
zsocket_set_rcvtimeo (zocket, 1);
assert (zsocket_rcvtimeo (zocket) == 1);
zsocket_rcvtimeo (zocket);
zsocket_destroy (ctx, zocket);
# endif
# endif
# if (ZMQ_VERSION_MINOR == 2)
# if defined (ZMQ_SNDTIMEO)
zocket = zsocket_new (ctx, ZMQ_SUB);
assert (zocket);
zsocket_set_sndtimeo (zocket, 1);
assert (zsocket_sndtimeo (zocket) == 1);
zsocket_sndtimeo (zocket);
zsocket_destroy (ctx, zocket);
# endif
# endif
# if defined (ZMQ_SNDBUF)
zocket = zsocket_new (ctx, ZMQ_SUB);
assert (zocket);
zsocket_set_sndbuf (zocket, 1);
assert (zsocket_sndbuf (zocket) == 1);
zsocket_sndbuf (zocket);
zsocket_destroy (ctx, zocket);
# endif
# if defined (ZMQ_RCVBUF)
zocket = zsocket_new (ctx, ZMQ_SUB);
assert (zocket);
zsocket_set_rcvbuf (zocket, 1);
assert (zsocket_rcvbuf (zocket) == 1);
zsocket_rcvbuf (zocket);
zsocket_destroy (ctx, zocket);
# endif
# if defined (ZMQ_LINGER)
zocket = zsocket_new (ctx, ZMQ_SUB);
assert (zocket);
zsocket_set_linger (zocket, 1);
assert (zsocket_linger (zocket) == 1);
zsocket_linger (zocket);
zsocket_destroy (ctx, zocket);
# endif
# if defined (ZMQ_RECONNECT_IVL)
zocket = zsocket_new (ctx, ZMQ_SUB);
assert (zocket);
zsocket_set_reconnect_ivl (zocket, 1);
assert (zsocket_reconnect_ivl (zocket) == 1);
zsocket_reconnect_ivl (zocket);
zsocket_destroy (ctx, zocket);
# endif
# if defined (ZMQ_RECONNECT_IVL_MAX)
zocket = zsocket_new (ctx, ZMQ_SUB);
assert (zocket);
zsocket_set_reconnect_ivl_max (zocket, 1);
assert (zsocket_reconnect_ivl_max (zocket) == 1);
zsocket_reconnect_ivl_max (zocket);
zsocket_destroy (ctx, zocket);
# endif
# if defined (ZMQ_BACKLOG)
zocket = zsocket_new (ctx, ZMQ_SUB);
assert (zocket);
zsocket_set_backlog (zocket, 1);
assert (zsocket_backlog (zocket) == 1);
zsocket_backlog (zocket);
zsocket_destroy (ctx, zocket);
# endif
# if defined (ZMQ_SUBSCRIBE)
zocket = zsocket_new (ctx, ZMQ_SUB);
assert (zocket);
zsocket_set_subscribe (zocket, "test");
zsocket_destroy (ctx, zocket);
# endif
# if defined (ZMQ_UNSUBSCRIBE)
zocket = zsocket_new (ctx, ZMQ_SUB);
assert (zocket);
zsocket_set_unsubscribe (zocket, "test");
zsocket_destroy (ctx, zocket);
# endif
# if defined (ZMQ_TYPE)
zocket = zsocket_new (ctx, ZMQ_SUB);
assert (zocket);
zsocket_type (zocket);
zsocket_destroy (ctx, zocket);
# endif
# if defined (ZMQ_RCVMORE)
zocket = zsocket_new (ctx, ZMQ_SUB);
assert (zocket);
zsocket_rcvmore (zocket);
zsocket_destroy (ctx, zocket);
# endif
# if defined (ZMQ_FD)
zocket = zsocket_new (ctx, ZMQ_SUB);
assert (zocket);
zsocket_fd (zocket);
zsocket_destroy (ctx, zocket);
# endif
# if defined (ZMQ_EVENTS)
zocket = zsocket_new (ctx, ZMQ_SUB);
assert (zocket);
zsocket_events (zocket);
zsocket_destroy (ctx, zocket);
# endif
#endif
#if (ZMQ_VERSION_MAJOR == 3)
# if defined (ZMQ_TYPE)
zocket = zsocket_new (ctx, ZMQ_SUB);
assert (zocket);
zsocket_type (zocket);
zsocket_destroy (ctx, zocket);
# endif
# if defined (ZMQ_SNDHWM)
zocket = zsocket_new (ctx, ZMQ_PUB);
assert (zocket);
zsocket_set_sndhwm (zocket, 1);
assert (zsocket_sndhwm (zocket) == 1);
zsocket_sndhwm (zocket);
zsocket_destroy (ctx, zocket);
# endif
# if defined (ZMQ_RCVHWM)
zocket = zsocket_new (ctx, ZMQ_SUB);
assert (zocket);
zsocket_set_rcvhwm (zocket, 1);
assert (zsocket_rcvhwm (zocket) == 1);
zsocket_rcvhwm (zocket);
zsocket_destroy (ctx, zocket);
# endif
# if defined (ZMQ_AFFINITY)
zocket = zsocket_new (ctx, ZMQ_SUB);
assert (zocket);
zsocket_set_affinity (zocket, 1);
assert (zsocket_affinity (zocket) == 1);
zsocket_affinity (zocket);
zsocket_destroy (ctx, zocket);
# endif
# if defined (ZMQ_SUBSCRIBE)
zocket = zsocket_new (ctx, ZMQ_SUB);
assert (zocket);
zsocket_set_subscribe (zocket, "test");
zsocket_destroy (ctx, zocket);
# endif
# if defined (ZMQ_UNSUBSCRIBE)
zocket = zsocket_new (ctx, ZMQ_SUB);
assert (zocket);
zsocket_set_unsubscribe (zocket, "test");
zsocket_destroy (ctx, zocket);
# endif
# if defined (ZMQ_IDENTITY)
zocket = zsocket_new (ctx, ZMQ_DEALER);
assert (zocket);
zsocket_set_identity (zocket, "test");
char *identity = zsocket_identity (zocket);
assert (identity);
free (identity);
zsocket_destroy (ctx, zocket);
# endif
# if defined (ZMQ_RATE)
zocket = zsocket_new (ctx, ZMQ_SUB);
assert (zocket);
zsocket_set_rate (zocket, 1);
assert (zsocket_rate (zocket) == 1);
zsocket_rate (zocket);
zsocket_destroy (ctx, zocket);
# endif
# if defined (ZMQ_RECOVERY_IVL)
zocket = zsocket_new (ctx, ZMQ_SUB);
assert (zocket);
zsocket_set_recovery_ivl (zocket, 1);
assert (zsocket_recovery_ivl (zocket) == 1);
zsocket_recovery_ivl (zocket);
zsocket_destroy (ctx, zocket);
# endif
# if defined (ZMQ_SNDBUF)
zocket = zsocket_new (ctx, ZMQ_PUB);
assert (zocket);
zsocket_set_sndbuf (zocket, 1);
assert (zsocket_sndbuf (zocket) == 1);
zsocket_sndbuf (zocket);
zsocket_destroy (ctx, zocket);
# endif
# if defined (ZMQ_RCVBUF)
zocket = zsocket_new (ctx, ZMQ_SUB);
assert (zocket);
zsocket_set_rcvbuf (zocket, 1);
assert (zsocket_rcvbuf (zocket) == 1);
zsocket_rcvbuf (zocket);
zsocket_destroy (ctx, zocket);
# endif
# if defined (ZMQ_LINGER)
zocket = zsocket_new (ctx, ZMQ_SUB);
assert (zocket);
zsocket_set_linger (zocket, 1);
assert (zsocket_linger (zocket) == 1);
zsocket_linger (zocket);
zsocket_destroy (ctx, zocket);
# endif
# if defined (ZMQ_RECONNECT_IVL)
zocket = zsocket_new (ctx, ZMQ_SUB);
assert (zocket);
zsocket_set_reconnect_ivl (zocket, 1);
assert (zsocket_reconnect_ivl (zocket) == 1);
zsocket_reconnect_ivl (zocket);
zsocket_destroy (ctx, zocket);
# endif
# if defined (ZMQ_RECONNECT_IVL_MAX)
zocket = zsocket_new (ctx, ZMQ_SUB);
assert (zocket);
zsocket_set_reconnect_ivl_max (zocket, 1);
assert (zsocket_reconnect_ivl_max (zocket) == 1);
zsocket_reconnect_ivl_max (zocket);
zsocket_destroy (ctx, zocket);
# endif
# if defined (ZMQ_BACKLOG)
zocket = zsocket_new (ctx, ZMQ_SUB);
assert (zocket);
zsocket_set_backlog (zocket, 1);
assert (zsocket_backlog (zocket) == 1);
zsocket_backlog (zocket);
zsocket_destroy (ctx, zocket);
# endif
# if defined (ZMQ_MAXMSGSIZE)
zocket = zsocket_new (ctx, ZMQ_SUB);
assert (zocket);
zsocket_set_maxmsgsize (zocket, 1);
assert (zsocket_maxmsgsize (zocket) == 1);
zsocket_maxmsgsize (zocket);
zsocket_destroy (ctx, zocket);
# endif
# if defined (ZMQ_MULTICAST_HOPS)
zocket = zsocket_new (ctx, ZMQ_SUB);
assert (zocket);
zsocket_set_multicast_hops (zocket, 1);
assert (zsocket_multicast_hops (zocket) == 1);
zsocket_multicast_hops (zocket);
zsocket_destroy (ctx, zocket);
# endif
# if defined (ZMQ_RCVTIMEO)
zocket = zsocket_new (ctx, ZMQ_SUB);
assert (zocket);
zsocket_set_rcvtimeo (zocket, 1);
assert (zsocket_rcvtimeo (zocket) == 1);
zsocket_rcvtimeo (zocket);
zsocket_destroy (ctx, zocket);
# endif
# if defined (ZMQ_SNDTIMEO)
zocket = zsocket_new (ctx, ZMQ_SUB);
assert (zocket);
zsocket_set_sndtimeo (zocket, 1);
assert (zsocket_sndtimeo (zocket) == 1);
zsocket_sndtimeo (zocket);
zsocket_destroy (ctx, zocket);
# endif
# if defined (ZMQ_IPV4ONLY)
zocket = zsocket_new (ctx, ZMQ_SUB);
assert (zocket);
zsocket_set_ipv4only (zocket, 1);
assert (zsocket_ipv4only (zocket) == 1);
zsocket_ipv4only (zocket);
zsocket_destroy (ctx, zocket);
# endif
# if defined (ZMQ_DELAY_ATTACH_ON_CONNECT)
zocket = zsocket_new (ctx, ZMQ_PUB);
assert (zocket);
zsocket_set_delay_attach_on_connect (zocket, 1);
zsocket_destroy (ctx, zocket);
# endif
# if defined (ZMQ_ROUTER_MANDATORY)
zocket = zsocket_new (ctx, ZMQ_ROUTER);
assert (zocket);
zsocket_set_router_mandatory (zocket, 1);
zsocket_destroy (ctx, zocket);
# endif
# if defined (ZMQ_ROUTER_RAW)
zocket = zsocket_new (ctx, ZMQ_ROUTER);
assert (zocket);
zsocket_set_router_raw (zocket, 1);
zsocket_destroy (ctx, zocket);
# endif
# if defined (ZMQ_XPUB_VERBOSE)
zocket = zsocket_new (ctx, ZMQ_XPUB);
assert (zocket);
zsocket_set_xpub_verbose (zocket, 1);
zsocket_destroy (ctx, zocket);
# endif
# if defined (ZMQ_RCVMORE)
zocket = zsocket_new (ctx, ZMQ_SUB);
assert (zocket);
zsocket_rcvmore (zocket);
zsocket_destroy (ctx, zocket);
# endif
# if defined (ZMQ_FD)
zocket = zsocket_new (ctx, ZMQ_SUB);
assert (zocket);
zsocket_fd (zocket);
zsocket_destroy (ctx, zocket);
# endif
# if defined (ZMQ_EVENTS)
zocket = zsocket_new (ctx, ZMQ_SUB);
assert (zocket);
zsocket_events (zocket);
zsocket_destroy (ctx, zocket);
# endif
# if defined (ZMQ_LAST_ENDPOINT)
zocket = zsocket_new (ctx, ZMQ_SUB);
assert (zocket);
char *last_endpoint = zsocket_last_endpoint (zocket);
assert (last_endpoint);
free (last_endpoint);
zsocket_destroy (ctx, zocket);
# endif
zocket = zsocket_new (ctx, ZMQ_SUB);
zsocket_set_hwm (zocket, 1);
#endif
zctx_destroy (&ctx);
// @end
printf ("OK\n");
return 0;
}
void
zsocket_set_hwm (void *zocket, int hwm)
{
zsocket_set_sndhwm (zocket, hwm);
zsocket_set_rcvhwm (zocket, hwm);
}
int main (int argc, char *argv[])
{
int rc;
zctx_t *zctx;
void *zs;
pthread_t tid;
pthread_attr_t attr;
zmsg_t *zmsg;
int i, ch;
const char *uritmpl = "ipc://*";
int timeout_sec = 1;
log_init (basename (argv[0]));
while ((ch = getopt_long (argc, argv, OPTIONS, longopts, NULL)) != -1) {
switch (ch) {
case 'r':
raw = true;
break;
case 'l':
lopt = true;
linger = strtol (optarg, NULL, 10);
break;
case 'i':
iopt = true;
imm = strtol (optarg, NULL, 10);
break;
case 't':
uritmpl = "tcp://*:*";
break;
case 'T':
timeout_sec = strtoul (optarg, NULL, 10);
break;
case 's':
bufsize = strtoul (optarg, NULL, 10);
break;
case 'v':
vopt = true;
break;
case 'S':
sleep_usec = strtoul (optarg, NULL, 10);;
break;
default:
usage ();
/*NOTREACHED*/
}
}
if (optind != argc - 1)
usage ();
iter = strtoul (argv[optind++], NULL, 10);
/* Create socket and bind to it.
* Store uri in global variable.
*/
if (!(zctx = zctx_new ()))
log_err_exit ("S: zctx_new");
if (!(zs = zsocket_new (zctx, ZMQ_ROUTER)))
log_err_exit ("S: zsocket_new");
zsocket_set_rcvhwm (zs, 0); /* unlimited */
if (zsocket_bind (zs, "%s", uritmpl) < 0)
log_err_exit ("S: zsocket_bind");
uri = zsocket_last_endpoint (zs);
/* Spawn thread which will be our client.
*/
if ((rc = pthread_attr_init (&attr)))
log_errn (rc, "S: pthread_attr_init");
if ((rc = pthread_create (&tid, &attr, thread, NULL)))
log_errn (rc, "S: pthread_create");
/* Handle 'iter' client messages with timeout
*/
for (i = 0; i < iter; i++) {
alarm (timeout_sec);
if (!(zmsg = zmsg_recv (zs)))
log_err_exit ("S: zmsg_recv");
zmsg_destroy (&zmsg);
alarm (0);
if (vopt)
log_msg ("received message %d of %d", i + 1, iter);
}
/* Wait for thread to terminate, then clean up.
*/
if ((rc = pthread_join (tid, NULL)))
log_errn (rc, "S: pthread_join");
zctx_destroy (&zctx); /* destroys sockets too */
if (strstr (uri, "ipc://"))
(void)unlink (uri);
log_fini ();
return 0;
}
int
main (int argc, char *argv[])
{
if (argc != 4) {
exit (-1);
}
int numb_msgs = atoi (argv[2]);
int numb_unimp_threads = atoi (argv[3]);
zctx_t *ctx = zctx_new ();
void *router_imp = zsocket_new (ctx, ZMQ_ROUTER);
zsocket_set_rcvhwm (router_imp, 500000000);
zsocket_bind (router_imp, "%s:9000", argv[1]);
void *router_unimp = zsocket_new (ctx, ZMQ_ROUTER);
zsocket_set_rcvhwm (router_unimp, 500000000);
zsocket_bind (router_unimp, "%s:9001", argv[1]);
void *pub = zsocket_new (ctx, ZMQ_PUB);
zsocket_bind (pub, "%s:9002", argv[1]);
int64_t time[3];
int64_t idle=0;
int64_t diff;
zclock_sleep (1000);
//send the signal to start
zmsg_t *amsg = zmsg_new ();
zmsg_add (amsg, zframe_new ("all", 4));
zmsg_send (&amsg, pub);
zmq_pollitem_t pollitem[2] = { {router_imp, 0, ZMQ_POLLIN}
, {router_unimp, 0, ZMQ_POLLIN}
};
unsigned long av_dropped_priority=0;
unsigned long dropped=0;
unsigned long av_processed_priority=0;
unsigned long processed=0;
int i;
int imp_counter = 0;
int once = 1;
int ndiffs = 0;
unsigned char drop_priority = 0;
for (i = 0; i < 2 * numb_msgs; i++) {
diff = zclock_time ();
if (zmq_poll (pollitem, 2, -1) == -1) {
exit (-1);
}
diff = zclock_time () - diff;
idle = idle + diff;
update_drop_rate(&diff,&drop_priority,&ndiffs);
if (pollitem[0].revents & ZMQ_POLLIN) {
zmsg_t *msg = zmsg_recv (router_imp);
if (!msg) {
exit (-1);
}
zmsg_destroy (&msg);
imp_counter++;
if (imp_counter == numb_msgs) {
time[0] = zclock_time ();
}
}
else {
if (pollitem[1].revents & ZMQ_POLLIN) {
if (once) {
time[1] = zclock_time ();
once = 0;
}
zmsg_t *msg = zmsg_recv (router_unimp);
if (!msg) {
exit (-1);
}
zframe_t *frame = zmsg_unwrap (msg);
zframe_destroy (&frame);
unsigned char priority;
memcpy (&priority, zframe_data (zmsg_first (msg)), 1);
if (priority < drop_priority) {
av_dropped_priority+=priority;
dropped++;
// printf ("dropped:%u\n", priority);
zmsg_destroy (&msg);
}
else {
av_processed_priority+=priority;
processed++;
// printf ("received:%u\n", priority);
zmsg_destroy (&msg);
}
}
}
}
time[2] = zclock_time ();
printf ("msgs received:%d\n", i);
amsg = zmsg_new ();
zmsg_add (amsg, zframe_new ("all", 4));
zmsg_send (&amsg, pub);
zmsg_t *msg = zmsg_recv (router_imp);
zframe_t *frame = zmsg_unwrap (msg);
zframe_destroy (&frame);
int64_t time_imp[2];
frame = zmsg_pop (msg);
memcpy (time_imp, zframe_data (frame), zframe_size (frame));
zframe_destroy (&frame);
zmsg_destroy (&msg);
int64_t time_unimp[numb_unimp_threads][2];
for(i=0; i<numb_unimp_threads; i++){
msg = zmsg_recv (router_unimp);
frame = zmsg_unwrap (msg);
zframe_destroy (&frame);
frame = zmsg_pop (msg);
memcpy (time_unimp[i], zframe_data (frame), zframe_size (frame));
zframe_destroy (&frame);
zmsg_destroy (&msg);
}
//compute average latency
printf ("\nTime when important msgs started to be sent: %lld\n",
time_imp[0]);
printf ("\nTime when important msgs were processed: %lld\n", time[0]);
printf ("\nDifference: %lld\n", time[0] - time_imp[0]);
for(i=0; i<numb_unimp_threads; i++){
printf ("\nTime when unimportant msgs started to be sent: %lld\n",
time_unimp[i][0]);
printf ("\nTime when unimportant msgs were processed: %lld\n", time[2]);
printf ("\nDifference: %lld\n", time[2] - time_unimp[i][0]);
}
printf ("\nTime when unimportant msgs started to be processed: %lld\n",
time[1]);
printf ("idle time:%llu\n",idle);
printf ("dropped msgs:%llu\n",dropped);
printf ("av_dropped_priority:%llu\n",av_dropped_priority/dropped);
printf ("processed msgs:%llu\n",processed);
printf ("av_processed_priority:%llu\n",av_processed_priority/processed);
}