int test_kmp_set_defaults_lock_bug()
{
  /* checks that omp_get_num_threads is equal to the number of
     threads */
  int nthreads_lib;
  int nthreads = 0;

  nthreads_lib = -1;

  #pragma omp parallel
  {
    omp_set_lock(&lock);
    nthreads++;
    omp_unset_lock(&lock);
    #pragma omp single
    {
      nthreads_lib = omp_get_num_threads ();
    }  /* end of single */
  } /* end of parallel */
  kmp_set_defaults("OMP_NUM_THREADS");
  #pragma omp parallel
  {
    omp_set_lock(&lock);
    nthreads++;
    omp_unset_lock(&lock);
  } /* end of parallel */

  return (nthreads == 2*nthreads_lib);
}
Пример #2
0
/* Assumes node is already locked */
static inline void lockTwoNodes(Node *node, Node *node2)
{
	IDnum nodeID = getNodeID(node);
	IDnum node2ID = getNodeID(node2);

	if (nodeID < 0)
		nodeID = -nodeID;
	if (node2ID < 0)
		node2ID = -node2ID;

	if (nodeID == node2ID)
		return;

	/* Lock lowest ID first to avoid deadlocks */
	if (nodeID < node2ID)
	{
		omp_set_lock (nodeLocks + node2ID);
	}
	else if (!omp_test_lock (nodeLocks + node2ID))
	{
		omp_unset_lock (nodeLocks + nodeID);
		omp_set_lock (nodeLocks + node2ID);
		omp_set_lock (nodeLocks + nodeID);
	}
}
Пример #3
0
void multWith_LockedArrays(){
	#pragma omp for schedule(static, N / NUM_THREADS)
	for(int i = 0; i < N; i++){
		forces[i][X_Pos] = 0;
		forces[i][Y_Pos] = 0;
	}

	#pragma omp for schedule(static, N / NUM_THREADS)
	for(int	i = 0; i < N; i++){
		double x_dif, y_dif, dist, dist_cubed;		
		double tempForcX, tempForcY;
		for(int j = i + 1; j < N; j++){			
			x_dif = pos[i][X_Pos] - pos[j][X_Pos];
			y_dif = pos[i][Y_Pos] - pos[j][Y_Pos];
			dist = sqrt(x_dif * x_dif + y_dif * y_dif);
			dist_cubed = dist * dist * dist;
			tempForcX = constG * masses[i] * masses[j] / dist_cubed * x_dif;
			tempForcY = constG * masses[i] * masses[j] / dist_cubed * y_dif;
			
			omp_set_lock(&locks[i]);					
			forces[i][X_Pos] += tempForcX;
			forces[i][Y_Pos] += tempForcY;
			omp_unset_lock(&locks[i]);

			omp_set_lock(&locks[j]);
			forces[j][X_Pos] -= tempForcX;
			forces[j][Y_Pos] -= tempForcY;			
			omp_unset_lock(&locks[j]);				
		}
	}		
}
Пример #4
0
int kernel(int npoints, int nclusters) {
  
  int i, j, delta = 0, index;

  #pragma omp parallel for default(shared) \
                            private(i,j,index) \
                            schedule(static)
  
  for(i = 0; i < npoints; i++) {
    
    index = find_nearest_point(feature[i], 2, clusters, nclusters);
    
    if (membership[i] != index) {
      omp_set_lock(&delta_lock);
        delta += 1;
      omp_unset_lock(&delta_lock);
    }
    
    membership[i] = index;
    
    omp_set_lock(&new_centers_len_locks[index]);
      new_centers_len[index]++;
    omp_unset_lock(&new_centers_len_locks[index]);

    for(j = 0; j < 2; j++) {
      omp_set_lock(&new_centers_locks[index][j]);
        new_centers[index][j] += feature[i][j];
      omp_unset_lock(&new_centers_locks[index][j]);   
    }
  }

  return delta;
}
Пример #5
0
int main(){
	/*объявляем mutex*/
	omp_lock_t lock_1;
	/*!!!обязательно инициализируем его!!!*/
	omp_init_lock(&lock_1);
	#pragma omp parallel num_threads(3)
	{
		#pragma omp sections
		{
			#pragma omp section
			{
				omp_set_lock(&lock_1); //устанавливать и снимать надо в одном и том же потоке
				std::cout<<"После установки блокировки 1\n";
				omp_unset_lock(&lock_1);
			}
			#pragma omp section
			{
				omp_set_lock(&lock_1);
				std::cout<<"После установки блокировки 2\n";
				omp_unset_lock(&lock_1);
			}
			#pragma omp section
			{
				omp_set_lock(&lock_1);
				std::cout<<"После установки блокировки 3\n";
				omp_unset_lock(&lock_1);
			}
		}
	}

	return 0;
}
Пример #6
0
int dequeue(){
    while(tail == NULL);

    if(head == tail){
        int data = head->data;
        omp_set_lock(&head_lock);
        head = NULL;
        #pragma omp flush(head)
        omp_unset_lock(&head_lock);

        omp_set_lock(&tail_lock);
        tail = NULL;
        #pragma omp flush(tail)
        omp_unset_lock(&tail_lock);

        return data;
    }
    else{
        int data = tail->data;
        NODE *ptr = head;
        while(ptr->next != tail)
            ptr = ptr->next;

        omp_set_lock(&tail_lock);
        tail = ptr;
        tail->next = NULL;
        #pragma omp flush(tail)
        omp_unset_lock(&tail_lock);

        return data;
    }
}
Пример #7
0
int main (int argc, char *argv[]) 
{
int nthreads, tid, i;
float a[N], b[N];
omp_lock_t locka, lockb;

/* Initialize the locks */
omp_init_lock(&locka);
omp_init_lock(&lockb);

/* Fork a team of threads giving them their own copies of variables */
#pragma omp parallel shared(a, b, nthreads, locka, lockb) private(tid)
  {

  /* Obtain thread number and number of threads */
  tid = omp_get_thread_num();
  #pragma omp master
    {
    nthreads = omp_get_num_threads();
    printf("Number of threads = %d\n", nthreads);
    }
  printf("Thread %d starting...\n", tid);
  #pragma omp barrier

  #pragma omp sections nowait
    {
    #pragma omp section
      {
      printf("Thread %d initializing a[]\n",tid);
      omp_set_lock(&locka);
      for (i=0; i<N; i++)
        a[i] = i * DELTA;
      omp_unset_lock(&locka);// if unset, the other thread will wait
      omp_set_lock(&lockb);
      printf("Thread %d adding a[] to b[]\n",tid);
      for (i=0; i<N; i++)
        b[i] += a[i];
      omp_unset_lock(&lockb);
      //omp_unset_lock(&locka);
      }

    #pragma omp section
      {
      printf("Thread %d initializing b[]\n",tid);
      omp_set_lock(&lockb);
      for (i=0; i<N; i++)
        b[i] = i * PI;
      omp_unset_lock(&lockb);// if unset, the other thread will wait
      omp_set_lock(&locka);
      printf("Thread %d adding b[] to a[]\n",tid);
      for (i=0; i<N; i++)
        a[i] += b[i];
      omp_unset_lock(&locka);
      //omp_unset_lock(&lockb);
      }
    }  /* end of sections */
  }  /* end of parallel region */

}
Пример #8
0
void POMP2_Set_lock(omp_lock_t *s) {
  if ( pomp2_tracing ) {
    esd_enter(epk_omp_regid[EPK__OMP_SET_LOCK]);
    omp_set_lock(s);
    if ( pomp2_tracing > 1 ) esd_omp_alock(epk_lock_id(s));
    esd_exit(epk_omp_regid[EPK__OMP_SET_LOCK]);
  } else {
    omp_set_lock(s);
  }
}
Пример #9
0
void incrementer(omp_lock_t* lock_b) {
	for(int i=0; i< LOOP_ITS; ++i) {
		omp_set_lock(&g_lock_a);
		g_a++;
		omp_unset_lock(&g_lock_a);
		omp_set_lock(lock_b);
		g_b++;
		omp_unset_lock(lock_b);
	}
}
Пример #10
0
void POMP_Set_lock(omp_lock_t *s) {
  if ( IS_POMP_TRACE_ON ) {
    uint64_t time = vt_pform_wtime();
    vt_enter(&time, vt_omp_regid[VT__OMP_SET_LOCK]);
    omp_set_lock(s);
    time = vt_pform_wtime();
    vt_omp_alock(&time, vt_lock_id(s));
    vt_exit(&time);
  } else {
    omp_set_lock(s);
  }
}
Пример #11
0
DEF_FPOMP_FUNC(void POMP_Set_lock_f(omp_lock_t *s)) {
  if ( IS_POMP_TRACE_ON ) {
    uint64_t time = vt_pform_wtime();
    vt_enter(&time, vt_omp_regid[VT__OMP_SET_LOCK]);
    omp_set_lock(s);
    time = vt_pform_wtime();
    vt_omp_alock(&time, vt_lock_id(s));
    vt_exit(&time);
  } else {
    omp_set_lock(s);
  }
} VT_GENERATE_F77_BINDINGS(pomp_set_lock, POMP_SET_LOCK,
Пример #12
0
VT_DECLDEF(void POMP_Set_lock_f(omp_lock_t *s)) {
  if ( IS_POMP_TRACE_ON ) {
    uint64_t time;
    time = vt_pform_wtime();
    vt_enter(VT_CURRENT_THREAD, &time, vt_omp_regid[VT__OMP_SET_LOCK]);
    omp_set_lock(s);
    time = vt_pform_wtime();
    vt_exit(VT_CURRENT_THREAD, &time);
  } else {
    omp_set_lock(s);
  }
} VT_GENERATE_F77_BINDINGS(pomp_set_lock, POMP_SET_LOCK,
Пример #13
0
void POMP_Set_lock(omp_lock_t *s) {
  if ( IS_POMP_TRACE_ON ) {
    uint64_t time;
    time = vt_pform_wtime();
    vt_enter(VT_CURRENT_THREAD, &time, vt_omp_regid[VT__OMP_SET_LOCK]);
    omp_set_lock(s);
    time = vt_pform_wtime();
    vt_exit(VT_CURRENT_THREAD, &time);
  } else {
    omp_set_lock(s);
  }
}
Пример #14
0
/*
Looks up a previously stored state, or generates a new one. No assumptions are
made about whether the board state is in reduced form already. Never fails. If
the memory is full it allocates a new state regardless. If the state is found
and returned it's OpenMP lock is first set. Thread-safe.
RETURNS the state information
*/
tt_stats * tt_lookup_create(
    const board * b,
    bool is_black,
    u64 hash
){
    u32 key = (u32)(hash % ((u64)number_of_buckets));
    omp_lock_t * bucket_lock = is_black ? &b_table_lock : &w_table_lock;
    omp_set_lock(bucket_lock);

    tt_stats * ret = find_state(hash, b, is_black);
    if(ret == NULL) /* doesnt exist */
    {
        if(states_in_use >= max_allocated_states)
        {
            /*
            It is possible in theory for a complex ko to produce a situation
            where freeing the game tree that is not reachable doesn't free any
            states.
            */
            tt_log_status();
            char * s = alloc();
            board_to_string(s, b->p, b->last_played, b->last_eaten);
            flog_warn("tt", s);
            release(s);
            flog_warn("tt", "memory exceeded on root lookup");
        }

        ret = create_state(hash);
        memcpy(ret->p, b->p, TOTAL_BOARD_SIZ);
        ret->last_eaten_passed =
            (b->last_played == PASS) ? PASS : b->last_eaten;
        omp_set_lock(&ret->lock);

        if(is_black)
        {
            ret->next = b_stats_table[key];
            b_stats_table[key] = ret;
        }
        else
        {
            ret->next = w_stats_table[key];
            w_stats_table[key] = ret;
        }
        omp_unset_lock(bucket_lock);
    }
    else /* update */
    {
        omp_set_lock(&ret->lock);
        omp_unset_lock(bucket_lock);
    }

    return ret;
}
Пример #15
0
/**
 * PRIVATE. Insert a region in a context.
 */
static inline int
bfwork_region_insert(bam_fwork_t *fwork, bam_region_t *region)
{
	linked_list_t *list;
	size_t list_l;

	assert(fwork);
	assert(region);

	omp_set_lock(&fwork->regions_lock);

	//List handle
	list = fwork->regions_list;
	list_l = linked_list_size(list);

	if(list_l >= FWORK_REGIONS_MAX)
	{
		omp_unset_lock(&fwork->regions_lock);

		//Wait for free slots
		if(!omp_test_lock(&fwork->free_slots))
		{
			if(omp_get_num_threads() == 2)
			{
				#pragma omp taskwait	//Force processing
			}
			omp_set_lock(&fwork->free_slots);
		}

		//LOG_FATAL_F("Not enough region slots, current: %d\n", list_l);
	}

	//This lock must be always locked until regions buffer have regions free
	omp_test_lock(&fwork->free_slots);

	//Add region to list
	linked_list_insert_last(region, list);

	omp_set_lock(&region->lock);
	LOG_INFO_F("Inserting region %d:%lu-%lu with %d reads\n",
				region->chrom + 1, region->init_pos + 1,
				region->end_pos + 1, region->size);
	LOG_INFO_F("Regions to process %lu\n", linked_list_size(list));
	omp_unset_lock(&region->lock);

	omp_unset_lock(&fwork->regions_lock);

	return NO_ERROR;
}
Пример #16
0
void *popBusyWait(struct Stack *s) {
    struct Node *temp;
    void *d;
    omp_set_lock(&s->lock);
    while (s->top == NULL) {
        omp_unset_lock(&s->lock);
        omp_set_lock(&s->lock);
    }
    d = s->top->data;
    temp = s->top;
    s->top = s->top->next;
    omp_unset_lock(&s->lock);
    free(temp);
    return d;
}
Пример #17
0
void
openmp_print_tid (void)
{
  omp_set_lock (&writelock);
  SC_PRODUCTIONF ("Hello from thread %i.\n", omp_get_thread_num ());
  omp_unset_lock (&writelock);
}
Пример #18
0
 OpenMPCounter& OpenMPCounter::operator ++()
 {
     omp_set_lock(&_lock);
     ++_counter;
     omp_unset_lock(&_lock);
     return *this;
 }
Пример #19
0
int ATL_DecAtomicCount(void *vp)
{
   char *cp=vp;
   #ifdef ATL_OMP_THREADS
      omp_lock_t *mp;
   #else
      pthread_mutex_t *mp;
   #endif
   int *cntp;
   int iret;

   cntp = (int*)(cp+128);
   #ifdef ATL_OMP_THREADS
      mp = (omp_lock_t*)(cntp+2);
      omp_set_lock(mp);
   #else
      mp = (pthread_mutex_t*)(cntp+2);
      pthread_mutex_lock(mp);
   #endif
   iret = *cntp;
   if (iret) (*cntp)--;
   #ifdef ATL_OMP_THREADS
      omp_unset_lock(mp);
   #else
      pthread_mutex_unlock(mp);
   #endif
   return(iret);
}
int main()
{
  omp_lock_t lck;
  int id;
  omp_init_lock(&lck);

  #pragma omp parallel shared(lck) private(id)
  {
    id = omp_get_thread_num();

    omp_set_lock(&lck);
    /*  only one thread at a time can execute this printf */
    printf("My thread id is %d.\n", id);
    omp_unset_lock(&lck);

    while (! omp_test_lock(&lck)) {
      skip(id);   /* we do not yet have the lock,
                     so we must do something else */
    }

    work(id);      /* we now have the lock
                      and can do the work */

    omp_unset_lock(&lck);
  }
  omp_destroy_lock(&lck);

  return 0;
}
Пример #21
0
FLA_Error FLA_Axpy_sync_circular( FLA_Obj alpha, FLA_Obj X, FLA_Obj B )
{
  FLA_Obj XL,    XR,       X0,  X1,  X2;
  FLA_Obj BL,    BR,       B0,  B1,  B2;

  int n_stages    = FLA_omp_get_num_stages();
  int stage_width = FLA_omp_compute_stage_width( X );
  int thread_num  = omp_get_thread_num();
  int n_done      = 0;
  int b, i;

  // Start thread i on the ith panel partition of B.
  FLA_Part_1x2( X,    &XL,  &XR,    stage_width*thread_num, FLA_LEFT );
  FLA_Part_1x2( B,    &BL,  &BR,    stage_width*thread_num, FLA_LEFT );

  while ( n_done++ < n_stages ){

    // The last lockable partition may be smaller than the others.
    b = min( FLA_Obj_width( XR ), stage_width );
    
    FLA_Repart_1x2_to_1x3( XL,  /**/ XR,        &X0, /**/ &X1, &X2,
                           b, FLA_RIGHT );

    FLA_Repart_1x2_to_1x3( BL,  /**/ BR,        &B0, /**/ &B1, &B2,
                           b, FLA_RIGHT );

    /*------------------------------------------------------------*/

    // Get the index of the current partition.
    i = FLA_Obj_width(XL)/stage_width;

    // Acquire lock[i] (the lock for X1 and B1).
    omp_set_lock( &fla_omp_lock[i] );

    // B1 := alpha * X1 + B1
    FLA_Axpy_external( alpha, X1, B1 );

    // Release lock[i] (the lock for X1 and B1).
    omp_unset_lock( &fla_omp_lock[i] );

    /*------------------------------------------------------------*/

    FLA_Cont_with_1x3_to_1x2( &XL,  /**/ &XR,        X0, X1, /**/ X2,
                              FLA_LEFT );

    FLA_Cont_with_1x3_to_1x2( &BL,  /**/ &BR,        B0, B1, /**/ B2,
                              FLA_LEFT );

    // If this thread reaches the last partition, wrap back around to 
    // the first partition for the next iteration.
    if( FLA_Obj_width( XL ) == FLA_Obj_width( X ) )
    {
      FLA_Part_1x2( X,    &XL,  &XR,      0, FLA_LEFT );
      FLA_Part_1x2( B,    &BL,  &BR,      0, FLA_LEFT );
    }

  }

  return FLA_SUCCESS;
}
Пример #22
0
/* Locks a single cell
 * i, j the coordinates of the cell; board, the current board
 */
void lockCell(int i, int j, Board board){

	int width = board->width + 1;
	int offset = i * width + j;

	omp_set_lock(&(board->locks[offset]));
}
Пример #23
0
void
computeHistogram (const Eigen::MatrixXf &data, Eigen::MatrixXf &histogram, size_t bins, float min, float max)
{
    float bin_size = (max-min) / bins;
    int num_dim = data.cols();
    histogram = Eigen::MatrixXf::Zero (bins, num_dim);

    for (int dim = 0; dim < num_dim; dim++)
    {
        omp_lock_t bin_lock[bins];
        for(size_t pos=0; pos<bins; pos++)
            omp_init_lock(&bin_lock[pos]);

    #pragma omp parallel for firstprivate(min, max, bins) schedule(dynamic)
        for (int j = 0; j<data.rows(); j++)
        {
            int pos = std::floor( (data(j,dim) - min) / bin_size);

            if(pos < 0)
                pos = 0;

            if(pos > (int)bins)
                pos = bins - 1;

            omp_set_lock(&bin_lock[pos]);
            histogram(pos,dim)++;
            omp_unset_lock(&bin_lock[pos]);
        }

        for(size_t pos=0; pos<bins; pos++)
            omp_destroy_lock(&bin_lock[pos]);
    }
}
inline void CReferenceCounter::Release(void* pObject)
{
    PNL_CHECK_IS_NULL_POINTER(pObject);
    
    omp_set_lock(&m_release_lock);
    std::list<void*>::iterator location = std::find( m_refList.begin(),
        m_refList.end(), pObject );
    
    assert( location != m_refList.end() );
       
    while( location != m_refList.end() )
    {
        location = std::find( m_refList.erase(location), m_refList.end(),
            pObject );
    }
    
    if( m_refList.empty() )
    {
	omp_unset_lock(&m_release_lock);
        delete this;
    }
    else
    {
        omp_unset_lock(&m_release_lock);
    };
}
Пример #25
0
int colvarproxy_smp::smp_lock()
{
#if defined(_OPENMP)
  omp_set_lock(reinterpret_cast<omp_lock_t *>(omp_lock_state));
#endif
  return COLVARS_OK;
}
Пример #26
0
static tt_stats * create_state(
    u64 hash
){
    tt_stats * ret = NULL;

    omp_set_lock(&freed_nodes_lock);
    if(freed_nodes != NULL)
    {
        ret = freed_nodes;
        freed_nodes = freed_nodes->next;
    }
    else
        ++allocated_states;
    ++states_in_use;
    omp_unset_lock(&freed_nodes_lock);

    if(ret == NULL)
    {
        ret = (tt_stats *)malloc(sizeof(tt_stats));
        if(ret == NULL)
            flog_crit("tt", "create_state: system out of memory");

        omp_init_lock(&ret->lock);
    }

    /* careful that some fields are not initialized here */
    ret->zobrist_hash = hash;
    ret->maintenance_mark = maintenance_mark;
    ret->plays_count = 0;
    ret->expansion_delay = expansion_delay;
    return ret;
}
Пример #27
0
/*Each thread will call this function independantly.  They calculate dataset
 *and then write it out to hdf, for NUM_MDSET times */
void CalcWriteData(hid_t fid, hid_t dataspace, hid_t datatype)
{
    double   data[NX][NY];
    hid_t    dataset;
    char     dname[16];
    int      tid;
    int      i, j, k;

    tid = omp_get_thread_num();

    for(i=0; i<NUM_MDSET; i++) {
         /*Weird calculation to extend computing time*/
         for(j=0; j<NX; j++) {
              for(k=0; k<NY; k++) 
                   data[j][k] = ( pow(sin(tid), 2.0) + pow(cos(tid), 2.0) ) * 
                            ( tid + i ) +
                            ( pow(123456789.0, 8.0) - pow(123456789.0, 8.0) );
   
	 }
         sprintf(dname, "tid%d-dataset%d", tid, i);

         /*Serialize HDF dataset writing using OpenMP lock*/
         omp_set_lock(&lock);

         dataset = H5Dcreate(fid, dname, datatype, dataspace, H5P_DEFAULT);
         H5Dwrite(dataset, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, H5P_DEFAULT, 
                  data);
         H5Dclose(dataset);

         /*Release lock*/
         omp_unset_lock(&lock);
    }

}
Пример #28
0
int test_omp_lock()
{
  int nr_threads_in_single = 0;
  int result = 0;
  int nr_iterations = 0;
  int i;

  omp_init_lock(&lck);
  #pragma omp parallel shared(lck)
  {
    #pragma omp for
    for(i = 0; i < LOOPCOUNT; i++) {
      omp_set_lock(&lck);
      #pragma omp flush
      nr_threads_in_single++;
      #pragma omp flush       
      nr_iterations++;
      nr_threads_in_single--;
      result = result + nr_threads_in_single;
      omp_unset_lock(&lck);
    }
  }
  omp_destroy_lock(&lck);

  return ((result == 0) && (nr_iterations == LOOPCOUNT));
}
Пример #29
0
void
ColorTransformOMP::initializeLUT()
{
    omp_set_lock(&initialization_lock_);

    sRGB_LUT.resize(256);
    sXYZ_LUT.resize(4000);

    #pragma omp parallel for schedule (dynamic)
    for (int i = 0; i < 256; i++)
    {
        float f = static_cast<float> (i) / 255.0f;
        if (f > 0.04045)
            sRGB_LUT[i] = powf ((f + 0.055f) / 1.055f, 2.4f);
        else
            sRGB_LUT[i] = f / 12.92f;
    }

    #pragma omp parallel for schedule (dynamic)
    for (int i = 0; i < 4000; i++)
    {
        float f = static_cast<float> (i) / 4000.0f;
        if (f > 0.008856)
            sXYZ_LUT[i] = static_cast<float> (powf (f, 0.3333f));
        else
            sXYZ_LUT[i] = static_cast<float>((7.787 * f) + (16.0 / 116.0));
    }

    omp_unset_lock(&initialization_lock_);
}
Пример #30
0
	int CoutLock::set()
	{
#ifdef _OPENMP
		omp_set_lock(&CoutLock::coutLock);
#endif
		return 0;
	}