Exemplo n.º 1
0
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));
}
Exemplo n.º 2
0
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 );
}
Exemplo n.º 3
0
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 );
}
Exemplo n.º 4
0
//------------------------------------------------------------------------------
void
msc_start_use (
  void)
//------------------------------------------------------------------------------
{
  lfds611_queue_use (g_msc_message_queue_p);
  lfds611_stack_use (g_msc_memory_stack_p);
}
Exemplo n.º 5
0
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 );
}
Exemplo n.º 6
0
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 );
}