/*-------------------------------------------------------------------*/
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;
}
}
void run_B (int use_hw, int num_load_threads, thread_arg_t * arg)
{
unsigned int i=0;
hthread_t measure_tidA, measure_tidB;
hthread_t tids[num_load_threads];
hthread_mutexattr_t block_attr;
hthread_mutexattr_t data_attr;
// Print banner
show_banner(num_load_threads);
// Initialize thread argument fields
// * Setup mutexes
// * Initialize counter
block_attr.num = 0;
block_attr.type = HTHREAD_MUTEX_DEFAULT;
data_attr.num = 1;
data_attr.type = HTHREAD_MUTEX_DEFAULT;
hthread_mutex_init(&arg->block_mutex, &block_attr);
hthread_mutex_init(&arg->data_mutex, &data_attr);
arg->counter = 0;
// Create measurement thread A
hthread_create(&measure_tidA, NULL, measureThread, (void*)arg);
// Create measurement thread B
hthread_create(&measure_tidB, NULL, testThreadWithMeasurement, (void*)arg);
// Create all of the load threads
dbg_printf("Creating load threads...\n");
for (i = 0; i < num_load_threads; i++)
{
// Create load thread
hthread_create(&tids[i], NULL, testThread, (void*)arg);
}
// Make sure that measurement thread A runs
hthread_join(measure_tidA,NULL);
// Make sure that measurement thread B runs
hthread_join(measure_tidB,NULL);
// Wait for all load threads to complete
for (i = 0; i < num_load_threads; i++)
{
// Join on load thread
hthread_join(tids[i],NULL);
}
// Extract turn-around results
// Turn-around = unlock_start to measure_lock_stop
arg->measure_lock_check = calc_timediff_us(arg->unlock_start, arg->measure_lock_stop);
return;
}
argument* create_args(void)
{
argument *arg;
hthread_condattr_t *attr1;
hthread_condattr_t *attr2;
attr1 = (hthread_condattr_t*)malloc(sizeof(hthread_condattr_t));
attr2 = (hthread_condattr_t*)malloc(sizeof(hthread_condattr_t));
arg = (argument*)malloc( sizeof(argument) );
arg->cond_notempty = (hthread_cond_t*)malloc( sizeof(hthread_cond_t) );
arg->cond_notfull = (hthread_cond_t*)malloc( sizeof(hthread_cond_t) );
arg->mutex = (hthread_mutex_t*)malloc( sizeof(hthread_mutex_t) );
hthread_condattr_init( attr1 );
hthread_condattr_init( attr2 );
hthread_condattr_setnum( attr1, 0 );
hthread_condattr_setnum( attr2, 1 );
hthread_cond_init( arg->cond_notempty, attr1 );
hthread_cond_init( arg->cond_notfull, attr2 );
hthread_mutex_init( arg->mutex, NULL );
hthread_condattr_destroy( attr1 );
hthread_condattr_destroy( attr2 );
free( attr1 );
free( attr2 );
arg->jobs = 0;
return arg;
}
int main() {
hthread_t test_thread;
hthread_attr_t test_attr;
hthread_mutex_t mutex;
int arg, retVal;
//Print the name of the test to the screen
printf( "Starting test mutex_trylock_2\n" );
//Set up the arguments for the test
hthread_mutex_init( &mutex, NULL );
arg = (int) &mutex;
//Initialize RPC
rpc_setup();
//Run the tests
hthread_attr_init( &test_attr );
if ( HARDWARE ) hthread_attr_sethardware( &test_attr, HWTI_ONE_BASEADDR );
hthread_create( &test_thread, &test_attr, testThread, (void *) arg );
hthread_join( test_thread, (void *) &retVal );
if ( HARDWARE ) readHWTStatus( HWTI_ONE_BASEADDR );
//Evaluate the results
if ( retVal == EXPECTED_RESULT ) {
printf("Test PASSED\n");
return PTS_PASS;
} else {
printf("Test FAILED [expecting %d, received %d]\n", EXPECTED_RESULT, retVal );
return PTS_FAIL;
}
}
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;
}
void * testThread ( void * arg ) {
int retVal;
hthread_mutex_t * mutex = (hthread_mutex_t *) arg;
hthread_mutex_init( mutex, NULL );
retVal = hthread_mutex_destroy( mutex );
hthread_exit( (void *) retVal );
return NULL;
}
void * testThread ( void * arg ) {
int retVal;
hthread_mutex_t * mutex = (hthread_mutex_t *) arg;
//Test that the initialized mutex is not locked
hthread_mutex_init( mutex, NULL );
retVal = _mutex_owner( mutex->num );
hthread_exit( (void *) retVal );
return NULL;
}
int main (int argc, char *argv[]) {
hthread_t thread; //I came up with this name myself
struct fibonacci fib;
// log_t log;
Huint fibArray[FIBMAX];
// Huint *fibArray;
Huint i;
hthread_mutex_init( &hwtiMutex, NULL );
hthread_mutex_init( &mutex2, NULL );
hthread_mutex_init( &mutex3, NULL );
hthread_mutex_init( &mutex4, NULL );
printf( "Mutex number is %d\n", hwtiMutex.num );
printf( "Mutex number is %d\n", mutex2.num );
printf( "Mutex number is %d\n", mutex3.num );
printf( "Mutex number is %d\n", mutex4.num );
// log_create( &log, 1024 );
// log_time( &log );
// fibArray = malloc( FIBMAX * sizeof ( Huint ) );
for( i=0; i<FIBMAX; i++ ) {
fib.fibNum = i;
printf( "Creating Thread for Fibonacci %d\n", i );
hthread_create(&thread, NULL, findFibonacci, (void*)&fib);
hthread_join(thread, NULL);
fibArray[i] = fib.fibVal;
}
// log_time( &log );
for( i=0; i<FIBMAX; i++ ) {
printf( "Fibonacci %d is %d\n", i, fibArray[i] );
}
// log_close_ascii( &log );
// printf( "\nReview the log file to determine the total time\n" );
printf( " - done -\n\n" );
return 1 ;
}
/*-------------------------------------------------------------------*/
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);
}
void setup_structs( prod_struct *prod, sort_struct *sort, cons_struct *cons )
{
int *data;
int *ready_prod;
int *ready_sort;
int *ready_cons;
hthread_mutex_t *mutex;
hthread_cond_t *start_prod;
hthread_cond_t *start_sort;
hthread_cond_t *start_cons;
data = (int*)malloc( SIZE * sizeof(int) );
mutex = (hthread_mutex_t*)malloc( sizeof(hthread_mutex_t) );
ready_prod = (int*)malloc( sizeof(int) );
ready_sort = (int*)malloc( sizeof(int) );
ready_cons = (int*)malloc( sizeof(int) );
start_prod = (hthread_cond_t*)malloc( sizeof(hthread_cond_t) );
start_sort = (hthread_cond_t*)malloc( sizeof(hthread_cond_t) );
start_cons = (hthread_cond_t*)malloc( sizeof(hthread_cond_t) );
hthread_mutex_init( mutex, NULL );
hthread_cond_init( start_prod, NULL );
hthread_cond_init( start_sort, NULL );
hthread_cond_init( start_cons, NULL );
prod->mutex = mutex;
prod->start = start_prod;
prod->finish = start_sort;
prod->data = data;
prod->size = SIZE;
prod->min = MIN;
prod->max = MAX;
prod->ready = ready_prod;
prod->done = ready_sort;
sort->mutex = mutex;
sort->start = start_sort;
sort->finish = start_cons;
sort->data = data;
sort->size = SIZE;
sort->ready = ready_sort;
sort->done = ready_cons;
cons->mutex = mutex;
cons->start = start_cons;
cons->finish = start_prod;
cons->data = data;
cons->size = SIZE;
cons->ready = ready_cons;
cons->done = ready_prod;
}
/*-------------------------------------------------------------------*/
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, sw1, sw2;
hthread_attr_t hw1Attr, sw1Attr, sw2Attr;
hthread_mutex_t mutex;
Huint retval;
struct arguments myArgs;
hthread_attr_init( &hw1Attr );
hthread_attr_init( &sw1Attr );
hthread_attr_init( &sw2Attr );
hthread_attr_sethardware( &hw1Attr, HWTI_BASEADDR );
hthread_mutex_init( &mutex, NULL );
myArgs.mutex = &mutex;
retval = hthread_mutex_lock( myArgs.mutex );
// Set the thread's argument data to some value
myArgs.value = 1000;
// Create two software threads
hthread_create( &tid, &hw1Attr, NULL, (void*)(&myArgs) );
hthread_create( &sw1, &sw1Attr, thread, (void*)(&myArgs) );
hthread_create( &sw2, &sw2Attr, thread, (void*)(&myArgs) );
hthread_yield();
// HWT should be blocked
readHWTStatus();
retval = hthread_mutex_unlock( myArgs.mutex );
hthread_join( tid, (void*)(&retval) );
hthread_join( sw1, (void*)(&retval) );
hthread_join( sw2, (void*)(&retval) );
readHWTStatus();
// Clean up the attribute structure
hthread_attr_destroy( &hw1Attr );
hthread_attr_destroy( &sw1Attr );
hthread_attr_destroy( &sw2Attr );
// Print out value of arg, and a successful exit message
printf( "After joins arg = %d\n", myArgs.value);
printf( "-- QED --\n" );
// Return from main
return 1;
}
void * testThread ( void * arg ) {
int retVal;
struct test_data * data = (struct test_data *) arg;
//Initialize a mutexattr, then a mutex with the attr
hthread_mutexattr_init( data->attr );
hthread_mutex_init( data->mutex, data->attr );
//Change the attr
data->attr->num = 1;
//Get the num of the mutex, it should not have changed
retVal = hthread_mutex_getnum( data->mutex );
hthread_exit( (void *) retVal );
return NULL;
}
int main() {
hthread_t test_thread;
hthread_attr_t test_attr;
int arg, retVal, start_num, waken_num;
struct testdata data;
hthread_mutex_t mutex;
hthread_cond_t cond;
//Print the name of the test to the screen
printf( "Starting test cond_broadcast_1\n" );
//Set up the arguments for the test
hthread_cond_init( &cond, NULL );
hthread_mutex_init( &mutex, NULL );
start_num = 0;
waken_num = 0;
data.mutex = &mutex;
data.cond = &cond;
data.start_num = &start_num;
data.waken_num = &waken_num;
data.function = a_thread_function;
arg = (int) &data;
//Initialize RPC
rpc_setup();
//Run the tests
hthread_attr_init( &test_attr );
if ( HARDWARE ) hthread_attr_sethardware( &test_attr, HWTI_ONE_BASEADDR );
hthread_create( &test_thread, &test_attr, testThread, (void *) arg );
hthread_join( test_thread, (void *) &retVal );
if ( HARDWARE ) readHWTStatus( HWTI_ONE_BASEADDR );
//Evaluate the results
if ( retVal == EXPECTED_RESULT ) {
printf("Test PASSED\n");
return PTS_PASS;
} else {
printf("Test FAILED [expecting %d, received %d]\n", EXPECTED_RESULT, retVal );
return PTS_FAIL;
}
}
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( int argc, char *argv[] )
{
unsigned int start, stop;
int i = 0;
int test = 0;
int NUM_LOAD_THREADS = 0;
thread_arg_t arg;
hthread_mutexattr_t block_attr;
hthread_mutexattr_t data_attr;
benchmark_t my_benchmark[TESTS];
// Turn on the Xilinx Timer
enableTimer();
for (test = 0; test < TESTS; test++)
{
// Set the # of load threads
NUM_LOAD_THREADS = test * 10;
// Init. benchmark structure
my_benchmark[test].num_threads_in_test = NUM_LOAD_THREADS;
*my_benchmark[test].name = "lock/unlock";
for (i = 0; i < RUNS; i++)
{
// Initialize thread argument fields
// * Setup mutexes
// * Initialize counter
block_attr.num = 0;
block_attr.type = HTHREAD_MUTEX_DEFAULT;
data_attr.num = 1;
data_attr.type = HTHREAD_MUTEX_DEFAULT;
hthread_mutex_init(&arg.block_mutex, &block_attr);
hthread_mutex_init(&arg.data_mutex, &data_attr);
arg.counter = 0;
arg.num_load_threads = NUM_LOAD_THREADS;
// Run the test
start = readTimer();
run_A(0,NUM_LOAD_THREADS,&arg);
stop = readTimer();
// Gather results
my_benchmark[test].results1[i] = calc_timediff(arg.lock_start, arg.lock_stop);
my_benchmark[test].results2[i] = calc_timediff(arg.unlock_start, arg.unlock_stop);
/*
printf(
"*** start = %u\n"
"*** stop = %u\n"
"*** elapsed = %u\n",
start, stop, stop - start
);
// Calculate timing results
printf( "\t*********************************\n"
"\t lock Start Time = %llu ticks\n"
"\t lock Stop Time = %llu ticks\n"
"\t diff = %llu ticks\n"
"\t lock Elapsed Time = %llu us\n",
arg.lock_start, arg.lock_stop, arg.lock_stop - arg.lock_start, calc_timediff_us(arg.lock_start, arg.lock_stop)
);
printf( "\t*********************************\n"
"\t unlock Start Time = %llu ticks\n"
"\t unlock Stop Time = %llu ticks\n"
"\t diff = %llu ticks\n"
"\t unlock Elapsed Time = %llu us\n",
arg.unlock_start, arg.unlock_stop, arg.unlock_stop - arg.unlock_start, calc_timediff_us(arg.unlock_start, arg.unlock_stop)
); */
}
}
report_benchmark_results(my_benchmark);
for (test = 0; test < TESTS; test++)
{
// Set the # of load threads
NUM_LOAD_THREADS = test * 10;
// Init. benchmark structure
my_benchmark[test].num_threads_in_test = NUM_LOAD_THREADS;
*my_benchmark[test].name = "turn_around";
for (i = 0; i < RUNS; i++)
{
// Initialize thread argument fields
// * Setup mutexes
// * Initialize counter
block_attr.num = 0;
block_attr.type = HTHREAD_MUTEX_DEFAULT;
data_attr.num = 1;
data_attr.type = HTHREAD_MUTEX_DEFAULT;
hthread_mutex_init(&arg.block_mutex, &block_attr);
hthread_mutex_init(&arg.data_mutex, &data_attr);
arg.counter = 0;
// Num loads threads + 1 b/c the 2nd measurement thread is a load thread and needs to increment the counter barrier
// before the main thread releases the blocking mutex
arg.num_load_threads = NUM_LOAD_THREADS+1;
// Run the test
start = readTimer();
run_B(0,NUM_LOAD_THREADS,&arg);
stop = readTimer();
// Gather results
my_benchmark[test].results1[i] = calc_timediff(arg.unlock_start, arg.measure_lock_stop);
my_benchmark[test].results2[i] = calc_timediff(arg.unlock_start, arg.measure_lock_stop);
/*
printf(
"*** start = %u\n"
"*** stop = %u\n"
"*** elapsed = %u\n",
start, stop, stop - start
);
// Calculate timing results
printf( "\t*********************************\n"
"\t lock Start Time = %llu ticks\n"
"\t lock Stop Time = %llu ticks\n"
"\t diff = %llu ticks\n"
"\t lock Elapsed Time = %llu us\n",
arg.lock_start, arg.lock_stop, arg.lock_stop - arg.lock_start, calc_timediff_us(arg.lock_start, arg.lock_stop)
);
printf( "\t*********************************\n"
"\t unlock Start Time = %llu ticks\n"
"\t unlock Stop Time = %llu ticks\n"
"\t diff = %llu ticks\n"
"\t unlock Elapsed Time = %llu us\n"
"\t m_lock Start Time = %llu ticks\n"
"\t m_lock Stop Time = %llu ticks\n"
"\t turn around = %llu us\n",
arg.unlock_start, arg.unlock_stop, arg.unlock_stop - arg.unlock_start, calc_timediff_us(arg.unlock_start, arg.unlock_stop), arg.measure_lock_start, arg.measure_lock_stop, calc_timediff_us(arg.unlock_start, arg.measure_lock_stop)); */
}
}
report_benchmark_results(my_benchmark);
return 0;
}
/*-------------------------------------------------------------------*/
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;
}
// 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;
}
int main( int argc, char *argv[] )
{
if (NUM_THREADS > 2){
printf("CANNOT USE MORE THAN (2) HETEROGENEOUS THREADS!!!!\r\n");
return (-1);
}
// Timer variables
xps_timer_t timer;
int time_create, time_start, time_stop;
// Mutex
hthread_mutex_t * mutex = (hthread_mutex_t*)malloc( sizeof(hthread_mutex_t) );
hthread_mutex_init( mutex, NULL );
// Thread attribute structures
Huint sta[NUM_THREADS];
void* retval[NUM_THREADS];
hthread_t tid[NUM_THREADS];
hthread_attr_t attr[NUM_THREADS];
targ_t thread_arg[NUM_THREADS];
// Setup Cache
XCache_EnableICache(0xc0000801);
// Create timer
xps_timer_create(&timer, (int*)0x20400000);
// Start timer
xps_timer_start(&timer);
// *************************************************************************************
extern unsigned char intermediate[];
extern unsigned int blink_handle_offset;
unsigned int blink_handle = (blink_handle_offset) + (unsigned int)(&intermediate);
// *************************************************************************************
int j = 0;
printf("Code start address = 0x%08x\n", (unsigned int)&intermediate);
for (j = 0; j < NUM_THREADS; j++)
{
// Initialize the attributes for the threads
hthread_attr_init( &attr[j] );
hthread_attr_sethardware( &attr[j], (void*)base_array[j] );
}
int num_ops = 0;
for( num_ops = 0; num_ops < 1; num_ops = num_ops + 1)
{
printf("******* Round %d ********\n",num_ops);
#ifdef USE_MB_THREAD
printf("**** MB-based Threads ****\n");
#else
printf("**** PPC-based Threads ****\n");
#endif
// Initialize thread arguments
for ( j= 0; j < NUM_THREADS; j++)
{
thread_arg[j].arg = 1 << ((j + 1));
thread_arg[j].mutex = mutex;
}
time_create = xps_timer_read_counter(&timer);
// Create threads
for (j = 0; j < NUM_THREADS; j++)
{
// Create the blink thread
#ifdef USE_MB_THREAD
// Create MB Thread
sta[j] = hthread_create( &tid[j], &attr[j], (void*)blink_handle, (void*)(&thread_arg[j]) );
//printf( "Started MB Thread (TID = %d) \n", tid[j]);
#else
// Create SW Thread
sta[j] = hthread_create( &tid[j], NULL, blink_thread, (void*)(&thread_arg[j]) );
//printf( "Started SW Thread (TID = %d) \n", tid[j]);
#endif
}
// Allow created threads to begin running and start timer
time_start = xps_timer_read_counter(&timer);
printf("Waiting for threads...\n");
// Join on all threads
for (j = 0; j < NUM_THREADS; j++)
{
hthread_join( tid[j], &retval[j] );
}
// Grab stop time
time_stop = xps_timer_read_counter(&timer);
// Print out status
for (j = 0; j < NUM_THREADS; j++)
{
printf("TID[%d] = 0x%08x, status = 0x%08x, retval = 0x%08x\n",j,tid[j],sta[j],(unsigned int)retval[j]);
}
printf("*********************************\n");
printf("Create time = %u\n",time_create);
printf("Start time = %u\n",time_start);
printf("Stop time = %u\n",time_stop);
printf("*********************************\n");
printf("Creation time (|Start - Create|) = %u\n",time_start - time_create);
printf("Elapsed time (|Stop - Start|) = %u\n",time_stop - time_start);
}
hthread_mutex_destroy( mutex );
free( mutex );
// Clean up the attribute structures
for (j = 0; j < NUM_THREADS; j++)
{
hthread_attr_destroy( &attr[j] );
}
printf ("-- Complete --\n");
// Return from main
return 0;
}
int run_tests()
{
// Timer variables
xps_timer_t timer;
int time_create, time_start, time_unlock, time_stop;
// Mutex
hthread_mutex_t * mutex = (hthread_mutex_t*)malloc( sizeof(hthread_mutex_t) );
hthread_mutex_init( mutex, NULL );
float min;
// Thread attribute structures
Huint sta[NUM_THREADS];
void* retval[NUM_THREADS];
hthread_t tid[NUM_THREADS];
hthread_attr_t attr[NUM_THREADS];
targ_t thread_arg[NUM_THREADS];
// Setup Cache
XCache_DisableDCache();
XCache_EnableICache(0xc0000801);
// Create timer
xps_timer_create(&timer, (int*)0x20400000);
// Start timer
xps_timer_start(&timer);
// *************************************************************************************
extern unsigned char intermediate[];
extern unsigned int min_handle_offset;
unsigned int min_handle = (min_handle_offset) + (unsigned int)(&intermediate);
// *************************************************************************************
printf("Code start address = 0x%08x\n", (unsigned int)&intermediate);
int i = 0;
float main_array[ARRAY_LENGTH];
printf("Addr of array = 0x%08x\n",(unsigned int)&main_array[0]);
for (i = 0; i < ARRAY_LENGTH; i++)
{
main_array[i] = (i+2)*3.14f;
}
int num_items = ARRAY_LENGTH/NUM_THREADS;
int extra_items = ARRAY_LENGTH - (num_items*NUM_THREADS);
float * start_addr = &main_array[0];
for (i = 0; i < NUM_THREADS; i++)
{
// Initialize the attributes for the hardware threads
hthread_attr_init( &attr[i] );
hthread_attr_sethardware( &attr[i], (void*)base_array[i] );
// Initialize thread arguments
thread_arg[i].num_items = num_items;
thread_arg[i].data_ptr = start_addr;
thread_arg[i].min_mutex = mutex;
thread_arg[i].min = &min;
start_addr+=num_items;
}
// Add in extra items for the last thread if needed
thread_arg[i-1].num_items += extra_items;
int num_ops = 0;
for( num_ops = 0; num_ops < 2; num_ops = num_ops + 1)
{
printf("******* Round %d ********\n",num_ops);
#ifdef USE_MB_THREAD
printf("**** MB-based Threads ****\n");
#else
printf("**** PPC-based Threads ****\n");
#endif
min = 9999999;
// Lock mutex before hand so that timing will not include thread creation time
hthread_mutex_lock(mutex);
// Start timing thread create
time_create = xps_timer_read_counter(&timer);
for (i = 0; i < NUM_THREADS; i++)
{
// Create the worker threads
#ifdef USE_MB_THREAD
// Create MB Thread
sta[i] = hthread_create( &tid[i], &attr[i], (void*)(min_handle), (void*)(&thread_arg[i]) );
#else
// Create SW Thread
sta[i] = hthread_create( &tid[i], NULL, min_thread, (void*)(&thread_arg[i]) );
#endif
}
// Allow created threads to begin running and start timer
time_start = xps_timer_read_counter(&timer);
hthread_mutex_unlock(mutex);
time_unlock = xps_timer_read_counter(&timer);
// Wait for the threads to exit
//printf( "Waiting for thread(s) to complete... \n" );
for (i = 0; i < NUM_THREADS; i++)
{
hthread_join( tid[i], &retval[i] );
}
time_stop = xps_timer_read_counter(&timer);
// Display results
printf("Min = %f\n",min);
for (i = 0; i < NUM_THREADS; i++)
{
printf("TID = 0x%08x, status = 0x%08x, retval = 0x%08x\n",tid[i],sta[i],(Huint)retval[i]);
}
printf("*********************************\n");
printf("Create time = %u\n",time_create);
printf("Start time = %u\n",time_start);
printf("Unlock time = %u\n",time_unlock);
printf("Stop time = %u\n",time_stop);
printf("*********************************\n");
printf("Creation time (|Start - Create|) = %u\n",time_start - time_create);
printf("Unlock time (|Unlock - Start|) = %u\n",time_unlock - time_start);
printf("Elapsed time (|Stop - Start|) = %u\n",time_stop - time_start);
}
hthread_mutex_destroy( mutex );
free( mutex );
// Clean up the attribute structures
for (i = 0; i < NUM_THREADS; i++)
{
hthread_attr_destroy( &attr[i] );
}
printf ("-- Complete --\n");
// Return from main
return 0;
}
