ACE/examples/Threads/task_five.cpp

   1
   2 //=============================================================================
   3 /**
   4  *  @file    task_five.cpp
   5  *
   6  * Stress testing thread creation and thread cancellation using
   7  * ACE_Task.
   8  *
   9  *  @author Author: Detlef Becker <Detlef.Becker@med.siemens.de>
  10  */
  11 //=============================================================================
  12
  13
  14 #include "ace/OS_main.h"
  15 #include "ace/Thread_Manager.h"
  16 #include "ace/Task.h"
  17 #include "ace/OS_NS_unistd.h"
  18
  19 static const int DEFAULT_TASKS = 100;
  20 static const int DEFAULT_ITERATIONS = 10;
  21
  22 // Default stack size
  23 static size_t default_stack_size =
  24 #if defined (ACE_WIN32)
  25     0;
  26 #else
  27     8192;
  28 #endif /* ACE_WIN32 */
  29   u_int loop_count = 0;
  30   u_int error_count = 0;
  31
  32 class Test_Task : public ACE_Task<ACE_SYNCH>
  33 {
  34 public:
  35   Test_Task (ACE_Thread_Manager * = ACE_Thread_Manager::instance ());
  36   ~Test_Task () {};
  37
  38   //FUZZ: disable check_for_lack_ACE_OS
  39   int open (void * = 0);
  40   int svc ();
  41   int close (u_long);
  42
  43   ///FUZZ: enable check_for_lack_ACE_OS
  44   int shutdown ();
  45
  46   int synch ();
  47 };
  48
  49 Test_Task::Test_Task (ACE_Thread_Manager *thrmgr)
  50   : ACE_Task<ACE_SYNCH> (thrmgr)
  51 {
  52 }
  53
  54 int
  55 Test_Task::open (void *)
  56 {
  57   return this->activate (0,
  58                          1,
  59                          0,
  60                          ACE_DEFAULT_THREAD_PRIORITY,
  61                          -1,
  62                          0,
  63                          0,
  64                          0,
  65                          &default_stack_size);
  66 }
  67
  68 int
  69 Test_Task::svc ()
  70 {
  71   while (thr_mgr_->testcancel (ACE_OS::thr_self ()) == 0)
  72     // Sleep for 350 msecs.
  73     ACE_OS::sleep (ACE_Time_Value (0, 350000));
  74
  75   return 0;
  76 }
  77
  78 int
  79 Test_Task::close (u_long)
  80 {
  81   ACE_DEBUG ((LM_DEBUG, "(%t) closing down\n"));
  82   return 0;
  83 }
  84
  85 int
  86 Test_Task::shutdown ()
  87 {
  88   return thr_mgr_->cancel_grp (grp_id_);
  89 }
  90
  91 int
  92 Test_Task::synch ()
  93 {
  94   return thr_mgr_->wait_grp (grp_id_);
  95 }
  96
  97 static void
  98 work (ACE_Thread_Manager *thr_mgr,
  99       int n_tasks,
 100       size_t stack_size)
 101 {
 102   ACE_UNUSED_ARG (stack_size);
 103
 104   int i;
 105   Test_Task *task_array;
 106
 107   ACE_NEW (task_array,
 108            Test_Task[n_tasks]);
 109
 110   ACE_DEBUG ((LM_DEBUG,
 111               "Opening Tasks, loop count = %d, error count = %d\n",
 112               loop_count,
 113               error_count));
 114
 115   for (i = 0;
 116        i < n_tasks;
 117        i++)
 118     task_array[i].open ();
 119
 120   ACE_OS::sleep (1);
 121
 122   ACE_DEBUG ((LM_DEBUG,
 123               "Cancelling Tasks, loop count = %d, error count = %d\n",
 124               loop_count,
 125               error_count));
 126
 127   for (i = 0; i < n_tasks; i++)
 128     task_array[i].shutdown ();
 129
 130   ACE_DEBUG ((LM_DEBUG,
 131               "Synching Tasks, loop count = %d, error count = %d\n",
 132               loop_count,
 133               error_count));
 134
 135   for (i = 0;
 136
 137        i < n_tasks; i++)
 138     if (-1 == task_array[i].synch ())
 139       {
 140         ACE_ERROR ((LM_ERROR,
 141                     "Error in synch! loop count = %d, error count = %d\n",
 142                     loop_count,
 143                     error_count));
 144         error_count++;
 145       }
 146
 147   ACE_DEBUG ((LM_DEBUG,
 148               "thr_mgr->wait ();! loop count = %d, error count = %d\n",
 149               loop_count,
 150               error_count));
 151
 152   // Wait for all the threads to finish.
 153   thr_mgr->wait ();
 154
 155   delete [] task_array;
 156   loop_count++;
 157 }
 158
 159 int
 160 ACE_TMAIN (int argc, ACE_TCHAR *argv[])
 161 {
 162   size_t stack_size = argc > 1 ? ACE_OS::atoi (argv[1]) : default_stack_size;
 163   const int n_tasks = argc > 2 ? ACE_OS::atoi (argv[2]) : DEFAULT_TASKS;
 164   u_int iterations = argc > 3 ? ACE_OS::atoi (argv[3]) : DEFAULT_ITERATIONS;
 165
 166   for (u_int i = 0; i < iterations; i++)
 167     work (ACE_Thread_Manager::instance (),
 168           n_tasks,
 169           stack_size);
 170
 171   return 0;
 172 }