lkfqSyncQ(lkfq_tc_t * pQ) { pthread_mutex_lock(&(pQ->tQAlloc.tLock)); lfds611_queue_use( pQ->tQAlloc.pRbQs ); pQ->tQAlloc.bInit = TRUE; pthread_mutex_unlock(&(pQ->tQAlloc.tLock)); pthread_mutex_lock(&(pQ->tQFree.tLock)); lfds611_queue_use( pQ->tQFree.pRbQs ); pQ->tQFree.bInit = TRUE; pthread_mutex_unlock(&(pQ->tQFree.tLock)); }
thread_return_t CALLING_CONVENTION queue_test_internal_thread_rapid_enqueuer_and_dequeuer( void *queue_test_rapid_enqueuing_and_dequeuing_state ) { struct queue_test_rapid_enqueuing_and_dequeuing_state *qtreds; time_t start_time; lfds611_atom_t user_data; assert( queue_test_rapid_enqueuing_and_dequeuing_state != NULL ); qtreds = (struct queue_test_rapid_enqueuing_and_dequeuing_state *) queue_test_rapid_enqueuing_and_dequeuing_state; lfds611_queue_use( qtreds->qs ); time( &start_time ); while( time(NULL) < start_time + 10 ) { lfds611_queue_enqueue( qtreds->qs, (void *) (qtreds->counter++) ); lfds611_queue_dequeue( qtreds->qs, (void *) &user_data ); } return( (thread_return_t) EXIT_SUCCESS ); }
thread_return_t CALLING_CONVENTION queue_test_internal_thread_simple_dequeuer( void *queue_test_dequeuing_state ) { struct queue_test_dequeuing_state *qtds; lfds611_atom_t *prev_user_data, *user_data; assert( queue_test_dequeuing_state != NULL ); qtds = (struct queue_test_dequeuing_state *) queue_test_dequeuing_state; lfds611_queue_use( qtds->qs ); lfds611_queue_dequeue( qtds->qs, (void *) &prev_user_data ); while( lfds611_queue_dequeue(qtds->qs, (void *) &user_data) ) { if( user_data <= prev_user_data ) qtds->error_flag = RAISED; prev_user_data = user_data; } return( (thread_return_t) EXIT_SUCCESS ); }
//------------------------------------------------------------------------------ void msc_start_use ( void) //------------------------------------------------------------------------------ { lfds611_queue_use (g_msc_message_queue_p); lfds611_stack_use (g_msc_memory_stack_p); }
thread_return_t CALLING_CONVENTION queue_test_internal_thread_simple_enqueuer( void *queue_test_enqueuing_state ) { struct queue_test_enqueuing_state *qtes; assert( queue_test_enqueuing_state != NULL ); qtes = (struct queue_test_enqueuing_state *) queue_test_enqueuing_state; lfds611_queue_use( qtes->qs ); // TRD : top byte of counter is already our thread number while( lfds611_queue_enqueue(qtes->qs, (void *) qtes->counter++) ); return( (thread_return_t) EXIT_SUCCESS ); }
thread_return_t CALLING_CONVENTION queue_test_internal_thread_enqueuer_and_dequeuer( void *queue_test_enqueuing_and_dequeuing_state ) { struct queue_test_enqueuing_and_dequeuing_state *qteds; time_t start_time; lfds611_atom_t thread, count, user_data; assert( queue_test_enqueuing_and_dequeuing_state != NULL ); qteds = (struct queue_test_enqueuing_and_dequeuing_state *) queue_test_enqueuing_and_dequeuing_state; lfds611_queue_use( qteds->qs ); time( &start_time ); while( time(NULL) < start_time + 10 ) { lfds611_queue_enqueue( qteds->qs, (void *) (qteds->counter++) ); lfds611_queue_dequeue( qteds->qs, (void *) &user_data ); thread = user_data >> (sizeof(lfds611_atom_t)*8-8); count = (user_data << 8) >> 8; if( thread >= qteds->cpu_count ) qteds->error_flag = RAISED; else { if( count < qteds->per_thread_counters[thread] ) qteds->error_flag = RAISED; if( count >= qteds->per_thread_counters[thread] ) qteds->per_thread_counters[thread] = count+1; } } return( (thread_return_t) EXIT_SUCCESS ); }