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;
}
