Exemple #1
0
int main (int argc, char *argv[])
{
    pthread_t thread_id;
    engine_t *engine;
    int count = 0, calls = 0;
    int status;

    status = pthread_key_create (&engine_key, destructor);
    if (status != 0)
        dbg_printf("Create key \n");

    status = workq_init (&workq, 4, engine_routine);
    if (status != 0)
        dbg_printf ( "Init work queue \n");

    status = pthread_create (&thread_id, NULL, thread_routine, NULL);
    if (status != 0)
        dbg_printf ("Create thread\n");


    (void)thread_routine (NULL);

    status = pthread_join (thread_id, NULL);
    if (status != 0)
        dbg_printf ( "Join thread \n");


    status = workq_destroy (&workq); /*死等模式将无法退出*/
    if (status != 0)
        dbg_printf ("Destroy work queue \n");


    return 0;
}
Exemple #2
0
int main (int argc, char *argv[])
{
    pthread_t thread_id;
    engine_t *engine;
    int count = 0, calls = 0;
    int status;

    status = pthread_key_create (&engine_key, destructor);
    if (status != 0)
        err_abort (status, "Create key");
    status = workq_init (&workq, 4, engine_routine);
    if (status != 0)
        err_abort (status, "Init work queue");
    status = pthread_create (&thread_id, NULL, thread_routine, NULL);
    if (status != 0)
        err_abort (status, "Create thread");
    (void)thread_routine (NULL);
    status = pthread_join (thread_id, NULL);
    if (status != 0)
        err_abort (status, "Join thread");
    status = workq_destroy (&workq);
    if (status != 0)
        err_abort (status, "Destroy work queue");

    /*
     * By now, all of the engine_t structures have been placed
     * on the list (by the engine thread destructors), so we
     * can count and summarize them.
     */
    engine = engine_list_head;
    while (engine != NULL) {
        count++;
        calls += engine->calls;
        printf ("engine %d: %d calls\n", count, engine->calls);
        engine = engine->link;
    }
    printf ("%d engine threads processed %d calls\n",
        count, calls);
    return 0;
}
Exemple #3
0
int main(int argc, char** argv)
{
    pthread_t thread_id;
    engine_t* engine;
    int count = 0;
    int calls = 0;
    int status;

    status = pthread_key_create(&engine_key, destructor);
    assert(status == 0);

    status = workq_init(&workq, 4, engine_routine);
    assert(status == 0);

    status = pthread_create(&thread_id, NULL, thread_routine, NULL);
    assert(status == 0);

    (void)thread_routine(NULL);
    
    status = pthread_join(thread_id, NULL);
    assert(status == 0);

    status = workq_destroy(&workq);
    assert(status == 0);

    engine = engine_list_head;
    while (engine != NULL)
    {
        count++;
        calls += engine->calls;
        printf("engine %d: %d calls\n", count, engine->calls);
        engine = engine->link;
    }
    printf("%d engine threads processed %d calls\n", count, calls);

    return 0;
}
int main(int argc, char* argv[])
{
	int c;
	u_int8_t payload[10] = {0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4a};
	u_int8_t srcmac1[6] =  {0x10,0x11,0x12,0x13,0x14,0x15};
	u_int8_t srcmac2[6] =  {0x16,0x17,0x18,0x19,0x1a,0x1b}; 
	u_int8_t (*p)[6];
	p=&srcmac2;
	struct config* pointer_config = NULL;
	struct thread_input input;
	while((c=getopt(argc, argv, "c:")) != -1) {
		if(c == 'c') {
			pointer_config = load_config(optarg);
			if(pointer_config == NULL) {
				return 1;
			}
		}
	}
	input.device = pointer_config->device;
	input.interval = pointer_config->interval;
	input.count = pointer_config->count;
	input.srcmac_qty = 2;
	input.size = pointer_config->size;
	input.srcip = pointer_config->srcip;
	input.dstip = pointer_config->dstip;
	memcpy(input.dstmac, pointer_config->dstmac, 6*sizeof(u_int8_t));
	input.payload = (u_int8_t*)malloc(10*sizeof(u_int8_t));
	input.size = 10;
	input.srcmac = malloc(2*sizeof(u_int8_t*));
	input.srcmac[0] = malloc(6*sizeof(u_int8_t));
	input.srcmac[1] = malloc(6*sizeof(u_int8_t));
	memcpy(input.srcmac[0], srcmac1, 6*sizeof(u_int8_t));
	memcpy(input.srcmac[1], srcmac2, 6*sizeof(u_int8_t));
	thread_routine(&input);	
	return 0;
}
Exemple #5
0
//
//  benchmarking program
//
int main( int argc, char **argv )
{    
  //
  //  process command line
  //
  if( find_option( argc, argv, "-h" ) >= 0 )
    {
      printf( "Options:\n" );
      printf( "-h to see this help\n" );
      printf( "-n <int> to set the number of particles\n" );
      printf( "-p <int> to set the number of threads\n" );
      printf( "-o <filename> to specify the output file name\n" );
      return 0;
    }
    
  n = read_int( argc, argv, "-n", 1000 );
  n_threads = read_int( argc, argv, "-p", 2 );
  char *savename = read_string( argc, argv, "-o", "pthreads.txt" );
  
  //
  //  allocate resources
  //
  fsave = savename ? fopen( savename, "w" ) : NULL;

  particles = (particle_t*) malloc( n * sizeof(particle_t) );
  
  set_size( n );
  init_particles( n, particles );

  blks_num = max(2 * size / sqrt((MAX_PART_THREADS)*(3.14159)*cutoff*cutoff), 1);
  blks_size =  size / ((double) blks_num);
  subblks_num = max(2 * blks_size / sqrt((MAX_PART_SUBB)*(3.14159)*cutoff*cutoff), 1);
  subblks_size = blks_size / ((double) subblks_num);
  totblks_num = blks_num * subblks_num;
  part_int = n/( blks_num * blks_num ) + 1;

  printf("blks_num %d, blks_size %f, subblks_num %d, subblks_size %f, totblks_num %d \n", blks_num, blks_size, subblks_num, subblks_size, totblks_num);

  printf("size %f, totblks_num * subblks_size %f \n", size, totblks_num * subblks_size);

  //printf("n %d, part_int %d, blks_num %d, cutoff %f \n", n, part_int, blks_num, cutoff);
  
  bins = (particle_t **) malloc( MAX_PART_SUBB * totblks_num * totblks_num * sizeof(particle_t*));
  bin_part_num = (int *) malloc( totblks_num * totblks_num * sizeof(int));
  bin_mutexes = (pthread_mutex_t*) malloc( totblks_num * totblks_num * sizeof(pthread_mutex_t));
  memset(bin_part_num, 0, totblks_num * totblks_num * sizeof(int));
  

  pthread_attr_t attr;
  P( pthread_attr_init( &attr ) );
  P( pthread_barrier_init( &barrier, NULL, blks_num * blks_num ) );
  pthread_mutex_init( &set_count_zero, NULL );
  pthread_cond_init( &count_zero_cond, NULL );

  for(int i=0; i<totblks_num*totblks_num; ++i)
  {
      if(pthread_mutex_init(&bin_mutexes[i], NULL))
	{
	  printf("\nsetupBins(): Unable to initialize the %i th mutex\n", i);
	}
  }

  int *thread_ids = (int *) malloc( blks_num * blks_num * sizeof( int ) );
  for( int i = 0; i < blks_num*blks_num; i++ ) 
    thread_ids[i] = i;

  pthread_t *threads = (pthread_t *) malloc( blks_num * blks_num * sizeof( pthread_t ) );
    
  printf("shit allocated \n");

  //
  //  do the parallel work
  //
  simulation_time = read_timer( );
  for( int i = 1; i < blks_num * blks_num; i++ ) 
    P( pthread_create( &threads[i], &attr, thread_routine, &thread_ids[i] ) );
    
  printf("pthreads created \n");

  thread_routine( &thread_ids[0] );
    
  printf("first thread runs \n");

  for( int i = 1; i < blks_num * blks_num; i++ ) 
    P( pthread_join( threads[i], NULL ) );

  simulation_time = read_timer( ) - simulation_time;
    
  printf( "n = %d, n_threads = %d, simulation time = %g seconds\n", n, blks_num*blks_num, simulation_time );
    
  //
  //  release resources
  //
  P( pthread_barrier_destroy( &barrier ) );
  P( pthread_attr_destroy( &attr ) );
  pthread_mutex_destroy(&set_count_zero);
  pthread_cond_destroy(&count_zero_cond);

  for(int i=0; i<totblks_num*totblks_num; i++)
  {
      pthread_mutex_destroy(&bin_mutexes[i]);
  }

  free( thread_ids );
  free( threads );
  free( bin_mutexes );
  free( bin_part_num );
  free( bins );
  free( particles );
  if( fsave )
    fclose( fsave );
    
  return 0;
}
Exemple #6
0
//
//  benchmarking program
//
int main( int argc, char **argv )
{    
    //
    //  process command line
    //
    if( find_option( argc, argv, "-h" ) >= 0 )
    {
        printf( "Options:\n" );
        printf( "-h to see this help\n" );
        printf( "-n <int> to set the number of particles\n" );
        printf( "-p <int> to set the number of threads\n" );
        printf( "-o <filename> to specify the output file name\n" );
        return 0;
    }
    
    n = read_int( argc, argv, "-n", 1000 );
    n_threads = read_int( argc, argv, "-p", 2 );
    char *savename = read_string( argc, argv, "-o", NULL );
    
    //
    //  allocate resources
    //
    fsave = savename ? fopen( savename, "w" ) : NULL;

    particles = (particle_t*) malloc( n * sizeof(particle_t) );
    set_size( n );
    init_particles( n, particles );

    pthread_attr_t attr;
    P( pthread_attr_init( &attr ) );
    P( pthread_barrier_init( &barrier, NULL, n_threads ) );

	// VIRAJ
	doBinning();
	// !VIRAJ

	// create threads
    int *thread_ids = (int *) malloc( n_threads * sizeof( int ) );
    for( int i = 0; i < n_threads; i++ ) 
        thread_ids[i] = i;

    pthread_t *threads = (pthread_t *) malloc( n_threads * sizeof( pthread_t ) );
    
    //
    //  do the parallel work
    //
    double simulation_time = read_timer( );
    for( int i = 1; i < n_threads; i++ ) 
        P( pthread_create( &threads[i], &attr, thread_routine, &thread_ids[i] ) );
    
    thread_routine( &thread_ids[0] );
    
    for( int i = 1; i < n_threads; i++ ) 
        P( pthread_join( threads[i], NULL ) );
    simulation_time = read_timer( ) - simulation_time;
    
    printf( "n = %d, n_threads = %d, simulation time = %g seconds\n", n, n_threads, simulation_time );
    
    //
    //  release resources
    //
    P( pthread_barrier_destroy( &barrier ) );
    P( pthread_attr_destroy( &attr ) );
    free( thread_ids );
    free( threads );
    free( particles );
    if( fsave )
        fclose( fsave );

    return 0;
}
//
//  benchmarking program
//
int main( int argc, char **argv )
{    
    //
    //  process command line
    //
    if( find_option( argc, argv, "-h" ) >= 0 )
    {
        printf( "Options:\n" );
        printf( "-h to see this help\n" );
        printf( "-n <int> to set the number of particles\n" );
        printf( "-p <int> to set the number of threads\n" );
        printf( "-o <filename> to specify the output file name\n" );
        printf( "-s <filename> to specify a summary file name\n" );
        printf( "-no turns off all correctness checks and particle output\n");        
        return 0;
    }
    
    n = read_int( argc, argv, "-n", 1000 );
    n_threads = read_int( argc, argv, "-p", 2 );
    char *savename = read_string( argc, argv, "-o", NULL );
    char *sumname = read_string( argc, argv, "-s", NULL );

    fsave = savename ? fopen( savename, "w" ) : NULL;
    fsum = sumname ? fopen ( sumname, "a" ) : NULL;

    if( find_option( argc, argv, "-no" ) != -1 )
      no_output = 1;

    //
    //  allocate resources
    //
    particles = (particle_t*) malloc( n * sizeof(particle_t) );
    set_size( n );
    init_particles( n, particles );

    pthread_attr_t attr;
    P( pthread_attr_init( &attr ) );
    P( pthread_barrier_init( &barrier, NULL, n_threads ) );

    int *thread_ids = (int *) malloc( n_threads * sizeof( int ) );
    for( int i = 0; i < n_threads; i++ ) 
        thread_ids[i] = i;

    pthread_t *threads = (pthread_t *) malloc( n_threads * sizeof( pthread_t ) );
    
    //
    //  do the parallel work
    //
    double simulation_time = read_timer( );
    for( int i = 1; i < n_threads; i++ ) 
        P( pthread_create( &threads[i], &attr, thread_routine, &thread_ids[i] ) );
    
    thread_routine( &thread_ids[0] );
    
    for( int i = 1; i < n_threads; i++ ) 
        P( pthread_join( threads[i], NULL ) );
    simulation_time = read_timer( ) - simulation_time;
   
    printf( "n = %d, simulation time = %g seconds", n, simulation_time);

    if( find_option( argc, argv, "-no" ) == -1 )
    {
      gabsavg /= (n_threads*1.0);
      // 
      //  -The minimum distance absmin between 2 particles during the run of the simulation
      //  -A Correct simulation will have particles stay at greater than 0.4 (of cutoff) with typical values between .7-.8
      //  -A simulation where particles don't interact correctly will be less than 0.4 (of cutoff) with typical values between .01-.05
      //
      //  -The average distance absavg is ~.95 when most particles are interacting correctly and ~.66 when no particles are interacting
      //
      printf( ", absmin = %lf, absavg = %lf", gabsmin, gabsavg);
      if (gabsmin < 0.4) printf ("\nThe minimum distance is below 0.4 meaning that some particle is not interacting ");
      if (gabsavg < 0.8) printf ("\nThe average distance is below 0.8 meaning that most particles are not interacting ");
    }
    printf("\n");

    //
    // Printing summary data
    //
    if( fsum)
        fprintf(fsum,"%d %d %g\n",n,n_threads,simulation_time); 
    
    //
    //  release resources
    //
    P( pthread_barrier_destroy( &barrier ) );
    P( pthread_attr_destroy( &attr ) );
    free( thread_ids );
    free( threads );
    free( particles );
    if( fsave )
        fclose( fsave );
    if( fsum )
        fclose ( fsum );
    
    return 0;
}
Exemple #8
0
extern "C" void* thread_routine (void *arg)
{
    thr_args_base* const args = (thr_args_base*)arg;

    printf ("thread %lu starting\n", args->threadno_);

    switch (args->type_tag_) {

    case thr_args_base::Char:
        return thread_routine ((thr_args<char>*)(arg));
    case thr_args_base::SChar:
        return thread_routine ((thr_args<signed char>*)(arg));
    case thr_args_base::UChar:
        return thread_routine ((thr_args<unsigned char>*)(arg));

    case thr_args_base::Short:
        return thread_routine ((thr_args<short>*)(arg));
    case thr_args_base::UShort:
        return thread_routine ((thr_args<unsigned short>*)(arg));

    case thr_args_base::Int:
        return thread_routine ((thr_args<int>*)(arg));
    case thr_args_base::UInt:
        return thread_routine ((thr_args<unsigned int>*)(arg));

    case thr_args_base::Long:
        return thread_routine ((thr_args<long>*)(arg));
    case thr_args_base::ULong:
        return thread_routine ((thr_args<unsigned long>*)(arg));

#ifdef _RWSTD_LONG_LONG

    case thr_args_base::LLong:
        return thread_routine ((thr_args<_RWSTD_LONG_LONG>*)(arg));
    case thr_args_base::ULLong:
        return thread_routine ((thr_args<unsigned _RWSTD_LONG_LONG>*)(arg));

#endif   // _RWSTD_LONG_LONG

    };

    return 0;
}