TAO/tests/RTCORBA/RTMutex/server.cpp

   1 #include "tao/ORB.h"
   2 #include "tao/RTCORBA/RTCORBA.h"
   3 #include "ace/Thread_Manager.h"
   4 #include "ace/High_Res_Timer.h"
   5 #include "ace/Get_Opt.h"
   6 #include "ace/OS_NS_unistd.h"
   7
   8 static int test_try_lock_flag =
   9 #if defined (ACE_HAS_MUTEX_TIMEOUTS) && !defined (ACE_HAS_WTHREADS)
  10 1;
  11 #else
  12 // Don't test try_lock timed waits unless the underlying OS supports it
  13 // Windows is the exception.  It supports some mutex timeouts, so
  14 // it has ACE_HAS_MUTEX_TIMEOUTS defined, but it doesn't support
  15 // thread mutex timeouts which is what is needed for this to work.
  16 0;
  17 #endif /* defined (ACE_HAS_MUTEX_TIMEOUTS) && !defined (ACE_HAS_WTHREADS) */
  18
  19 // Parse command-line arguments.
  20
  21 static int
  22 parse_args (int argc, ACE_TCHAR *argv[])
  23 {
  24   ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("t"));
  25   int c;
  26
  27   while ((c = get_opts ()) != -1)
  28     switch (c)
  29       {
  30       case 't':
  31         test_try_lock_flag = 0;
  32         break;
  33
  34       case '?':
  35       default:
  36         ACE_ERROR_RETURN ((LM_ERROR,
  37                            "usage:  %s "
  38                            "-t"
  39                            "\n",
  40                            argv [0]),
  41                           -1);
  42       }
  43
  44   return 0;
  45 }
  46
  47 static int
  48 check_for_nil (CORBA::Object_ptr obj, const char *msg)
  49 {
  50   if (CORBA::is_nil (obj))
  51     ACE_ERROR_RETURN ((LM_ERROR,
  52                        "ERROR: Object reference <%C> is nil\n",
  53                        msg),
  54                       -1);
  55   else
  56     return 0;
  57 }
  58
  59 static int
  60 test_mutex_simple (RTCORBA::RTORB_ptr rt_orb)
  61 {
  62   // Test the basic interface of the RTCORBA::Mutex This test should
  63   // run even on platforms without thread support.
  64   try
  65     {
  66       RTCORBA::Mutex_var my_mutex;
  67
  68       my_mutex = rt_orb->create_mutex ();
  69
  70       my_mutex->lock ();
  71
  72       my_mutex->unlock ();
  73
  74       my_mutex->lock ();
  75
  76       my_mutex->unlock ();
  77
  78       rt_orb->destroy_mutex (my_mutex.in ());
  79     }
  80   catch (const CORBA::Exception& ex)
  81     {
  82       ex._tao_print_exception (
  83         "Unexpected exception caught in test_mutex_simple()");
  84       return -1;
  85     }
  86
  87   return 0;
  88 }
  89
  90 #if (TAO_HAS_NAMED_RT_MUTEXES == 1)
  91 static int
  92 test_named_mutex_simple (RTCORBA::RTORB_ptr rt_orb)
  93 {
  94   // Test the basic interface of the named RTCORBA::Mutex(es) This
  95   // test should run even on platforms without thread support.
  96   try
  97     {
  98       RTCORBA::Mutex_var larry_mutex1;
  99       RTCORBA::Mutex_var moe_mutex1;
 100       CORBA::Boolean created_flag;
 101
 102       larry_mutex1 = rt_orb->create_named_mutex ("larry",
 103                                                  created_flag);
 104
 105       if (created_flag != 1)
 106         ACE_ERROR_RETURN ((LM_ERROR,
 107                            "ERROR: Expected named mutex larry to be created, but it wasn't\n"),
 108                           -1);
 109
 110       moe_mutex1 = rt_orb->create_named_mutex ("moe",
 111                                                created_flag);
 112
 113       if (created_flag != 1)
 114         ACE_ERROR_RETURN ((LM_ERROR,
 115                            "ERROR: Expected named mutex moe to be created, but it wasn't\n"),
 116                           -1);
 117
 118       larry_mutex1->lock ();
 119
 120       larry_mutex1->unlock ();
 121
 122       // Test creating the mutex a second time
 123       {
 124         RTCORBA::Mutex_var larry_mutex2;
 125         larry_mutex2 = rt_orb->create_named_mutex ("larry",
 126                                                    created_flag);
 127
 128         if (created_flag != 0)
 129           ACE_ERROR_RETURN ((LM_ERROR,
 130                              "ERROR: Expected named mutex to already be created, but it wasn't\n"),
 131                             -1);
 132
 133         // test the pointers...
 134         if (reinterpret_cast<void *> (larry_mutex1.in ())
 135             != reinterpret_cast<void *> (larry_mutex2.in ()))
 136           ACE_ERROR_RETURN ((LM_ERROR,
 137                              "ERROR: Should have gotten the same mutex, but didn't\n"),
 138                             -1);
 139
 140         larry_mutex2->lock ();
 141
 142         larry_mutex2->unlock ();
 143       }
 144
 145       // test opening the mutex
 146       {
 147         RTCORBA::Mutex_var larry_mutex3;
 148         larry_mutex3 = rt_orb->open_named_mutex ("larry");
 149
 150         // test the pointers...
 151         if (reinterpret_cast<void *> (larry_mutex1.in ())
 152             != reinterpret_cast<void *> (larry_mutex3.in ()))
 153           ACE_ERROR_RETURN ((LM_ERROR,
 154                              "ERROR: Should have gotten the same mutex, but didn't\n"),
 155                             -1);
 156
 157         larry_mutex3->lock ();
 158
 159         larry_mutex3->unlock ();
 160       }
 161
 162       // Make sure that nothing has been broken behind the scenes.
 163       larry_mutex1->lock ();
 164
 165       larry_mutex1->unlock ();
 166
 167       rt_orb->destroy_mutex (larry_mutex1.in ());
 168
 169       rt_orb->destroy_mutex (moe_mutex1.in ());
 170     }
 171   catch (const CORBA::Exception& ex)
 172     {
 173       ex._tao_print_exception (
 174         "Unexpected exception caught in test_named_mutex_simple()");
 175       return -1;
 176     }
 177
 178   return 0;
 179 }
 180
 181 static int
 182 test_named_mutex_exception (RTCORBA::RTORB_ptr rt_orb)
 183 {
 184   // Test that open_named_mutex returns an exception when the mutex
 185   // name isn't found.
 186
 187   // This test should run even on platforms without thread support.
 188   try
 189     {
 190       RTCORBA::Mutex_var larry_mutex1;
 191
 192       larry_mutex1 = rt_orb->open_named_mutex ("larry");
 193
 194       ACE_ERROR_RETURN ((LM_ERROR,
 195                          "Expected a MutexNotFound exception, but didn't get one.\n"),
 196                         -1);
 197     }
 198   catch (const RTCORBA::RTORB::MutexNotFound& ex)
 199     {
 200       ACE_DEBUG ((LM_DEBUG, "Caught expected MutexNotFound exception.\n"));
 201     }
 202   catch (const CORBA::Exception& ex)
 203     {
 204       ex._tao_print_exception (
 205         "Unexpected exception caught in test_named_mutex_exception()");
 206       return -1;
 207     }
 208
 209   return 0;
 210 }
 211 #endif /* TAO_HAS_NAMED_RT_MUTEXES == 1 */
 212
 213 #if defined (ACE_HAS_THREADS)
 214 const size_t MAX_ITERATIONS=10;
 215 const size_t MAX_THREADS=4;
 216
 217 struct Mutex_Test_Data
 218 {
 219   RTCORBA::Mutex_ptr mutex;
 220   int *shared_var;
 221   int *error_flag;
 222 };
 223
 224 static void *
 225 mutex_test_thread (void *args)
 226 {
 227   Mutex_Test_Data *data = reinterpret_cast<Mutex_Test_Data *> (args);
 228
 229   RTCORBA::Mutex_ptr mutex = data->mutex;
 230   int *shared_var = data->shared_var;
 231
 232   ACE_OS::srand (static_cast<u_int> (ACE_OS::time (0)));
 233
 234   try
 235     {
 236       for (size_t i = 0; i < MAX_ITERATIONS / 2; i++)
 237         {
 238           ACE_DEBUG ((LM_DEBUG,
 239                       ACE_TEXT ("(%P|%t) = trying to lock on iteration %d\n"),
 240                       i));
 241           mutex->lock ();
 242
 243           ACE_DEBUG ((LM_DEBUG,
 244                       ACE_TEXT ("(%P|%t) = locked on iteration %d\n"),
 245                       i));
 246
 247           // Check if the shared var is a value it shouldn't be when
 248           // we're under the lock.
 249           if (*shared_var != 0)
 250             {
 251               ACE_ERROR ((LM_ERROR,
 252                           "Expected shared_var to be 0 under the mutex\n"));
 253               *data->error_flag = 1;
 254             }
 255
 256           *shared_var = 1;
 257
 258           // Sleep for a random amount of time between 0 and 2
 259           // seconds.  Note that it's ok to use rand() here because we
 260           // are running within the critical section defined by the
 261           // Thread_Mutex.
 262           ACE_OS::sleep (ACE_OS::rand () % 2);
 263
 264           if (*shared_var != 1)
 265             {
 266               ACE_ERROR ((LM_ERROR,
 267                           "Expected shared_var to still be 1 after sleeping\n"));
 268               *data->error_flag = 1;
 269             }
 270
 271           *shared_var = 0;
 272
 273           mutex->unlock ();
 274
 275           ACE_DEBUG ((LM_DEBUG,
 276                       ACE_TEXT ("(%P|%t) = unlocked on iteration %d\n"),
 277                       i));
 278         }
 279     }
 280   catch (const CORBA::Exception& ex)
 281     {
 282       ex._tao_print_exception (
 283         "Unexpected exception caught in mutex_test_thread()");
 284       *data->error_flag = 1;
 285     }
 286
 287   return 0;
 288 }
 289
 290 static int
 291 test_mutex_threads (RTCORBA::RTORB_ptr rt_orb)
 292 {
 293   // test the RTCORBA::Mutex implementation be spawning many threads
 294   // that repeatedly content for a lock.  This code is based on the
 295   // tests/Thread_Mutex_Test code.
 296
 297   Mutex_Test_Data test_data;
 298
 299   const u_int n_threads = MAX_THREADS;
 300   int shared_var = 0;
 301   int error_flag = 0;
 302
 303   try
 304     {
 305       RTCORBA::Mutex_ptr mutex = rt_orb->create_mutex ();
 306
 307       test_data.mutex = mutex;
 308       test_data.shared_var = &shared_var;
 309       test_data.error_flag = &error_flag;
 310
 311       if (ACE_Thread_Manager::instance ()->spawn_n (n_threads,
 312                                                     ACE_THR_FUNC (mutex_test_thread),
 313                                                     (void *) &test_data,
 314                                                     THR_NEW_LWP | THR_DETACHED) == -1)
 315         ACE_ERROR ((LM_ERROR,
 316                     ACE_TEXT ("%p\n%a"),
 317                     ACE_TEXT ("thread create failed")));
 318
 319       // Wait for the threads to exit.
 320       ACE_Thread_Manager::instance ()->wait ();
 321
 322       CORBA::release (mutex);
 323     }
 324   catch (const CORBA::Exception& ex)
 325     {
 326       ex._tao_print_exception (
 327         "Unexpected exception caught in test_mutex_threads()");
 328       return -1;
 329     }
 330
 331   return error_flag;
 332 }
 333
 334 static void *
 335 mutex_test_try_lock_thread (void *args)
 336 {
 337   // test out try_lock() failure cases
 338   Mutex_Test_Data *data = reinterpret_cast<Mutex_Test_Data *> (args);
 339
 340   RTCORBA::Mutex_ptr mutex = data->mutex;
 341   CORBA::Boolean result;
 342
 343   try
 344     {
 345       // check that try_lock (0) returns false
 346       ACE_DEBUG ((LM_DEBUG,"attempting try_lock (0) - expect failure (but no exceptions)\n"));
 347       result = mutex->try_lock (0u);
 348
 349       if (result)
 350         {
 351           ACE_ERROR ((LM_ERROR,
 352                       "try_lock succeeded, but expected a failure\n"));
 353           *data->error_flag = 1;
 354         }
 355
 356       if (test_try_lock_flag)
 357         {
 358           ACE_High_Res_Timer timer;
 359
 360           // Check that try_lock (timeout) returns false (and times
 361           // out)
 362           ACE_DEBUG ((LM_DEBUG,
 363                       "attempting try_lock (5 sec) - expect failure after 5 secs (but no exceptions)\n"));
 364
 365           timer.start ();
 366           result = mutex->try_lock (50000000u /*5sec*/);
 367           timer.stop ();
 368
 369           if (result)
 370             {
 371               ACE_ERROR ((LM_ERROR,
 372                           "try_lock (timeout) succeeded, but expected a failure\n"));
 373               *data->error_flag = 1;
 374             }
 375
 376           ACE_Time_Value measured;
 377           timer.elapsed_time (measured);
 378           ACE_DEBUG ((LM_DEBUG,
 379                       "try_lock returned after %u secs, %u usecs\n",
 380                       measured.sec(),
 381                       measured.usec()));
 382
 383           if ((measured.sec() == 4 && measured.usec() >= 500000)
 384               || (measured.sec() == 5 && measured.usec() <= 500000))
 385             /* success */;
 386           else
 387             {
 388               ACE_ERROR ((LM_ERROR,
 389                           "try_lock timed out not as expected\n"));
 390               *data->error_flag = 1;
 391             }
 392         }
 393     }
 394   catch (const CORBA::Exception& ex)
 395     {
 396       ex._tao_print_exception (
 397         "Unexpected exception caught in mutex_test_try_lock_thread()");
 398       *data->error_flag = 1;
 399     }
 400
 401   return 0;
 402 }
 403
 404 static int
 405 test_mutex_try_lock (RTCORBA::RTORB_ptr rt_orb)
 406 {
 407   Mutex_Test_Data test_data;
 408   CORBA::Boolean result;
 409
 410   int shared_var = 0;
 411   int error_flag = 0;
 412
 413   try
 414     {
 415       RTCORBA::Mutex_ptr mutex = rt_orb->create_mutex ();
 416
 417       // Test out try_lock and keep the lock so that the spawned task
 418       // can test out try_lock failure cases
 419       result = mutex->try_lock (0u);
 420       if (!result)
 421         ACE_ERROR_RETURN ((LM_ERROR,
 422                            "try_lock failed\n"),
 423                           -1);
 424
 425       test_data.mutex = mutex;
 426       test_data.shared_var = &shared_var;
 427       test_data.error_flag = &error_flag;
 428
 429       ACE_DEBUG ((LM_DEBUG,
 430                   "Spawning the test thread\n"));
 431       if (ACE_Thread_Manager::instance ()->spawn (ACE_THR_FUNC (mutex_test_try_lock_thread),
 432                                                   (void *) &test_data,
 433                                                   THR_NEW_LWP | THR_DETACHED) == -1)
 434         ACE_ERROR ((LM_ERROR,
 435                     ACE_TEXT ("%p\n%a"),
 436                     ACE_TEXT ("thread create failed")));
 437
 438       // Wait for the threads to exit.
 439       ACE_Thread_Manager::instance ()->wait ();
 440
 441       mutex->unlock ();
 442
 443       CORBA::release (mutex);
 444     }
 445   catch (const CORBA::Exception& ex)
 446     {
 447       ex._tao_print_exception (
 448         "Unexpected exception caught in test_mutex_try_lock()");
 449       return -1;
 450     }
 451
 452   return error_flag;
 453 }
 454
 455 #endif /* ACE_HAS_THREADS */
 456
 457 int
 458 ACE_TMAIN(int argc, ACE_TCHAR *argv[])
 459 {
 460   try
 461     {
 462       // ORB.
 463       CORBA::ORB_var orb = CORBA::ORB_init (argc, argv);
 464
 465       // Parse arguments.
 466       if (parse_args (argc, argv) != 0)
 467         return -1;
 468
 469       // RTORB.
 470       CORBA::Object_var object =
 471         orb->resolve_initial_references ("RTORB");
 472       RTCORBA::RTORB_var rt_orb = RTCORBA::RTORB::_narrow (object.in ());
 473       if (check_for_nil (rt_orb.in (), "RTORB") == -1)
 474         return -1;
 475
 476       ACE_DEBUG ((LM_DEBUG,
 477                   "Running RTCORBA Mutex unit tests\n"));
 478
 479       if (test_mutex_simple (rt_orb.in ()) != 0)
 480         ACE_ERROR_RETURN ((LM_ERROR,
 481                            "test_mutex_simple failed\n"),
 482                           -1);
 483
 484 #if (TAO_HAS_NAMED_RT_MUTEXES == 1)
 485       if (test_named_mutex_simple (rt_orb.in ()) != 0)
 486         ACE_ERROR_RETURN ((LM_ERROR,
 487                            "test_named_mutex_simple failed\n"),
 488                           -1);
 489
 490       if (test_named_mutex_exception (rt_orb. in ()) != 0)
 491         ACE_ERROR_RETURN ((LM_ERROR,
 492                            "test_named_mutex_exception failed\n"),
 493                           -1);
 494 #else
 495       ACE_DEBUG ((LM_DEBUG,
 496                   "Named RT_Mutex support is not enabled. "
 497                   "Skipping Named RT_Mutex tests.\n"));
 498 #endif /* TAO_HAS_NAMED_RT_MUTEXES == 1 */
 499
 500 #if defined (ACE_HAS_THREADS)
 501
 502       if (test_mutex_threads (rt_orb.in ()) != 0)
 503         ACE_ERROR_RETURN ((LM_ERROR,
 504                            "test_mutex_threads failed\n"),
 505                           -1);
 506       else if (test_mutex_try_lock (rt_orb.in ()) != 0)
 507         ACE_ERROR_RETURN ((LM_ERROR,
 508                            "test_mutex_try_lock failed\n"),
 509                           -1);
 510
 511 #endif /* ACE_HAS_THREADS */
 512
 513       ACE_DEBUG ((LM_DEBUG, "Mutex test finished\n\n"));
 514     }
 515   catch (const CORBA::Exception& ex)
 516     {
 517       ex._tao_print_exception (
 518         "Unexpected exception caught in Mutex test server:");
 519       return -1;
 520     }
 521
 522   return 0;
 523 }