ACE/ace/Message_Queue_Vx.cpp

   1 #include "ace/Message_Queue.h"
   2 #include "ace/Message_Queue_Vx.h"
   3 #include "ace/Log_Category.h"
   4
   5 #if !defined (__ACE_INLINE__)
   6 #include "ace/Message_Queue_Vx.inl"
   7 #endif /* __ACE_INLINE__ */
   8
   9 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  10
  11 #if defined (ACE_VXWORKS)
  12
  13 ////////////////////////////////
  14 // class ACE_Message_Queue_Vx //
  15 ////////////////////////////////
  16
  17 ACE_ALLOC_HOOK_DEFINE (ACE_Message_Queue_Vx);
  18
  19 void
  20 ACE_Message_Queue_Vx::dump () const
  21 {
  22 #if defined (ACE_HAS_DUMP)
  23   ACE_TRACE ("ACE_Message_Queue_Vx::dump");
  24   ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
  25   switch (this->state_)
  26     {
  27     case ACE_Message_Queue_Base::ACTIVATED:
  28       ACELIB_DEBUG ((LM_DEBUG,
  29                   ACE_TEXT ("state = ACTIVATED\n")));
  30       break;
  31     case ACE_Message_Queue_Base::DEACTIVATED:
  32       ACELIB_DEBUG ((LM_DEBUG,
  33                   ACE_TEXT ("state = DEACTIVATED\n")));
  34       break;
  35     case ACE_Message_Queue_Base::PULSED:
  36       ACELIB_DEBUG ((LM_DEBUG,
  37                   ACE_TEXT ("state = PULSED\n")));
  38       break;
  39     }
  40   ACELIB_DEBUG ((LM_DEBUG,
  41               ACE_TEXT ("low_water_mark = %d\n")
  42               ACE_TEXT ("high_water_mark = %d\n")
  43               ACE_TEXT ("cur_bytes = %d\n")
  44               ACE_TEXT ("cur_length = %d\n")
  45               ACE_TEXT ("cur_count = %d\n")
  46               ACE_TEXT ("head_ = %u\n")
  47               ACE_TEXT ("MSG_Q_ID = %u\n"),
  48               this->low_water_mark_,
  49               this->high_water_mark_,
  50               this->cur_bytes_,
  51               this->cur_length_,
  52               this->cur_count_,
  53               this->head_,
  54               this->tail_));
  55   ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP));
  56 #endif /* ACE_HAS_DUMP */
  57 }
  58
  59 ACE_Message_Queue_Vx::ACE_Message_Queue_Vx (size_t max_messages,
  60                                             size_t max_message_length,
  61                                             ACE_Notification_Strategy *ns)
  62   : ACE_Message_Queue<ACE_NULL_SYNCH> (0, 0, ns),
  63     max_messages_ (static_cast<int> (max_messages)),
  64     max_message_length_ (static_cast<int> (max_message_length))
  65 {
  66   ACE_TRACE ("ACE_Message_Queue_Vx::ACE_Message_Queue_Vx");
  67
  68   if (this->open (max_messages_, max_message_length_, ns) == -1)
  69     ACELIB_ERROR ((LM_ERROR, ACE_TEXT ("open")));
  70 }
  71
  72 ACE_Message_Queue_Vx::~ACE_Message_Queue_Vx ()
  73 {
  74   ACE_TRACE ("ACE_Message_Queue_Vx::~ACE_Message_Queue_Vx");
  75
  76   if (this->tail_ != 0  &&  this->close () == -1)
  77     ACELIB_ERROR ((LM_ERROR, ACE_TEXT ("close")));
  78 }
  79
  80 // Don't bother locking since if someone calls this function more than
  81 // once for the same queue, we're in bigger trouble than just
  82 // concurrency control!
  83
  84 int
  85 ACE_Message_Queue_Vx::open (size_t max_messages,
  86                             size_t max_message_length,
  87                             ACE_Notification_Strategy *ns)
  88 {
  89   ACE_TRACE ("ACE_Message_Queue_Vx::open");
  90   this->high_water_mark_ = 0;
  91   this->low_water_mark_  = 0;
  92   this->cur_bytes_ = 0;
  93   this->cur_length_ = 0;
  94   this->cur_count_ = 0;
  95   this->head_ = 0;
  96   this->notification_strategy_ = ns;
  97   this->max_messages_ = static_cast<int> (max_messages);
  98   this->max_message_length_ = static_cast<int> (max_message_length);
  99
 100   if (tail_)
 101     {
 102       // Had already created a msgQ, so delete it.
 103       close ();
 104       activate_i ();
 105     }
 106
 107   return (this->tail_ =
 108           reinterpret_cast<ACE_Message_Block *> (
 109               ::msgQCreate (max_messages_,
 110                             max_message_length_,
 111                             MSG_Q_FIFO))) == 0 ? -1 : 0;
 112 }
 113
 114 // Clean up the queue if we have not already done so!
 115 int
 116 ACE_Message_Queue_Vx::close ()
 117 {
 118   ACE_TRACE ("ACE_Message_Queue_Vx::close");
 119   // Don't lock, because we don't have a lock.  It shouldn't be
 120   // necessary, anyways.
 121
 122   this->deactivate_i ();
 123
 124   // Don't bother to free up the remaining message on the list,
 125   // because we don't have any way to iterate over what's in the
 126   // queue.
 127
 128   return ::msgQDelete (msgq ());
 129 }
 130
 131 bool
 132 ACE_Message_Queue_Vx::is_empty_i ()
 133 {
 134   ACE_TRACE ("ACE_Message_Queue_Vx::is_empty_i");
 135   return ::msgQNumMsgs (msgq ()) == 0;
 136 }
 137
 138 bool
 139 ACE_Message_Queue_Vx::is_full_i ()
 140 {
 141   ACE_TRACE ("ACE_Message_Queue_Vx::is_full_i");
 142   return ::msgQNumMsgs (msgq ()) >= max_messages_;
 143 }
 144
 145 size_t
 146 ACE_Message_Queue_Vx::high_water_mark ()
 147 {
 148   ACE_TRACE ("ACE_Message_Queue_Vx::high_water_mark");
 149   ACE_NOTSUP_RETURN ((size_t) -1);
 150 }
 151
 152 void
 153 ACE_Message_Queue_Vx::high_water_mark (size_t)
 154 {
 155   ACE_TRACE ("ACE_Message_Queue_Vx::high_water_mark");
 156   ACE_NOTSUP;
 157 }
 158
 159 size_t
 160 ACE_Message_Queue_Vx::low_water_mark ()
 161 {
 162   ACE_TRACE ("ACE_Message_Queue_Vx::low_water_mark");
 163   // Don't need to guard, because this is fixed.
 164
 165   ACE_NOTSUP_RETURN ((size_t) -1);
 166 }
 167
 168 void
 169 ACE_Message_Queue_Vx::low_water_mark (size_t)
 170 {
 171   ACE_TRACE ("ACE_Message_Queue_Vx::low_water_mark");
 172   ACE_NOTSUP;
 173 }
 174
 175 size_t
 176 ACE_Message_Queue_Vx::message_bytes ()
 177 {
 178   ACE_TRACE ("ACE_Message_Queue_Vx::message_bytes");
 179   ACE_NOTSUP_RETURN ((size_t) -1);
 180 }
 181
 182 size_t
 183 ACE_Message_Queue_Vx::message_length ()
 184 {
 185   ACE_TRACE ("ACE_Message_Queue_Vx::message_length");
 186   ACE_NOTSUP_RETURN ((size_t) -1);
 187 }
 188
 189 size_t
 190 ACE_Message_Queue_Vx::message_count ()
 191 {
 192   ACE_TRACE ("ACE_Message_Queue_Vx::message_count");
 193   // Don't need to guard, because this is a system call.
 194
 195   return ::msgQNumMsgs (msgq ());
 196 }
 197
 198 void
 199 ACE_Message_Queue_Vx::message_bytes (size_t)
 200 {
 201   ACE_TRACE ("ACE_Message_Queue_Vx::message_bytes");
 202   ACE_NOTSUP;
 203 }
 204
 205 void
 206 ACE_Message_Queue_Vx::message_length (size_t)
 207 {
 208   ACE_TRACE ("ACE_Message_Queue_Vx::message_length");
 209   ACE_NOTSUP;
 210 }
 211
 212 int
 213 ACE_Message_Queue_Vx::signal_enqueue_waiters ()
 214 {
 215   // No-op.
 216   return 0;
 217 }
 218
 219 int
 220 ACE_Message_Queue_Vx::signal_dequeue_waiters ()
 221 {
 222   // No-op.
 223   return 0;
 224 }
 225
 226 int
 227 ACE_Message_Queue_Vx::enqueue_tail_i (ACE_Message_Block *new_item)
 228 {
 229   ACE_TRACE ("ACE_Message_Queue_Vx::enqueue_tail_i");
 230
 231   if (new_item == 0)
 232     return -1;
 233
 234   // Don't try to send a composite message!!!!  Only the first
 235   // block will be sent.
 236
 237   ++this->cur_count_;
 238
 239   // Always use this method to actually send a message on the queue.
 240   if (::msgQSend (msgq (),
 241                   new_item->rd_ptr (),
 242                   new_item->size (),
 243                   WAIT_FOREVER,
 244                   MSG_PRI_NORMAL) == OK)
 245     return ::msgQNumMsgs (msgq ());
 246   else
 247     return -1;
 248 }
 249
 250 int
 251 ACE_Message_Queue_Vx::enqueue_head_i (ACE_Message_Block *new_item)
 252 {
 253   ACE_TRACE ("ACE_Message_Queue_Vx::enqueue_head_i");
 254
 255   // Just delegate to enqueue_tail_i.
 256   return enqueue_tail_i (new_item);
 257 }
 258
 259 int
 260 ACE_Message_Queue_Vx::enqueue_i (ACE_Message_Block *new_item)
 261 {
 262   ACE_TRACE ("ACE_Message_Queue_Vx::enqueue_i");
 263
 264   if (new_item == 0)
 265     return -1;
 266
 267   if (this->head_ == 0)
 268     // Should always take this branch.
 269     return this->enqueue_head_i (new_item);
 270   else
 271     ACE_NOTSUP_RETURN (-1);
 272 }
 273
 274 int
 275 ACE_Message_Queue_Vx::enqueue_deadline_i (ACE_Message_Block *new_item)
 276 {
 277   ACE_TRACE ("ACE_Message_Queue_Vx::enqueue_deadline_i");
 278
 279   // Just delegate to enqueue_tail_i.
 280   return enqueue_tail_i (new_item);
 281 }
 282
 283 // Actually get the first ACE_Message_Block (no locking, so must be
 284 // called with locks held).  This method assumes that the queue has at
 285 // least one item in it when it is called.
 286
 287 int
 288 ACE_Message_Queue_Vx::dequeue_head_i (ACE_Message_Block *&first_item)
 289 {
 290   ACE_TRACE ("ACE_Message_Queue_Vx::dequeue_head_i");
 291
 292   // We don't allocate a new Message_Block:  the caller must provide
 293   // it, and must ensure that it is big enough (without chaining).
 294
 295   if (first_item == 0  ||  first_item->wr_ptr () == 0)
 296     return -1;
 297
 298   if (::msgQReceive (msgq (),
 299                      first_item->wr_ptr (),
 300                      first_item->size (),
 301                      WAIT_FOREVER) == ERROR)
 302     return -1;
 303   else
 304     return ::msgQNumMsgs (msgq ());
 305 }
 306
 307 int
 308 ACE_Message_Queue_Vx::dequeue_prio_i (ACE_Message_Block *& /*dequeued*/)
 309 {
 310   ACE_TRACE ("ACE_Message_Queue_Vx::dequeue_prio_i");
 311   ACE_NOTSUP_RETURN (-1);
 312 }
 313
 314 int
 315 ACE_Message_Queue_Vx::dequeue_tail_i (ACE_Message_Block *& /*dequeued*/)
 316 {
 317   ACE_TRACE ("ACE_Message_Queue_Vx::dequeue_tail_i");
 318   ACE_NOTSUP_RETURN (-1);
 319 }
 320
 321 int
 322 ACE_Message_Queue_Vx::dequeue_deadline_i (ACE_Message_Block *& /*dequeued*/)
 323 {
 324   ACE_TRACE ("ACE_Message_Queue_Vx::dequeue_deadline_i");
 325   ACE_NOTSUP_RETURN (-1);
 326 }
 327
 328 // Take a look at the first item without removing it.
 329
 330 int
 331 ACE_Message_Queue_Vx::wait_not_full_cond (ACE_Time_Value *)
 332 {
 333   // Always return here, and let the VxWorks message queue handle blocking.
 334   return 0;
 335 }
 336
 337 int
 338 ACE_Message_Queue_Vx::wait_not_empty_cond (ACE_Time_Value *)
 339 {
 340   // Always return here, and let the VxWorks message queue handle blocking.
 341   return 0;
 342 }
 343
 344 #endif /* ACE_VXWORKS */
 345
 346 ACE_END_VERSIONED_NAMESPACE_DECL