ACE/examples/Threads/tss2.cpp

   1
   2 //=============================================================================
   3 /**
   4  *  @file    tss2.cpp
   5  *
   6  *   This program tests various features of ACE_Thread and the
   7  *   thread-specific storage variant of <ACE_Singleton>.
   8  *
   9  *  @author Prashant Jain and Doug Schmidt
  10  */
  11 //=============================================================================
  12
  13
  14 #include "ace/OS_main.h"
  15 #include "ace/Thread.h"
  16 #include "ace/Log_Msg.h"
  17 #include "ace/Atomic_Op.h"
  18 #include "TSS_Data.h"
  19 #include "TSS_Obj.h"
  20 #include "TSS_Task.h"
  21
  22
  23 #if defined (ACE_HAS_THREADS)
  24
  25 const int MAX_TASKS = 4;
  26 const int MAX_ITERATIONS = 10;
  27
  28 ACE_Atomic_Op<ACE_Token, int> Test_Task::count_ (0);
  29 ACE_Atomic_Op<ACE_Token, int> Test_Task::wait_count_ (0);
  30 ACE_Atomic_Op<ACE_Token, int> Test_Task::max_count_ (0);
  31 int num_tasks = 0;
  32
  33 // ACE synchronization object.
  34 static ACE_Token token;
  35
  36 ACE_Atomic_Op<ACE_Thread_Mutex, int> TSS_Obj::count_ = 0;
  37
  38 TSS_Obj::TSS_Obj ()
  39 {
  40   TSS_Obj::count_++;
  41   ACE_DEBUG ((LM_DEBUG, "(%t) TSS_Obj+: %d\n", TSS_Obj::count_.value ()));
  42 }
  43
  44 TSS_Obj::~TSS_Obj ()
  45 {
  46   TSS_Obj::count_--;
  47   ACE_DEBUG ((LM_DEBUG, "(%t) TSS_Obj-: %d\n", TSS_Obj::count_.value ()));
  48 }
  49
  50 Test_Task::Test_Task ()
  51 {
  52   Test_Task::count_++;
  53   ACE_DEBUG ((LM_DEBUG,
  54               "(%t) Test_Task+: %d\n", Test_Task::count_.value ()));
  55 }
  56
  57 Test_Task::~Test_Task ()
  58 {
  59   Test_Task::count_--;
  60
  61   ACE_DEBUG ((LM_DEBUG,
  62               "(%t) Test_Task-: %d\n", Test_Task::count_.value ()));
  63   Test_Task::wait_count_--;
  64 }
  65
  66 void *
  67 Test_Task::svc (void *arg)
  68 {
  69   // When the thread exits this thread-specific object will be deleted
  70   // automatically.
  71   ACE_TSS<TSS_Obj> tss (new TSS_Obj);
  72
  73   TSS_DATA::instance ()->data (arg);
  74
  75   Test_Task::wait_count_++;
  76   Test_Task::max_count_++;
  77
  78   ACE_DEBUG ((LM_DEBUG, "(%t) svc: waiting (data = %u)\n",
  79               arg));
  80
  81   // Do a bunch of set operations on the TSS data just to make sure
  82   // that it's truly in TSS (it it weren't, the assertion would fail).
  83
  84   while (Test_Task::max_count_ < num_tasks)
  85     {
  86       TSS_DATA::instance ()->data (arg);
  87       ACE_Thread::yield ();
  88     }
  89
  90   ACE_DEBUG ((LM_DEBUG, "(%t) svc: waiting finished (data = %u)\n",
  91               arg));
  92
  93 #if 0
  94   ACE_ASSERT (TSS_DATA::instance ()->data () == arg);
  95 #endif
  96
  97   delete (Test_Task *) arg;
  98
  99   return 0;
 100 }
 101
 102 int
 103 Test_Task::open (void *arg)
 104 {
 105   if (ACE_Thread::spawn ((ACE_THR_FUNC) Test_Task::svc, arg) == -1)
 106     ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "ACE_Thread::spawn"), 0);
 107
 108   return 0;
 109 }
 110
 111 int
 112 ACE_TMAIN (int argc, ACE_TCHAR *argv[])
 113 {
 114   num_tasks = argc > 1 ? ACE_OS::atoi (argv[1]) : MAX_TASKS;
 115
 116   Test_Task **task_arr = 0;
 117
 118   ACE_NEW_RETURN (task_arr, Test_Task *[num_tasks], -1);
 119
 120   for (int i = 0; i < MAX_ITERATIONS; i++)
 121     {
 122       ACE_DEBUG ((LM_DEBUG,
 123                   "(%t) ********* iteration %d **********\n"
 124                   "Test_Task::max_count_ %d\n",
 125                   i,
 126                   Test_Task::max_count_.value ()));
 127       Test_Task::max_count_ = 0;
 128
 129       for (int j = 0; j < num_tasks; j++)
 130         {
 131           ACE_NEW_RETURN (task_arr[j], Test_Task, -1);
 132           task_arr[j]->open (task_arr[j]);
 133         }
 134
 135       ACE_DEBUG ((LM_DEBUG, "(%t) waiting for first thread started\n"));
 136
 137       for (;;)
 138         {
 139           ACE_Thread::yield ();
 140
 141           if (Test_Task::max_count_ != 0 )
 142             break;
 143         }
 144
 145       ACE_DEBUG ((LM_DEBUG, "(%t) First thread started\n"
 146                   "Waiting for all threads finished\n"));
 147
 148       for (;;)
 149         {
 150           if (!(Test_Task::max_count_ == num_tasks
 151                 && Test_Task::wait_count_ == 0))
 152             {
 153               ACE_Thread::yield ();
 154               continue;
 155             }
 156           ACE_DEBUG ((LM_DEBUG,
 157                       "(%t) Test_Task::max_count_ = %d,"
 158                       " Test_Task::wait_count_ = %d",
 159                       Test_Task::max_count_.value (),
 160                       Test_Task::wait_count_.value ()));
 161           break;
 162         }
 163
 164       ACE_DEBUG ((LM_DEBUG, "(%t) all threads finished\n"));
 165     }
 166
 167   return 0;
 168 }
 169
 170 ACE_SINGLETON_TEMPLATE_INSTANTIATE(ACE_TSS_Singleton, TSS_Data, ACE_SYNCH_MUTEX);
 171
 172
 173 #else
 174
 175 int
 176 ACE_TMAIN (int, ACE_TCHAR *[])
 177 {
 178   ACE_ERROR ((LM_ERROR, "threads not supported on this platform\n"));
 179   return 0;
 180 }
 181 #endif /* ACE_HAS_THREADS */