diff --git a/src/decoder.hpp b/src/decoder.hpp index 6aa912dc..c8fe5bef 100644 --- a/src/decoder.hpp +++ b/src/decoder.hpp @@ -119,7 +119,7 @@ namespace zmq bytes_used_ = size_; while (!to_read) { - const int rc = + const int rc = (static_cast (this)->*next) (data_ + bytes_used_); if (rc != 0) return rc; diff --git a/src/norm_engine.cpp b/src/norm_engine.cpp index 23eac066..3b50acc5 100644 --- a/src/norm_engine.cpp +++ b/src/norm_engine.cpp @@ -9,14 +9,14 @@ zmq::norm_engine_t::norm_engine_t(io_thread_t* parent_, const options_t& options_) - : io_object_t(parent_), zmq_session(NULL), options(options_), - norm_instance(NORM_INSTANCE_INVALID), norm_session(NORM_SESSION_INVALID), + : io_object_t(parent_), zmq_session(NULL), options(options_), + norm_instance(NORM_INSTANCE_INVALID), norm_session(NORM_SESSION_INVALID), is_sender(false), is_receiver(false), - zmq_encoder(0), norm_tx_stream(NORM_OBJECT_INVALID), - tx_first_msg(true), tx_more_bit(false), - zmq_output_ready(false), norm_tx_ready(false), + zmq_encoder(0), norm_tx_stream(NORM_OBJECT_INVALID), + tx_first_msg(true), tx_more_bit(false), + zmq_output_ready(false), norm_tx_ready(false), tx_index(0), tx_len(0), - zmq_input_ready(false) + zmq_input_ready(false) { int rc = tx_msg.init(); errno_assert(0 == rc); @@ -50,7 +50,7 @@ int zmq::norm_engine_t::init(const char* network_, bool send, bool recv) { ifacePtr = network_; } - + // Second, look for optional multicast ifaceName char ifaceName[256]; const char* addrPtr = strchr(ifacePtr, ';'); @@ -68,7 +68,7 @@ int zmq::norm_engine_t::init(const char* network_, bool send, bool recv) addrPtr = ifacePtr; ifacePtr = NULL; } - + // Finally, parse IP address and port number const char* portPtr = strrchr(addrPtr, ':'); if (NULL == portPtr) @@ -76,7 +76,7 @@ int zmq::norm_engine_t::init(const char* network_, bool send, bool recv) errno = EINVAL; return -1; } - + char addr[256]; size_t addrLen = portPtr - addrPtr; if (addrLen > 255) addrLen = 255; @@ -84,7 +84,7 @@ int zmq::norm_engine_t::init(const char* network_, bool send, bool recv) addr[addrLen] = '\0'; portPtr++; unsigned short portNumber = atoi(portPtr); - + if (NORM_INSTANCE_INVALID == norm_instance) { if (NORM_INSTANCE_INVALID == (norm_instance = NormCreateInstance())) @@ -93,14 +93,14 @@ int zmq::norm_engine_t::init(const char* network_, bool send, bool recv) return -1; } } - + // TBD - What do we use for our local NormNodeId? // (for now we use automatic, IP addr based assignment or passed in 'id') // a) Use ZMQ Identity somehow? // b) Add function to use iface addr // c) Randomize and implement a NORM session layer // conflict detection/resolution protocol - + norm_session = NormCreateSession(norm_instance, addr, portNumber, localId); if (NORM_SESSION_INVALID == norm_session) { @@ -129,7 +129,7 @@ int zmq::norm_engine_t::init(const char* network_, bool send, bool recv) NormSetMulticastInterface(norm_session, ifacePtr); } } - + if (recv) { // The alternative NORM_SYNC_CURRENT here would provide "instant" @@ -148,7 +148,7 @@ int zmq::norm_engine_t::init(const char* network_, bool send, bool recv) } is_receiver = true; } - + if (send) { // Pick a random sender instance id (aka norm sender session id) @@ -163,10 +163,10 @@ int zmq::norm_engine_t::init(const char* network_, bool send, bool recv) norm_instance = NORM_INSTANCE_INVALID; errno = savedErrno; return -1; - } + } NormSetCongestionControl(norm_session, true); norm_tx_ready = true; - is_sender = true; + is_sender = true; if (NORM_OBJECT_INVALID == (norm_tx_stream = NormStreamOpen(norm_session, 2*1024*1024))) { // errno set by whatever failed @@ -178,11 +178,11 @@ int zmq::norm_engine_t::init(const char* network_, bool send, bool recv) return -1; } } - + //NormSetMessageTrace(norm_session, true); //NormSetDebugLevel(3); //NormOpenDebugLog(norm_instance, "normLog.txt"); - + return 0; // no error } // end zmq::norm_engine_t::init() @@ -192,12 +192,12 @@ void zmq::norm_engine_t::shutdown() if (is_receiver) { NormStopReceiver(norm_session); - + // delete any active NormRxStreamState rx_pending_list.Destroy(); rx_ready_list.Destroy(); msg_ready_list.Destroy(); - + is_receiver = false; } if (is_sender) @@ -224,20 +224,20 @@ void zmq::norm_engine_t::plug (io_thread_t* io_thread_, session_base_t *session_ zmq_session = session_; if (is_sender) zmq_output_ready = true; if (is_receiver) zmq_input_ready = true; - + fd_t normDescriptor = NormGetDescriptor(norm_instance); norm_descriptor_handle = add_fd(normDescriptor); // Set POLLIN for notification of pending NormEvents - set_pollin(norm_descriptor_handle); - + set_pollin(norm_descriptor_handle); + if (is_sender) send_data(); - + } // end zmq::norm_engine_t::init() void zmq::norm_engine_t::unplug() { rm_fd(norm_descriptor_handle); - + zmq_session = NULL; } // end zmq::norm_engine_t::unplug() @@ -253,7 +253,7 @@ void zmq::norm_engine_t::restart_output() // There's new message data available from the session zmq_output_ready = true; if (norm_tx_ready) send_data(); - + } // end zmq::norm_engine_t::restart_output() void zmq::norm_engine_t::send_data() @@ -289,7 +289,7 @@ void zmq::norm_engine_t::send_data() // Need to pull and load a new message to send if (-1 == zmq_session->pull_msg(&tx_msg)) { - // We need to wait for "restart_output()" to be called by ZMQ + // We need to wait for "restart_output()" to be called by ZMQ zmq_output_ready = false; break; } @@ -301,7 +301,7 @@ void zmq::norm_engine_t::send_data() // 'syncs' mid-stream. We key off the the state of the 'more_flag' // I.e.,If more_flag _was_ false previously, this is the first // frame of a ZMQ message. - if (tx_more_bit) + if (tx_more_bit) tx_buffer[0] = (char)0xff; // this is not first frame of message else tx_buffer[0] = 0x00; // this is first frame of message @@ -339,7 +339,7 @@ void zmq::norm_engine_t::in_event() zmq_assert(false); return; } - + switch(event.type) { case NORM_TX_QUEUE_VACANCY: @@ -350,13 +350,13 @@ void zmq::norm_engine_t::in_event() send_data(); } break; - + case NORM_RX_OBJECT_NEW: //break; case NORM_RX_OBJECT_UPDATED: recv_data(event.object); break; - + case NORM_RX_OBJECT_ABORTED: { NormRxStreamState* rxState = (NormRxStreamState*)NormObjectGetUserData(event.object); @@ -370,7 +370,7 @@ void zmq::norm_engine_t::in_event() } delete rxState; break; - } + } case NORM_REMOTE_SENDER_INACTIVE: // Here we free resources used for this formerly active sender. // Note w/ NORM_SYNC_STREAM, if sender reactivates, we may @@ -380,11 +380,11 @@ void zmq::norm_engine_t::in_event() // user configurable timeout here to wait some amount of time // after this event to declare the remote sender truly dead // and delete its state??? - NormNodeDelete(event.sender); + NormNodeDelete(event.sender); break; - + default: - // We ignore some NORM events + // We ignore some NORM events break; } } // zmq::norm_engine_t::in_event() @@ -396,7 +396,7 @@ void zmq::norm_engine_t::restart_input() // Process any pending received messages if (!msg_ready_list.IsEmpty()) recv_data(NORM_OBJECT_INVALID); - + } // end zmq::norm_engine_t::restart_input() void zmq::norm_engine_t::recv_data(NormObjectHandle object) @@ -447,19 +447,19 @@ void zmq::norm_engine_t::recv_data(NormObjectHandle object) { switch(rxState->Decode()) { - case 1: // msg completed + case 1: // msg completed // Complete message decoded, move this stream to msg_ready_list - // to push the message up to the session below. Note the stream + // to push the message up to the session below. Note the stream // will be returned to the "rx_ready_list" after that's done rx_ready_list.Remove(*rxState); msg_ready_list.Append(*rxState); continue; - + case -1: // decoding error (shouldn't happen w/ NORM, but ...) // We need to re-sync this stream (decoder buffer was reset) rxState->SetSync(false); break; - + default: // 0 - need more data break; } @@ -524,12 +524,12 @@ void zmq::norm_engine_t::recv_data(NormObjectHandle object) rx_pending_list.Append(*rxState); } } // end while(NULL != (rxState = iterator.GetNextItem())) - + if (zmq_input_ready) { // At this point, we've made a pass through the "rx_ready" stream list - // Now make a pass through the "msg_pending" list (if the zmq session - // ready for more input). This may possibly return streams back to + // Now make a pass through the "msg_pending" list (if the zmq session + // ready for more input). This may possibly return streams back to // the "rx ready" stream list after their pending message is handled NormRxStreamState::List::Iterator iterator(msg_ready_list); NormRxStreamState* rxState; @@ -549,7 +549,7 @@ void zmq::norm_engine_t::recv_data(NormObjectHandle object) { // session rejected message? // TBD - handle this better - zmq_assert(false); + zmq_assert(false); } } // else message was accepted. @@ -561,15 +561,15 @@ void zmq::norm_engine_t::recv_data(NormObjectHandle object) } // end while(NULL != (rxState = iterator.GetNextItem())) } // end if (zmq_input_ready) } // end while ((!rx_ready_list.empty() || (zmq_input_ready && !msg_ready_list.empty())) - + // Alert zmq of the messages we have pushed up zmq_session->flush(); - + } // end zmq::norm_engine_t::recv_data() -zmq::norm_engine_t::NormRxStreamState::NormRxStreamState(NormObjectHandle normStream, +zmq::norm_engine_t::NormRxStreamState::NormRxStreamState(NormObjectHandle normStream, int64_t maxMsgSize) - : norm_stream(normStream), max_msg_size(maxMsgSize), + : norm_stream(normStream), max_msg_size(maxMsgSize), in_sync(false), rx_ready(false), zmq_decoder(NULL), skip_norm_sync(false), buffer_ptr(NULL), buffer_size(0), buffer_count(0), prev(NULL), next(NULL), list(NULL) @@ -620,17 +620,17 @@ int zmq::norm_engine_t::NormRxStreamState::Decode() { // There's pending data for the decoder to decode size_t processed = 0; - + // This a bit of a kludgy approach used to weed // out the NORM ZMQ message transport "syncFlag" byte // from the ZMQ message stream being decoded (but it works!) - if (skip_norm_sync) + if (skip_norm_sync) { buffer_ptr++; buffer_count--; skip_norm_sync = false; } - + int rc = zmq_decoder->decode(buffer_ptr, buffer_count, processed); buffer_ptr += processed; buffer_count -= processed; @@ -651,7 +651,7 @@ int zmq::norm_engine_t::NormRxStreamState::Decode() skip_norm_sync = false; // will get consumed by norm sync check Init(); break; - + case 0: // need more data, keep decoding until buffer exhausted break; @@ -662,7 +662,7 @@ int zmq::norm_engine_t::NormRxStreamState::Decode() buffer_size = 0; zmq_decoder->get_buffer(&buffer_ptr, &buffer_size); return 0; // need more data - + } // end zmq::norm_engine_t::NormRxStreamState::Decode() zmq::norm_engine_t::NormRxStreamState::List::List() @@ -723,6 +723,6 @@ zmq::norm_engine_t::NormRxStreamState* zmq::norm_engine_t::NormRxStreamState::Li if (NULL != nextItem) next_item = nextItem->next; return nextItem; } // end zmq::norm_engine_t::NormRxStreamState::List::Iterator::GetNextItem() - + #endif // ZMQ_HAVE_NORM diff --git a/src/norm_engine.hpp b/src/norm_engine.hpp index fa6d1ffa..5d059ec7 100644 --- a/src/norm_engine.hpp +++ b/src/norm_engine.hpp @@ -16,17 +16,17 @@ namespace zmq { class io_thread_t; class session_base_t; - + class norm_engine_t : public io_object_t, public i_engine { public: norm_engine_t (zmq::io_thread_t *parent_, const options_t &options_); ~norm_engine_t (); - + // create NORM instance, session, etc int init(const char* network_, bool send, bool recv); void shutdown(); - + // i_engine interface implementation. // Plug the engine to the session. virtual void plug (zmq::io_thread_t *io_thread_, @@ -45,43 +45,43 @@ namespace zmq virtual void restart_output (); virtual void zap_msg_available () {}; - + // i_poll_events interface implementation. // (we only need in_event() for NormEvent notification) // (i.e., don't have any output events or timers (yet)) void in_event (); - + private: void unplug(); void send_data(); - void recv_data(NormObjectHandle stream); - - + void recv_data(NormObjectHandle stream); + + enum {BUFFER_SIZE = 2048}; - - // Used to keep track of streams from multiple senders + + // Used to keep track of streams from multiple senders class NormRxStreamState { public: NormRxStreamState(NormObjectHandle normStream, int64_t maxMsgSize); ~NormRxStreamState(); - + NormObjectHandle GetStreamHandle() const {return norm_stream;} - + bool Init(); - + void SetRxReady(bool state) {rx_ready = state;} bool IsRxReady() const {return rx_ready;} - + void SetSync(bool state) {in_sync = state;} bool InSync() const {return in_sync;} - + // These are used to feed data to decoder // and its underlying "msg" buffer char* AccessBuffer() @@ -98,21 +98,21 @@ namespace zmq // occurs the 'sync' is dropped and the // decoder re-initialized int Decode(); - + class List { public: List(); ~List(); - + void Append(NormRxStreamState& item); void Remove(NormRxStreamState& item); - + bool IsEmpty() const {return (NULL == head);} - + void Destroy(); - + class Iterator { public: @@ -122,36 +122,36 @@ namespace zmq NormRxStreamState* next_item; }; friend class Iterator; - + private: NormRxStreamState* head; - NormRxStreamState* tail; - + NormRxStreamState* tail; + }; // end class zmq::norm_engine_t::NormRxStreamState::List - + friend class List; - + List* AccessList() {return list;} - - + + private: NormObjectHandle norm_stream; int64_t max_msg_size; - bool in_sync; + bool in_sync; bool rx_ready; v2_decoder_t* zmq_decoder; bool skip_norm_sync; unsigned char* buffer_ptr; size_t buffer_size; size_t buffer_count; - + NormRxStreamState* prev; NormRxStreamState* next; NormRxStreamState::List* list; - + }; // end class zmq::norm_engine_t::NormRxStreamState - + session_base_t* zmq_session; options_t options; NormInstanceHandle norm_instance; @@ -161,25 +161,25 @@ namespace zmq bool is_receiver; // Sender state msg_t tx_msg; - v2_encoder_t zmq_encoder; // for tx messages (we use v2 for now) + v2_encoder_t zmq_encoder; // for tx messages (we use v2 for now) NormObjectHandle norm_tx_stream; bool tx_first_msg; bool tx_more_bit; - bool zmq_output_ready; // zmq has msg(s) to send + bool zmq_output_ready; // zmq has msg(s) to send bool norm_tx_ready; // norm has tx queue vacancy // TBD - maybe don't need buffer if can access zmq message buffer directly? char tx_buffer[BUFFER_SIZE]; unsigned int tx_index; unsigned int tx_len; - + // Receiver state // Lists of norm rx streams from remote senders bool zmq_input_ready; // zmq ready to receive msg(s) NormRxStreamState::List rx_pending_list; // rx streams waiting for data reception NormRxStreamState::List rx_ready_list; // rx streams ready for NormStreamRead() NormRxStreamState::List msg_ready_list; // rx streams w/ msg ready for push to zmq - - + + }; // end class norm_engine_t }