bool zmq::writer_t::check_write (zmq_msg_t *msg_)
{
// We've already checked and there's no space free for the new message.
// There's no point in checking once again.
if (unlikely (!active))
return false;
if (unlikely (swapping)) {
if (unlikely (!swap->fits (msg_))) {
active = false;
return false;
}
}
else {
if (unlikely (pipe_full ())) {
if (swap)
swapping = true;
else {
active = false;
return false;
}
}
}
return true;
}
bool zmq::writer_t::check_write ()
{
if (pipe_full () && (msg_store == NULL || msg_store->full () || extra_msg_flag)) {
stalled = true;
return false;
}
return true;
}
bool zmq::writer_t::check_write ()
{
if (pipe_full ()) {
stalled = true;
return false;
}
return true;
}
void zmq::writer_t::process_reader_info (uint64_t msgs_read_)
{
zmq_msg_t msg;
msgs_read = msgs_read_;
if (msg_store) {
// Move messages from backing store into pipe.
while (!pipe_full () && !msg_store->empty ()) {
msg_store->fetch(&msg);
// Write message into the pipe.
pipe->write (msg, msg.flags & ZMQ_MSG_MORE);
if (!(msg.flags & ZMQ_MSG_MORE))
msgs_written++;
}
if (extra_msg_flag) {
if (!pipe_full ()) {
pipe->write (extra_msg, extra_msg.flags & ZMQ_MSG_MORE);
if (!(extra_msg.flags & ZMQ_MSG_MORE))
msgs_written++;
extra_msg_flag = false;
}
else if (msg_store->store (&extra_msg)) {
if (!(extra_msg.flags & ZMQ_MSG_MORE))
msg_store->commit ();
extra_msg_flag = false;
}
}
if (pending_close && msg_store->empty () && !extra_msg_flag) {
write_delimiter ();
pending_close = false;
}
flush ();
}
if (stalled && endpoint != NULL) {
stalled = false;
endpoint->revive (this);
}
}
bool zmq::writer_t::write (zmq_msg_t *msg_)
{
if (pipe_full ()) {
stalled = true;
return false;
}
pipe->write (*msg_, msg_->flags & ZMQ_MSG_MORE);
if (!(msg_->flags & ZMQ_MSG_MORE))
msgs_written++;
return true;
}
void zmq::writer_t::rollback ()
{
zmq_msg_t msg;
// Remove all incomplete messages from the pipe.
while (pipe->unwrite (&msg)) {
zmq_assert (msg.flags & ZMQ_MSG_MORE);
zmq_msg_close (&msg);
msgs_written--;
}
if (stalled && endpoint != NULL && !pipe_full()) {
stalled = false;
endpoint->revive (this);
}
}
void zmq::writer_t::process_activate_writer (uint64_t msgs_read_)
{
// Store the reader's message sequence number.
msgs_read = msgs_read_;
// If we are in the swapping mode, we have some messages in the swap.
// Given that pipe is now ready for writing we can move part of the
// swap into the pipe.
if (swapping) {
zmq_msg_t msg;
while (!pipe_full () && !swap->empty ()) {
swap->fetch(&msg);
pipe->write (msg, msg.flags & ZMQ_MSG_MORE);
if (!(msg.flags & ZMQ_MSG_MORE))
msgs_written++;
}
if (!pipe->flush ())
send_activate_reader (reader);
// There are no more messages in the swap. We can switch into
// standard in-memory mode.
if (swap->empty ()) {
swapping = false;
// Push delimiter into the pipe. Trick the compiler to belive that
// the tag is a valid pointer. Note that watermarks are not checked
// thus the delimiter can be written even though the pipe is full.
if (pending_delimiter) {
zmq_msg_t msg;
const unsigned char *offset = 0;
msg.content = (void*) (offset + ZMQ_DELIMITER);
msg.flags = 0;
pipe->write (msg, false);
flush ();
return;
}
}
}
// If the writer was non-active before, let's make it active
// (available for writing messages to).
if (!active && !terminating) {
active = true;
zmq_assert (sink);
sink->activated (this);
}
}
bool zmq::writer_t::write (zmq_msg_t *msg_)
{
if (!check_write ())
return false;
if (pipe_full ()) {
if (msg_store->store (msg_)) {
if (!(msg_->flags & ZMQ_MSG_MORE))
msg_store->commit ();
} else {
extra_msg = *msg_;
extra_msg_flag = true;
}
}
else {
pipe->write (*msg_, msg_->flags & ZMQ_MSG_MORE);
if (!(msg_->flags & ZMQ_MSG_MORE))
msgs_written++;
}
return true;
}
