ACE/examples/Threads/task_two.cpp

   1 // Exercise more tests for the ACE Tasks.  This test can spawn off
   2 // zillions of tasks and then wait for them using both polling and the
   3 // ACE Thread Manager.
   4
   5 #include "ace/OS_main.h"
   6 #include "ace/Task.h"
   7
   8 #include "ace/Service_Config.h"
   9 #include "ace/Atomic_Op.h"
  10
  11
  12 #if defined (ACE_HAS_THREADS)
  13
  14 typedef ACE_Atomic_Op<ACE_Thread_Mutex, int> ATOMIC_INT;
  15
  16 static int zero = 0;
  17 static ATOMIC_INT task_count (zero);
  18 static ATOMIC_INT max_count (zero);
  19 static ATOMIC_INT wait_count (zero);
  20
  21 static int n_threads = 0;
  22
  23 // Default number of tasks.
  24 static const int default_threads = ACE_DEFAULT_THREADS;
  25
  26 // Default number of times to run the test.
  27 static const int default_iterations = 1000;
  28
  29 class Task_Test : public ACE_Task<ACE_MT_SYNCH>
  30 {
  31 public:
  32   //FUZZ: disable check_for_lack_ACE_OS
  33   virtual int open (void *args = 0);
  34   virtual int close (u_long flags = 0);
  35   //FUZZ: enable check_for_lack_ACE_OS
  36
  37   virtual int svc ();
  38
  39 private:
  40   static ACE_Thread_Mutex lock_;
  41 };
  42
  43 ACE_Thread_Mutex Task_Test::lock_;
  44
  45 int
  46 Task_Test::open (void *)
  47 {
  48   ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, Task_Test::lock_, -1);
  49
  50   task_count++;
  51   ACE_DEBUG ((LM_DEBUG, "(%t) creating Task_Test, task count = %d\n",
  52               task_count.value ()));
  53
  54   return this->activate (THR_BOUND);
  55 }
  56
  57 int
  58 Task_Test::close (u_long)
  59 {
  60   ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, Task_Test::lock_, -1);
  61
  62   task_count--;
  63   ACE_DEBUG ((LM_DEBUG, "(%t) destroying Task_Test, task count = %d\n",
  64               task_count.value ()));
  65   wait_count--;
  66   return 0;
  67 }
  68
  69 int
  70 Task_Test::svc ()
  71 {
  72   wait_count++;
  73   max_count++;
  74
  75   ACE_DEBUG ((LM_DEBUG, "(%t) svc: waiting\n"));
  76
  77   for (;;)
  78     if (max_count >= n_threads)
  79       break;
  80     else
  81       ACE_Thread::yield ();
  82
  83   ACE_DEBUG ((LM_DEBUG, "(%t) svc: finished waiting\n"));
  84   return 0;
  85 }
  86
  87 int
  88 ACE_TMAIN (int argc, ACE_TCHAR *argv[])
  89 {
  90   n_threads = argc > 1 ? ACE_OS::atoi (argv[1]) : default_threads;
  91   int n_iterations = argc > 2 ? ACE_OS::atoi (argv[2]) : default_iterations;
  92
  93   Task_Test **task_array = new Task_Test *[n_threads];
  94
  95   for (int i = 1; i <= n_iterations; i++)
  96     {
  97       ACE_DEBUG ((LM_DEBUG, "(%t) iteration = %d, max_count %d\n",
  98                   i, max_count.value ()));
  99       max_count = 0;
 100
 101       ACE_DEBUG ((LM_DEBUG, "(%t) starting %d task%s\n",
 102                   n_threads, n_threads == 1 ? "" : "s"));
 103
 104       // Launch the new tasks.
 105       for (int j = 0; j < n_threads; j++)
 106         {
 107           task_array[j] = new Task_Test;
 108           // Activate the task, i.e., make it an active object.
 109           task_array[j]->open ();
 110         }
 111
 112       // Wait for initialization to kick in.
 113       while (max_count == 0)
 114         ACE_Thread::yield ();
 115
 116       ACE_DEBUG ((LM_DEBUG, "(%t) waiting for threads to finish\n"));
 117
 118       // Wait for the threads to finish this iteration.
 119       while (max_count != n_threads && wait_count != 0)
 120         ACE_Thread::yield ();
 121
 122       ACE_DEBUG ((LM_DEBUG,
 123                   "(%t) iteration %d finished, max_count %d, wait_count %d, waiting for tasks to exit\n",
 124                   i, max_count.value (), wait_count.value ()));
 125
 126       // Wait for all the tasks to exit.
 127           ACE_Thread_Manager::instance ()->wait ();
 128
 129       // Delete the existing tasks.
 130       for (int k = 0; k < n_threads; k++)
 131         delete task_array[k];
 132     }
 133
 134   delete [] task_array;
 135
 136   ACE_DEBUG ((LM_DEBUG, "(%t) shutting down the test\n"));
 137   return 0;
 138 }
 139
 140 #else
 141 int
 142 ACE_TMAIN (int, ACE_TCHAR *[])
 143 {
 144   ACE_ERROR ((LM_ERROR, "threads not supported on this platform\n"));
 145   return 0;
 146 }
 147 #endif /* ACE_HAS_THREADS */