// Listing 4 code/ch17
int processRecord (ALLOCATOR *shmem_allocator)
{
ACE_GUARD_RETURN (ACE_Process_Mutex, ace_mon, coordMutex, -1);
QUEUE* queue = squeue (shmem_allocator);
if (queue == 0)
{
delete shmem_allocator;
ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%p\n"),
ACE_TEXT ("Could not obtain queue")),
-1);
}
if (queue->is_empty ()) // Check for anything to process.
return 0;
Record record;
if (queue->dequeue_head (record, shmem_allocator) == -1)
{
ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%p\n"),
ACE_TEXT ("dequeue_head\n")),
-1);
}
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("(%P|%t) Processing record|name: %C")
ACE_TEXT ("|Record id1:%d|Record id2:%d\n"),
record.name (), record.id1 (), record.id2 ()));
if (record.id1 () == -1)
queue->enqueue_tail (record, shmem_allocator);
return record.id1 ();
}
static int
chained_block_test (void)
{
QUEUE q;
const char * s = "123456789"; // Will be length 10 when copied to block
const size_t slen = 10;
const size_t num_blks = 10;
ACE_Message_Block b[num_blks];
size_t i;
int status = 0;
for (i = 0; i < num_blks; ++i)
{
b[i].init (slen);
b[i].copy (s);
}
// Test enqueueing single and chained blocks and be sure they end up with
// the proper enqueued block count and sizes. Then be sure they are dequeued
// in the proper order.
b[0].next (&b[1]);
b[1].next (&b[2]);
// b[3] and b[4] are unchained.
b[5].next (&b[6]);
b[6].next (&b[7]);
b[7].next (&b[8]);
// b[9] is unchained
q.enqueue_tail (&b[3]);
q.enqueue_tail (&b[4]);
int num = q.enqueue_head (&b[0]);
if (num != 5)
{
ACE_ERROR ((LM_ERROR, ACE_TEXT ("Chained enqueue expected 5; has %d\n"),
num));
status = -1;
}
num = q.enqueue_tail (&b[5]);
if (num != 9)
{
ACE_ERROR ((LM_ERROR, ACE_TEXT ("Chained enqueue expected 9; has %d\n"),
num));
status = -1;
}
num = q.enqueue_tail (&b[9]);
if (num != 10)
{
ACE_ERROR ((LM_ERROR, ACE_TEXT ("Chained enqueue expected 10; has %d\n"),
num));
status = -1;
}
size_t msgs, bytes;
msgs = q.message_count ();
bytes = q.message_bytes ();
if (msgs != 10 || bytes != 100)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Chained enqueue totals: %d msgs, %d bytes; ")
ACE_TEXT ("should be 10 msgs, 100 bytes\n"),
(int)msgs, (int)bytes));
status = -1;
}
// Now see if we can dequeue them, checking the order.
ACE_Time_Value nowait (ACE_OS::gettimeofday ());
ACE_Message_Block *bp;
int qstat;
for (i = 0; i < num_blks; ++i)
{
qstat = q.dequeue_head (bp, &nowait);
if (qstat == -1)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Checking chained blocks, pass %d: %p\n"),
(int)i, ACE_TEXT ("dequeue_head")));
status = -1;
}
else if (bp != &b[i])
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Checking chained blocks, pass %d: ")
ACE_TEXT ("block out of order\n"),
(int)i));
status = -1;
}
}
if (status == 0)
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Chained block test OK\n")));
return status;
}
static int
single_thread_performance_test (void)
{
const char test_message[] =
"ACE_Message_Queue_Ex Test Message";
const ACE_TCHAR *message =
ACE_TEXT ("ACE_Message_Queue_Ex<ACE_NULL_SYNCH>, single thread");
// Create a message queue.
QUEUE *msgq = 0;
ACE_NEW_RETURN (msgq,
QUEUE,
-1);
// Create the messages. Allocate off the heap in case messages is
// large relative to the amount of stack space available.
User_Class **send_block = 0;
ACE_NEW_RETURN (send_block,
User_Class *[max_messages],
-1);
int i;
for (i = 0; i < max_messages; ++i)
ACE_NEW_RETURN (send_block[i],
User_Class (test_message),
-1);
User_Class **receive_block_p = 0;
ACE_NEW_RETURN (receive_block_p,
User_Class *[max_messages],
-1);
timer->start ();
// Send/receive the messages.
for (i = 0; i < max_messages; ++i)
{
if (msgq->enqueue_tail (send_block[i]) == -1)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("enqueue")),
-1);
if (msgq->dequeue_head (receive_block_p[i]) == -1)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("dequeue_head")),
-1);
}
timer->stop ();
ACE_Time_Value tv;
timer->elapsed_time (tv);
ACE_DEBUG ((LM_INFO,
ACE_TEXT ("%s: %u messages took %u msec (%f msec/message)\n"),
message,
max_messages,
tv.msec (),
(double) tv.msec () / max_messages));
timer->reset ();
delete [] receive_block_p;
for (i = 0; i < max_messages; ++i)
delete send_block[i];
delete [] send_block;
delete msgq;
return 0;
}
