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; }
void* findFibonacci(void * arg) { hthread_attr_t attrBase; hthread_t threadBase; hthread_t threadOne; hthread_t threadTwo; struct fibonacci * fib; struct fibonacci fibOne; struct fibonacci fibTwo; fib = (struct fibonacci *) arg; if (fib->fibNum == 0 || fib->fibNum == 1) { //Set up the attr for a HW thread hthread_attr_init( &attrBase ); hthread_attr_sethardware( &attrBase, HWTI_BASEADDR ); //since there is only one HWTI, perform a mutex lock on it. //then create the HW thread hthread_mutex_lock( &hwtiMutex ); //hthread_create(&threadBase, NULL, findFibHWTI, (void*)fib); //readHWTStatus(); //resetHWT(); //printf( "fibVal is %d\n", fib->fibVal ); printf( "fib address is %x, %x, %x\n", (Huint)fib, (Huint)(&fib->fibNum), (Huint)(&fib->fibVal) ); hthread_create(&threadBase, &attrBase, NULL, arg); //Clean up the attr hthread_attr_destroy( &attrBase ); //Wait for HW thread to finish ... and unlock mutex hthread_join(threadBase, NULL); //readHWTStatus(); printf( "fibVal is %d\n", fib->fibVal ); hthread_mutex_unlock( &hwtiMutex ); } else { fibOne.fibNum = fib->fibNum - 1; fibTwo.fibNum = fib->fibNum - 2; hthread_create(&threadOne, NULL, findFibonacci, (void*)&fibOne); hthread_create(&threadTwo, NULL, findFibonacci, (void*)&fibTwo); hthread_join(threadOne, NULL); hthread_join(threadTwo, NULL); fib->fibVal = fibOne.fibVal + fibTwo.fibVal; } return NULL; }
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() { hthread_t test_thread; hthread_mutexattr_t attr; hthread_mutex_t mutex; struct test_data data; int arg, retVal; //Print the name of the test to the screen printf( "Starting test mutexattr_init_1\n" ); //Set up the arguments for the test data.attr = &attr; data.mutex = &mutex; arg = (int) &data; //Run the tests hthread_create( &test_thread, NULL, testThread, (void *) arg ); hthread_join( test_thread, (void *) &retVal ); //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() { 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_init_3\n" ); //Set up the arguments for the test 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[] ) { Huint sta; void* retval; hthread_t tid; hthread_attr_t attr; int num_ops = 0; printf( "\n****Main Thread****... \n" ); for( num_ops = 0; num_ops < 5; num_ops++) { // Initialize the attributes for the hardware thread hthread_attr_init( &attr ); hthread_attr_sethardware( &attr, HWTI_BASEADDR ); // Create the hardware thread printf( "Starting Hardware Thread... \r" ); sta = hthread_create( &tid, &attr, NULL, (void*)(num_ops) ); printf( "Started Hardware Thread (TID = %d) (ARG = %d)... 0x%8.8x\n", tid, num_ops, sta ); // Clean up the attribute structure hthread_attr_destroy( &attr ); // Wait for the hardware thread to exit printf( "Waiting for Hardware Thread... \r" ); hthread_join( tid, &retval ); printf( "Joined on Hardware Thread... 0x%8.8x\n", (Huint)retval ); } // Return from main return 0; }
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; }
int main( int argc, char *argv[] ) { hthread_t prod_tid; hthread_t sort_tid; hthread_t cons_tid; prod_struct prod; sort_struct sort; cons_struct cons; // Setup the structures for the threads DEBUG_PRINTF( "Setting up Structures\n" ); setup_structs( &prod, &sort, &cons ); // Create the producing thread DEBUG_PRINTF( "Creating Producer\n" ); hthread_create( &prod_tid, NULL, prod_thread, (void*)&prod ); // Create the sorting thread DEBUG_PRINTF( "Creating Sorter\n" ); hthread_create( &sort_tid, NULL, sort_thread, (void*)&sort ); // Create the consuming thread DEBUG_PRINTF( "Creating Consumer\n" ); hthread_create( &cons_tid, NULL, cons_thread, (void*)&cons ); // Send the start signal to the producer DEBUG_PRINTF( "Starting Producer\n" ); start_producer( &prod, &sort, &cons ); // Wait for the sorting thread to finish hthread_join( prod_tid, NULL ); // Wait for the sorting thread to finish hthread_join( sort_tid, NULL ); // Wait for the sorting thread to finish hthread_join( cons_tid, NULL ); // Clean up the structures DEBUG_PRINTF( "Cleaning Structures\n" ); destroy_structs( &prod, &sort, &cons ); // Exit the program return 0; }
Hint thread_create(hthread_t *t, hthread_attr_t *a, hthread_start_t s, void *g) { Hint status; status = hthread_create( t, a, s, g ); if( status != SUCCESS ) DEBUG_PRINTF( "CREATE ERROR: 0x%8.8x\n", status ); return status; }
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 thread_pool_init(struct threadpool * tp, int num_threads) { int iterator; for (iterator = 0; iterator < num_threads; iterator++) { tp->thr_id[iterator] = iterator; hthread_create(&(tp->p_threads[iterator]), NULL, handle_requests_loop, (void *) tp); } return 0; }
void * testThread ( void * arg ) { int retVal; struct test_data * data = (struct test_data *) arg; hthread_create( &data->thread, NULL, data->function, NULL ); retVal = hthread_join( data->thread, NULL ); hthread_exit( (void *) retVal ); return NULL; }
int main( int argc, char *argv[] ) { Huint sta; void* retval; hthread_t tid; hthread_attr_t attr; int num_ops = 0; printf( "\n****Main Thread****... \n" ); XCache_DisableDCache(); // ************************************************************************************* unsigned int *fcn_pointer = (unsigned int*)(HWTI_BASEADDR + 6*sizeof(int)); int code_offset = 0; FuncPointer fp = 0; unsigned char * prog_ptr = 0; unsigned int * first_instr = 0; // Initialize code offset and program pointer code_offset = 0x1f0; //0x1d4;//0x1a8; prog_ptr = (unsigned char *)&junk_o; // Initialize function pointer (actual place to jump to) fp = (FuncPointer)(prog_ptr + code_offset); // Initialize a pointer that allows one to "look" at the 1st instruction first_instr = (unsigned int*)(prog_ptr + code_offset); *fcn_pointer = (int)fp; // ************************************************************************************* for( num_ops = 0; num_ops < 5; num_ops++) { // Initialize the attributes for the hardware thread hthread_attr_init( &attr ); hthread_attr_sethardware( &attr, HWTI_BASEADDR ); // Create the hardware thread printf( "Starting Hardware Thread... \r" ); sta = hthread_create( &tid, &attr, (void*)fp, (void*)(num_ops) ); printf( "Started Hardware Thread (TID = %d) (ARG = %d)... 0x%8.8x\n", tid, num_ops, sta ); // Clean up the attribute structure hthread_attr_destroy( &attr ); // Wait for the hardware thread to exit printf( "Waiting for Hardware Thread... \r" ); hthread_join( tid, &retval ); printf( "Joined on Hardware Thread... 0x%8.8x\n", (Huint)retval ); } // Return from main return 0; }
void * testThread ( void * arg ) { int retVal; struct testdata * data = (struct testdata *) arg; hthread_create( &data->thread, data->attr, data->function, NULL ); hthread_attr_setdetachstate( data->attr, HTHREAD_CREATE_DETACHED ); retVal = hthread_join( data->thread, NULL ); hthread_exit( (void *) retVal ); return NULL; }
int main (int argc, char *argv[]) { unsigned int start = 0; unsigned int stop = 0; hthread_t thread; struct simple_test simple; Huint i, j, ret; for(j = 0; j < ITERATIONS; j++) { #ifdef PRINT printf("\nStarting Simple Test...\n"); #endif simple.val = 110; // Xilinx OPB Timer locations as specified in the .mhs file volatile int *timer_control = (int*)0x73000000; volatile int *timer_value = (int*)0x73000008; // Enable timer and clear interrupt *timer_control = 0x00000510; // Start the timer start = *timer_value; for(i = 0; i < j+1; i++) { hthread_create(&thread, NULL, simple_thread, (void*)&simple); hthread_join(thread, (void*)&ret); #ifdef PRINT printf( "main: CPUID = %d\n",_get_procid()); printf( "main: Val = %d\n", simple.val ); printf( "..................................\n"); #endif } // Stop timer stop = *timer_value; printf("Exec. Time = %d Iteration = %d\n",(stop-start),j); #ifdef PRINT printf("Start Time = %u\n",start); printf("Stop Time = %u\n",stop); printf("Exec. Time = %d\n",(stop-start)); printf( "main: Val = %d\n", simple.val ); printf( "- done -\n\n" ); #endif } return 0; }
// The daemon_init function provides an interface to the main thread // to start the daemon. It should only be called once and will run // in the main thread. void daemon_init(DaemonComm *dc) { // Initialize the Daemon Communication Struct. // This struct is used to pass information from the // main thread to the daemon thread. UNSET(dc->new_code); UNSET(dc->in_hw); dc->new_code_address = NULL; dc->new_code_size = 0; // Create the daemon thread. hthread_create(&dc->tid, NULL, daemon_thread, (void *)dc); }
void * testThread ( void * arg ) { int retVal; struct test_data * data = (struct test_data *) arg; hthread_create( &data->thread, NULL, data->function, NULL ); hthread_join( data->thread, NULL ); //If the thread exited, and we can join on it, its a success retVal = SUCCESS; hthread_exit( (void *) retVal ); return NULL; }
Hint create_producer( buffer_t *buffer, hthread_t *tid ) { Hint sta; // Attempt to create the thread sta = hthread_create( tid, NULL, producer, (void*)buffer ); // Check that the creation was successful if( sta != 0 ) DEBUG_PRINTF( "ERROR: (OP=CREATE) (STA=0x%8.8x)\n", sta ); // Return the status back to the user return sta; }
void * testThread ( void * arg ) { int retVal; struct test_data * data = (struct test_data *) arg; hthread_mutex_lock( data->mutex ); hthread_create( &data->thread, NULL, data->function, (void *) data ); retVal = hthread_cond_wait( data->cond, data->mutex ); hthread_mutex_unlock( data->mutex ); hthread_join( data->thread, NULL ); hthread_exit( (void *) retVal ); return NULL; }
hthread_t create_worker( argument *arg ) { hthread_t tid; Huint status; status = hthread_create( &tid, NULL, thread_worker, (void*)arg ); if( status != 0 ) { printf( "Create Error: (STA=%u) (TID=%u)\n",status,tid ); while(1); } return tid; }
/*-------------------------------------------------------------------*/ DLL_EXPORT int hthread_create_thread( TID* ptid, ATTR* pat, THREAD_FUNC* pfn, void* arg, const char* name, const char* location ) { int rc; void** arg2; UNREFERENCED( name ); /* unref'ed on non-Windows */ pttthread = 1; /* Set a mark on the wall */ arg2 = malloc( 2 * sizeof( void* )); *(arg2+0) = (void*) pfn; *(arg2+1) = (void*) arg; rc = hthread_create( ptid, pat, hthread_func, arg2, name ); PTTRACE( "create", (void*)*ptid, NULL, location, rc ); return rc; }
int main( int argc, char *argv[] ) { hthread_t tid1; hthread_attr_t attr1; struct command commands; Huint i; log_t log; // Create the log file for timing reports log_create( &log, 1024 ); // Initialize the attributes for the threads hthread_attr_init( &attr1 ); // Setup the attributes for the hardware threads hthread_attr_sethardware( &attr1, HWT_ZERO_BASEADDR ); // Initialize matrixData commands.count = 060; commands.value = 1012; commands.operation = 6; //commands.ptrData = (int *) malloc( sizeof( int ) * commands.count ); commands.ptrData = (int *) 0x63000050; // Create the hardware thread log_time( &log ); hthread_create( &tid1, &attr1, NULL, (void*)(&commands) ); // Wait for the threads to exit hthread_join( tid1, NULL ); log_time( &log ); readHWTStatus( HWT_ZERO_BASEADDR ); for( i = 0; i < commands.count; i+=16 ) { printf( "%i=%i\n", i, commands.ptrData[i] ); } // Clean up the attribute structure hthread_attr_destroy( &attr1 ); printf( "log dump\n" ); log_close_ascii( &log ); printf( "-- QED --\n" ); // Return from main return 1; }
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; } }
//------------------------------------------// // Software_Create // // Description: Function used to create // // software threads only. Used if creating // // a hardware thread fails. // //------------------------------------------// Huint software_create ( hthread_t * tid, hthread_attr_t * attr, Huint func_id, void * arg) { void * func; // --------------------------------------------- // Make sure tables are setup // --------------------------------------------- if (!table_initialized_flag) { // Assert flag table_initialized_flag = 1; // Init thread table init_thread_table(&global_thread_table); // Load entries with app-specific data load_my_table(); // Init function-to-accelerator table init_func_2_acc_table(); #ifdef ICAP // Initialize mutexes, ICAP, and bitfiles // for Partial Reconfiguration. init_PR_data(); #endif } #ifdef DEBUG_DISPATCH printf("Software thread\n"); #endif // Create a native/software thread on the host processor func = lookup_handle(&global_thread_table, func_id, TYPE_HOST); // Increment thread counter thread_counter++; return (hthread_create(tid, attr, func, arg)); }
void * testThread ( void * arg ) { int retVal, i; struct testdata * data = (struct testdata *) arg; for( i=0; i<THREAD_NUM; i++ ) hthread_create( &data->thread[i], NULL, data->function, (void *) data ); while( *(data->start_num) != THREAD_NUM ) hthread_yield(); hthread_mutex_lock( data->mutex ); hthread_cond_broadcast( data->cond ); hthread_mutex_unlock( data->mutex ); for( i=0; i<THREAD_NUM; i++ ) hthread_join( data->thread[i], NULL ); retVal = *(data->waken_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 ; }
hthread_t create_new_thread(uint ctr, Hbool detached) { Huint status; hthread_t thread_id; hthread_attr_t attrs; // Setup the attributes for the main thread attrs.detached = detached; attrs.stack_size = HT_STACK_SIZE; status = hthread_create( &thread_id, &attrs, simpleThread, (void*) ctr); if( status != 0 ) { // UNrecoverable error. printf( "Create Error: %u, for %s thread (CTR = %u)\n", status, ((detached == Htrue)? "detached" : "joinable"), ctr); while(1); } return thread_id; }
int main() { hthread_t test_thread; int arg, retVal; //Print the name of the test to the screen printf( "Starting test yield_1\n" ); //Set up the arguments for the test arg = (int) NULL; //Run the tests hthread_create( &test_thread, NULL, testThread, (void *) arg ); hthread_join( test_thread, (void *) &retVal ); //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() { unsigned int i = 0; int retVal; // Allocate NUM_THREADS threads hthread_t * tid = (hthread_t *) malloc(sizeof(hthread_t) * NUM_THREADS); hthread_attr_t * attr = (hthread_attr_t *) malloc(sizeof(hthread_attr_t) * NUM_AVAILABLE_HETERO_CPUS); assert(tid); assert(attr); // Set up attributes for a hardware thread for (i = 0; i < NUM_AVAILABLE_HETERO_CPUS; i++) { hthread_attr_init(&attr[i]); hthread_attr_setdetachstate( &attr[i], HTHREAD_CREATE_JOINABLE); } unsigned int failed = 0; // Create hardware threads first for (i = 0; i < NUM_AVAILABLE_HETERO_CPUS; i++) { // Create thread -- Assuming that thread manager will give us // a TID = 2 every time since we are creating & joining 1 thread // at a time. if (microblaze_create( &tid[i], &attr[i], foo_thread_FUNC_ID, (void *) 2, i) ) { failed = 1; PRINT_ERROR(THREAD_HARDWARE_CREATE_FAILED); } if (hthread_join( tid[i], (void *) &retVal ) ) { failed = 1; PRINT_ERROR(THREAD_HARDWARE_JOIN_FAILED); } // Make sure the return value is equal to base_array[i] if (base_array[i] != ((unsigned int) retVal - HT_CMD_HWTI_COMMAND)) { failed = 1; PRINT_ERROR(THREAD_HARDWARE_INCORRECT_RETURN); } } // Create all threads as software threads for (i = 0; i < NUM_THREADS; i++) { // Create threads if (hthread_create( &tid[i], NULL, foo_thread, (void *) 2 )) { failed = 1; PRINT_ERROR(THREAD_SOFTWARE_CREATE_FAILED); } } // Now join on all software threads we just created for (i = 0; i < NUM_THREADS; i++) { // Join on thread if (hthread_join(tid[i], (void *) &retVal )) { failed = 1; PRINT_ERROR(THREAD_SOFTWARE_JOIN_FAILED); } } // Create NUM_THREADS threads // ----> Create hardware threads first for (i = 0; i < NUM_AVAILABLE_HETERO_CPUS; i++) { // Create threads if (microblaze_create( &tid[i], &attr[i], foo2_thread_FUNC_ID, (void *) i, i) ) { failed = 1; PRINT_ERROR(THREAD_HARDWARE_CREATE_FAILED); } } // ----> The remaining are software threads for (i = NUM_AVAILABLE_HETERO_CPUS; i < NUM_THREADS; i++) { // Create threads if (hthread_create( &tid[i], NULL, foo2_thread, (void *) i )) { failed = 1; PRINT_ERROR(THREAD_SOFTWARE_CREATE_FAILED); } } // Try to create more here --SHOULD FAIL!!! for (i = 0; i < NUM_THREADS; i++) { // If it does not fail if (hthread_create( &tid[i], NULL, foo2_thread, (void *) i ) == SUCCESS ) { failed = 1; PRINT_ERROR(THREAD_SOFTWARE_ERROR_FAILED); } } // Clean up- Join on the threads. for (i = 0; i < NUM_THREADS; i++) { // If it fails if (hthread_join(tid[i], (void *) &retVal )) { failed = 1; PRINT_ERROR(FINAL_JOIN_ERROR); } } // Test dynamic_create_smart #ifdef SPLIT_BRAM // Test microblaze_create_DMA and dyanmic_create_smart_DMA #endif if (failed) { PRINT_ERROR(TEST_FAILED); } else PRINT_ERROR(TEST_PASSED); free(tid); free(attr); return TEST_PASSED; }