tests/testMutex.cpp

   1 /*
   2         Copyright (C) 2004-2008 Grame
   3
   4         This program is free software; you can redistribute it and/or modify
   5         it under the terms of the GNU General Public License as published by
   6         the Free Software Foundation; either version 2 of the License, or
   7         (at your option) any later version.
   8
   9         This program is distributed in the hope that it will be useful,
  10         but WITHOUT ANY WARRANTY; without even the implied warranty of
  11         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12         GNU General Public License for more details.
  13
  14         You should have received a copy of the GNU General Public License
  15         along with this program; if not, write to the Free Software
  16         Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #include <stdio.h>
  21 #include <sys/time.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <unistd.h>
  25
  26 #ifdef __APPLE__
  27 #include "JackMachThread.h"
  28 #endif
  29
  30 #include "JackPosixThread.h"
  31 #include "JackMutex.h"
  32 #include "thread.h"
  33
  34 using namespace Jack;
  35
  36 static void CleanupHandler(void * arg)
  37 {
  38     JackLockAble* locked = (JackLockAble*)arg;
  39     printf("CleanupHandler locked %px \n", locked);
  40     locked->Unlock();
  41 }
  42
  43 struct LockedObject : public JackLockAble {
  44
  45     int fCount;
  46
  47         LockedObject():fCount(0)
  48         {}
  49
  50     virtual ~LockedObject()
  51         {}
  52
  53     /*
  54     void LockedMethod1()
  55     {
  56         JackLock lock(this);
  57         fCount++;
  58         printf("LockedMethod1 self %x fCount %d\n", pthread_self(), fCount);
  59         if (fCount >= 1000) {
  60             printf("Terminate self %x\n", pthread_self());
  61             pthread_exit(NULL);
  62         }
  63    }
  64
  65     void LockedMethod2()
  66     {
  67         JackLock lock(this);
  68         fCount++;
  69         printf("LockedMethod2 self %x fCount %d\n", pthread_self(), fCount);
  70         if (fCount >= 1500) {
  71             printf("Terminate self %x\n", pthread_self());
  72             pthread_exit(NULL);
  73         }
  74     }
  75
  76     void LockedMethod3()
  77     {
  78         JackLock lock(this);
  79         fCount++;
  80         printf("LockedMethod3 self %x fCount %d\n", pthread_self(), fCount);
  81         if (fCount >= 3000) {
  82             printf("Terminate self %x\n", pthread_self());
  83             pthread_exit(NULL);
  84         }
  85     }
  86     */
  87
  88     void LockedMethod1()
  89     {
  90         pthread_cleanup_push(CleanupHandler, this);
  91         Lock();
  92         fCount++;
  93         //printf("LockedMethod1 self %x fCount %d\n", pthread_self(), fCount);
  94         if (fCount >= 1000) {
  95             printf("Terminate self = %px  count = %d\n", pthread_self(), fCount);
  96             pthread_exit(NULL);
  97         }
  98         Unlock();
  99         pthread_cleanup_pop(0);
 100     }
 101
 102     void LockedMethod2()
 103     {
 104         pthread_cleanup_push(CleanupHandler, this);
 105         Lock();
 106
 107         fCount++;
 108         //printf("LockedMethod2 self %x fCount %d\n", pthread_self(), fCount);
 109         if (fCount >= 1500) {
 110             printf("Terminate self = %px  count = %d\n", pthread_self(), fCount);
 111             pthread_exit(NULL);
 112         }
 113         Unlock();
 114         pthread_cleanup_pop(0);
 115     }
 116
 117     void LockedMethod3()
 118     {
 119         pthread_cleanup_push(CleanupHandler, this);
 120         Lock();
 121
 122         fCount++;
 123         //printf("LockedMethod3 self %x fCount %d\n", pthread_self(), fCount);
 124         if (fCount >= 3000) {
 125             printf("Terminate self = %px  count = %d\n", pthread_self(), fCount);
 126             pthread_exit(NULL);
 127         }
 128         Unlock();
 129         pthread_cleanup_pop(0);
 130     }
 131
 132
 133 };
 134
 135 struct TestThread : public JackRunnableInterface {
 136
 137         JackMachThread* fThread;
 138     LockedObject* fObject;
 139     int fNum;
 140
 141         TestThread(LockedObject* obj, int num)
 142         {
 143         printf("TestThread\n");
 144         fThread = new JackMachThread(this);
 145         fObject = obj;
 146         fNum = num;
 147             fThread->StartSync();
 148    }
 149
 150         virtual ~TestThread()
 151         {
 152         printf("DELETE %px\n", fThread);
 153         fThread->Kill();
 154                 delete fThread;
 155         }
 156
 157     bool Execute()
 158     {
 159                 //printf("TestThread Execute\n");
 160         switch (fNum) {
 161
 162             case 1:
 163                 fObject->LockedMethod1();
 164                 /*
 165                 if (fObject->fCount >= 500) {
 166                     printf("Terminate self %x\n", pthread_self());
 167                     fThread->Terminate();
 168                 }
 169                 */
 170                 break;
 171
 172             case 2:
 173                 fObject->LockedMethod2();
 174                 /*
 175                 if (fObject->fCount >= 1500) {
 176                     printf("Terminate self %x\n", pthread_self());
 177                     fThread->Terminate();
 178                 }
 179                 */
 180                 break;
 181
 182             case 3:
 183                 fObject->LockedMethod3();
 184                 /*
 185                 if (fObject->fCount >= 2000) {
 186                     printf("Terminate self %x\n", pthread_self());
 187                     fThread->Terminate();
 188                 }
 189                 */
 190                 break;
 191         };
 192
 193         //usleep(fNum * 1000);
 194                 return true;
 195     }
 196
 197 };
 198
 199 static void* TestThread1_Execute(void* arg);
 200
 201 struct TestThread1 : public JackRunnableInterface {
 202
 203         pthread_t fThread;
 204     LockedObject* fObject;
 205     int fNum;
 206
 207         TestThread1(LockedObject* obj, int num)
 208         {
 209         if (jack_client_create_thread(NULL, &fThread, 0, 0, TestThread1_Execute, this))
 210                         jack_error( "Can't create the network manager control thread." );
 211         fObject = obj;
 212         fNum = num;
 213         }
 214
 215         virtual ~TestThread1()
 216         {}
 217
 218     bool Execute()
 219     {
 220                 printf("TestThread Execute\n");
 221         switch (fNum) {
 222
 223             case 1:
 224                 fObject->LockedMethod1();
 225                 break;
 226
 227             case 2:
 228                 fObject->LockedMethod2();
 229                 break;
 230
 231             case 3:
 232                 fObject->LockedMethod3();
 233                 break;
 234         };
 235
 236         //usleep(fNum * 1000);
 237                 return true;
 238     }
 239
 240 };
 241
 242 static void* TestThread1_Execute(void* arg)
 243 {
 244     TestThread1* obj = (TestThread1*)arg;
 245
 246     while (true) {
 247         //printf("TestThread Execute\n");
 248         switch (obj->fNum) {
 249
 250                 case 1:
 251                     obj->fObject->LockedMethod1();
 252                     break;
 253
 254                 case 2:
 255                     obj->fObject->LockedMethod2();
 256                     break;
 257
 258                 case 3:
 259                     obj->fObject->LockedMethod3();
 260                     break;
 261         };
 262
 263         //usleep(obj->fNum * 1000);
 264     }
 265
 266     return 0;
 267 }
 268
 269 int main (int argc, char * const argv[])
 270 {
 271     char c;
 272
 273     LockedObject obj;
 274
 275     TestThread th1(&obj, 1);
 276     TestThread th2(&obj, 2);
 277     TestThread th3(&obj, 3);
 278
 279     /*
 280     LockedObject obj;
 281     TestThread1 th1(&obj, 1);
 282     TestThread th2(&obj, 2);
 283     TestThread th3(&obj, 3);
 284     */
 285
 286     /*
 287     while ((c = getchar()) != 'q') {
 288
 289     }
 290     */
 291
 292     while (true) {
 293         usleep(1000);
 294         th1.fThread->Kill();
 295     }
 296
 297     /*
 298     th1.fThread->Kill();
 299     th2.fThread->Kill();
 300     th3.fThread->Kill();
 301
 302      while (true) {
 303         //usleep(100000);
 304         th1.fThread->Kill();
 305     }
 306     */
 307
 308 }