int main( int argc, char *argv[] ) { hthread_t tid[ CHILDREN ]; hthread_mutex_t mutex; hthread_mutexattr_t attr; Huint i; hthread_mutexattr_init( &attr ); hthread_mutexattr_settype( &attr, HTHREAD_MUTEX_FAST_NP ); hthread_mutexattr_setnum( &attr, 1 ); hthread_mutex_init( &mutex, &attr ); for( i = 0; i < CHILDREN; i++ ) { hthread_create( &tid[i], NULL, child, &mutex ); } for( i = 0; i < CHILDREN; i++ ) { hthread_join( tid[i], NULL ); } printf( "--DONE--\n" ); return 1; }
/*-------------------------------------------------------------------*/ DLL_EXPORT void ptt_trace_init( int n, int init ) { if (n > 0) pttrace = calloc( n, PTT_TRACE_SIZE ); else pttrace = NULL; pttracen = pttrace ? n : 0; pttracex = 0; if (init) /* First time? */ { int rc; MATTR attr; if ((rc = hthread_mutexattr_init( &attr )) != 0) BREAK_INTO_DEBUGGER(); if ((rc = hthread_mutexattr_settype( &attr, HTHREAD_MUTEX_DEFAULT )) != 0) BREAK_INTO_DEBUGGER(); if ((rc = hthread_mutex_init( &pttlock, &attr )) != 0) BREAK_INTO_DEBUGGER(); if ((rc = hthread_mutex_init( &ptttolock, &attr )) != 0) BREAK_INTO_DEBUGGER(); if ((rc = hthread_cond_init( &ptttocond )) != 0) BREAK_INTO_DEBUGGER(); if ((rc = hthread_mutexattr_destroy( &attr )) != 0) BREAK_INTO_DEBUGGER(); pttnolock = 0; pttnotod = 0; pttnowrap = 0; pttto = 0; ptttotid = 0; } }
/*-------------------------------------------------------------------*/ DLL_EXPORT int hthread_initialize_rwlock( RWLOCK* plk, const char* name, const char* location ) { int rc; RWATTR attr1; /* for primary lock */ MATTR attr2; /* for internal locklock */ ILOCK* ilk = hthreads_get_ILOCK( plk, name ); /* Initialize the requested lock */ rc = hthread_rwlockattr_init( &attr1 ); if (rc) goto fatal; rc = hthread_mutexattr_init( &attr2 ); if (rc) goto fatal; rc = hthread_rwlockattr_setpshared( &attr1, HTHREAD_RWLOCK_DEFAULT ); if (rc) goto fatal; rc = hthread_mutexattr_settype( &attr2, HTHREAD_MUTEX_DEFAULT ); if (rc) goto fatal; rc = hthread_rwlock_init( &ilk->rwlock, &attr1 ); if (rc) goto fatal; rc = hthread_mutex_init( &ilk->locklock, &attr2 ); if (rc) goto fatal; rc = hthread_rwlockattr_destroy( &attr1 ); if (rc) goto fatal; rc = hthread_mutexattr_destroy( &attr2 ); if (rc) goto fatal; plk->ilk = ilk; /* (RWLOCK is now initialized) */ PTTRACE( "rwlock init", plk, &attr1, location, PTT_MAGIC ); return 0; fatal: perror( "Fatal error in hthread_initialize_rwlock function" ); exit(1); }
/*-------------------------------------------------------------------*/ DLL_EXPORT int hthread_initialize_lock( LOCK* plk, const char* name, const char* location ) { int rc; MATTR attr; ILOCK* ilk = hthreads_get_ILOCK( plk, name ); /* Initialize the requested lock */ rc = hthread_mutexattr_init( &attr ); if (rc) goto fatal; rc = hthread_mutexattr_settype( &attr, HTHREAD_MUTEX_DEFAULT ); if (rc) goto fatal; rc = hthread_mutex_init( &ilk->locklock, &attr ); if (rc) goto fatal; rc = hthread_mutex_init( &ilk->lock, &attr ); if (rc) goto fatal; rc = hthread_mutexattr_destroy( &attr ); if (rc) goto fatal; plk->ilk = ilk; /* (LOCK is now initialized) */ PTTRACE( "lock init", plk, 0, location, PTT_MAGIC ); return 0; fatal: perror( "Fatal error in hthread_initialize_lock function" ); exit(1); }
int main( int argc, char *argv[] ) { hthread_t tid[ CHILDREN ]; hthread_mutex_t mutex[ MUTEXES ]; hthread_mutexattr_t attr; Huint i; Huint j; Huint c; hthread_mutexattr_init( &attr ); hthread_mutexattr_settype( &attr, HTHREAD_MUTEX_FAST_NP ); c = 0; for( i = 0; i < MUTEXES; i++ ) { hthread_mutexattr_setnum( &attr, i ); hthread_mutex_init( &mutex[i], &attr ); for( j = 0; j < CHILDREN_PER_MUTEX; j++ ) { hthread_create( &tid[c], NULL, child, &mutex[i] ); printf( "Created Child %u\n", tid[c] ); c++; } } for( i = 0; i < CHILDREN; i++ ) { printf( "Join Child %u\n", tid[i] ); hthread_join( tid[i], NULL ); } printf( "--DONE--\n" ); return 1; }
/*-------------------------------------------------------------------*/ static void hthreads_internal_init() { static BYTE bDidInit = FALSE; if (!bDidInit) { MATTR attr; int rc, herc_high_pri, host_high_pri; /* Initialize our internal lock */ rc = hthread_mutexattr_init( &attr ); if (rc) goto fatal; rc = hthread_mutexattr_settype( &attr, HTHREAD_MUTEX_DEFAULT ); if (rc) goto fatal; rc = hthread_mutex_init( &listlock, &attr ); if (rc) goto fatal; rc = hthread_mutexattr_destroy( &attr ); if (rc) goto fatal; /* Initialize our locks list anchor */ InitializeListHead( &locklist ); lockcount = 0; /* Initialize thread scheduling variables */ herc_policy = HTHREAD_SCHED_DEF; herc_low_pri = HTHREAD_MIN_PRI; herc_high_pri = HTHREAD_MAX_PRI; host_low_pri = hthread_sched_get_priority_min( herc_policy ); host_high_pri = hthread_sched_get_priority_max( herc_policy ); herc_pri_rvrsd = (herc_high_pri < herc_low_pri); host_pri_rvrsd = (host_high_pri < host_low_pri); herc_pri_amt = herc_pri_rvrsd ? (herc_low_pri - herc_high_pri) : (herc_high_pri - herc_low_pri); host_pri_amt = host_pri_rvrsd ? (host_low_pri - host_high_pri) : (host_high_pri - host_low_pri); /* One-time initialization completed */ bDidInit = TRUE; return; fatal: perror( "Fatal error in hthreads_internal_init function" ); exit(1); } return; }
int main() { struct threadpool tp; hthread_mutex_t task_queue_mutex; hthread_cond_t active_task; // Init. global print mutex hthread_mutex_init(&print_mutex, NULL); // Setup mutex printf("Setting up mutex..."); hthread_mutexattr_t mta; hthread_mutexattr_settype(&mta, HTHREAD_MUTEX_RECURSIVE_NP); hthread_mutexattr_setnum(&mta, 1); hthread_mutex_init(&task_queue_mutex, &mta); printf("DONE\n"); // Setup cond. var printf("Setting up cond.var..."); hthread_condattr_t cta; hthread_condattr_init(&cta); hthread_cond_init(&active_task, &cta); printf("DONE\n"); // Setup threadpool struct tp.task_queue_mutex = &task_queue_mutex; tp.active_task = &active_task; tp.total_tasks = 0; tp.request_errors = 0; tp.head_ptr = NULL; tp.tail_ptr = NULL; // Init threadpool printf("Creating thread pool..."); thread_pool_init(&tp, 8); printf("DONE\n"); int i; void (*x) (void *); void (*y) (void *); x = func; y = func2; for (i = 0; i < 15; i++) { aprintf("Adding task %d...\n", i); if (i %4 == 0) { add_task(&tp, i, *x, (void*)i); } else { add_task(&tp, i, *y, (void*)i); } } aprintf("Waiting for completion...\n"); while (tp.total_tasks > 0) { aprintf("Main running (%d)...\n", tp.total_tasks); hthread_yield(); } aprintf("DONE!!!\n"); /* while(1) { hthread_yield(); } */ return 0; }