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;
}
int main(int argc, char *argv[]) {
hthread_mutexattr_t mutexAttr;
hthread_mutex_t mutex;
hthread_attr_t threadAttr;
hthread_t thread;
Huint arg;
log_t log;
//Initialize Log
log_create( &log, 1024 );
//Mutex operations
printf( "Starting mutex operations\n" );
hthread_mutexattr_init( &mutexAttr );
hthread_mutexattr_setnum( &mutexAttr, 0 );
hthread_mutexattr_getnum( &mutexAttr, &arg );
hthread_mutexattr_destroy( &mutexAttr );
hthread_mutex_init(&mutex, NULL);
hthread_mutex_lock( &mutex );
hthread_mutex_unlock( &mutex );
hthread_mutex_trylock( &mutex );
hthread_mutex_unlock( &mutex );
hthread_mutex_destroy( &mutex );
//Condition Variable operations
/*
printf( "Starting condition variable operations\n" );
hthread_condattr_init( &condvarAttr );
hthread_condattr_setnum( &condvarAttr, 0 );
hthread_condattr_getnum( &condvarAttr, &arg );
hthread_condattr_destroy( &condvarAttr );
hthread_cond_init( &condvar, NULL );
hthread_mutex_lock( &mutex );
hthread_cond_wait( &condvar, &mutex );
hthread_mutex_unlock( &mutex );
hthread_cond_signal( &condvar );
hthread_cond_broadcast( &condvar );
hthread_cond_destroy( &condvar );
*/
//Thread operations
printf( "Starting thread operations\n" );
hthread_attr_init( &threadAttr );
hthread_create( &thread, &threadAttr, foo, &log );
hthread_attr_destroy( &threadAttr );
hthread_join( thread, NULL );
printf( " -- End of Program --\n" );
log_close_ascii( &log );
return 0;
}
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;
}
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;
}
// Initialize all of the PR data
void init_PR_data() {
// Initialize the ICAP
hthread_mutexattr_t attr;
if (hthread_mutexattr_init(&attr)) {
printf("Error intializing mutex attribute\n");
while(1);
}
// Set MID to maximum ID allowed
if (hthread_mutexattr_setnum(&attr,(Huint) HT_SEM_MAXNUM)) {
printf("Error setting MID (%u) for mutex attribute\n", HT_SEM_MAXNUM);
while(1);
}
if(hthread_mutex_init(&icap_mutex, &attr)) {
printf("error initializing icap mutex\n");
while(1);
}
#ifdef ICAP
// Initialize the ICAP
if(XHwIcap_CfgInitialize(&HwIcap, (XHwIcap_Config *) 0x1, ICAP_BASEADDR)) {
printf("Error initializing the ICAP\n");
while(1);
}
// Initialize the pointers
// init CRC
crc_bit[0] = (unsigned char *) (&crc0_bit[0]);
crc_bit[1] = (unsigned char *) (&crc1_bit[0]);
crc_bit[2] = (unsigned char *) (&crc2_bit[0]);
crc_bit[3] = (unsigned char *) (&crc3_bit[0]);
crc_bit[4] = (unsigned char *) (&crc4_bit[0]);
crc_bit[5] = (unsigned char *) (&crc5_bit[0]);
// init sort
sort_bit[0] = (unsigned char *) (&sort0_bit[0]);
sort_bit[1] = (unsigned char *) (&sort1_bit[0]);
sort_bit[2] = (unsigned char *) (&sort2_bit[0]);
sort_bit[3] = (unsigned char *) (&sort3_bit[0]);
sort_bit[4] = (unsigned char *) (&sort4_bit[0]);
sort_bit[5] = (unsigned char *) (&sort5_bit[0]);
// init vector
vector_bit[0] = (unsigned char *) (&vector0_bit[0]);
vector_bit[1] = (unsigned char *) (&vector1_bit[0]);
vector_bit[2] = (unsigned char *) (&vector2_bit[0]);
vector_bit[3] = (unsigned char *) (&vector3_bit[0]);
vector_bit[4] = (unsigned char *) (&vector4_bit[0]);
vector_bit[5] = (unsigned char *) (&vector5_bit[0]);
// Create accelerate profiles - containers that hold
// pointers to each accelerator specific for each slave.
unsigned int i;
for (i = 0; i < NUM_AVAILABLE_HETERO_CPUS; i++) {
set_accelerator_structure((accelerator_list_t *) &accelerator_list[i], i);
// -------------------------------------------------------------- //
// Write extra parameters for PR functionality //
// -------------------------------------------------------------- //
_hwti_set_accelerator_ptr((Huint) hwti_array[i], (Huint)&accelerator_list[i]);
// Write the ICAP Mutex
_hwti_set_icap_mutex( (Huint) hwti_array[i], (Huint) &icap_mutex);
// Write the ICAP Data Strucutre
_hwti_set_icap_struct_ptr( (Huint) hwti_array[i], (Huint) &HwIcap);
// Write pointer for last_used_accelerator so slave can update the table
_hwti_set_last_accelerator_ptr( (Huint) hwti_array[i], (Huint) &slave_table[i].last_used_acc);
// Write pointer to tuning_table
_hwti_set_tuning_table_ptr((Huint) hwti_array[i], (Huint) &tuning_table);
}
#endif
// Reset thread create statistical data
no_free_slaves_num = 0;
possible_slaves_num = 0;
best_slaves_num = 0;
}
