Пример #1
0
void hash_delete()
{
	//populate
	int i;
	node_t **hd;
	lock_t *lck;

#ifdef COUNT_HASH_EMPTY
	int empty = 0;
	for(i=0; i< nbkeys; i++)
	{
		get_buckets(i, &hd, &lck);
		if(*hd==NULL) empty++;
	}
	printf("empty = %d, total = %d, ratio: %d\n", empty, nbkeys, empty/nbkeys);
#endif
	
	for(i=0; i< nbkeys; i++)
	{
		get_buckets(i, &hd, &lck);
		delete(i, hd, lck);
	}

#ifdef SET_TAIL
	//printf("SET TAIL\n");
	//insert max key
	get_buckets(i, &hd, &lck);
	delete(nbkeys+1, hd, lck);
#endif
	free((void*)hash.heads);
	free((void*)hash.locks);

}
Пример #2
0
void hash_init() 
{
	int i;

	hash.heads = calloc(sizeof(struct node_t*), nbbuckets);
	hash.locks = calloc(sizeof(lock_t), nbbuckets);

	for(i=0; i < nbbuckets; i++)
	{
		lock_init(&hash.locks[i]);
	} 

	//populate
	node_t **hd;
	lock_t *lck;

#ifdef POPULATE
	unsigned nbcores = get_nbcores();
	unsigned percorekeys = (nbkeys/nbcores)+1;
	unsigned nextcore = 1;
	//printf("npn %d %d %d\n", nbcores, percorekeys, nextcore);
	for(i=0; i< nbkeys; i++)
	{
		if(!(i%percorekeys))
		{
			//printf("switching to core %d at %d keys\n", nextcore, i);
			set_affinity(nextcore%nbcores);
			nextcore++;
		} 
		get_buckets(i, &hd, &lck);
		insert(i, hd, lck);
	}
	//printf("empty = %d, total = %d\n", empty, nbkeys);
#endif

#ifdef SET_TAIL
	printf("SET TAIL\n");
	//insert max key
	get_buckets(i, &hd, &lck);
	insert(nbkeys+1, hd, lck);
#endif
}
Пример #3
0
  Tm *find_internal(const Tk& k, size_type bkt) const {
    node_type **const buckets = get_buckets();
    assert(bkt < h.num_buckets);
    for (node_type *p = buckets[bkt]; p != 0; p = p->next) {
      entry_type& pe = p->entry;
      if (eq(pe.first, k)) {
	return &pe.second;
      }
    }
    return 0;
  }
Пример #4
0
  ~hashmap_buckets() {
    hashmap_buckets_hdr& h = *hdr;
    node_type **const buckets = get_buckets();
    for (size_type i = 0; i < h.num_buckets; ++i) {
      node_type *p = buckets[i];
      while (p != 0) {
	node_type *np = p->next;
	delete p;
	p = np;
      }
    }
    free(hdr);
  }
STKUNIT_UNIT_TEST( PerformanceTestSelector, start)
{
  size_t N = 5;
  VariableSelectorFixture fix(N);
  stk::mesh::Selector selectUnion;
  for (size_t part_i = 0 ; part_i<N ; ++part_i) {
    selectUnion |= *fix.m_declared_part_vector[part_i];
  }
  std::vector<stk::mesh::Bucket*> buckets_out;
  unsigned entity_rank = 0;
  get_buckets(selectUnion, fix.m_BulkData.buckets(entity_rank), buckets_out);
  STKUNIT_ASSERT_EQUAL( buckets_out.size(), N );
  // Construct once for large N
  // Graph time for get_buckets against 1..N
}
Пример #6
0
 hashmap_buckets(size_type ini_num_buckets, modulo_func mf) {
   hdr = static_cast<hashmap_buckets_hdr *>(malloc(
     sizeof(hashmap_buckets_hdr) +
     ini_num_buckets * sizeof(node_type *)));
     /* FIXME: check overflow */
   if (hdr == 0) {
     throw std::bad_alloc();
   }
   hashmap_buckets_hdr& h = *hdr;
   node_type **const buckets = get_buckets();
   h.num_entries = 0;
   h.num_buckets = ini_num_buckets;
   h.buckets_modf = mf;
   for (size_type i = 0; i < ini_num_buckets; ++i) {
     buckets[i] = 0;
   }
 }
Пример #7
0
  bool insert(const Tk& k, const Tm& m, size_type bkt) {
    hashmap_buckets_hdr& h = *hdr;
    node_type **const buckets = get_buckets();
    assert(bkt < h.num_buckets);
    node_type *cur = buckets[bkt];
    for (node_type *p = cur; p != 0; p = p->next) {
      entry_type& pe = p->entry;
      if (eq(pe.first, k)) {
	pe.second = m;
	return false; /* not created */
      }
    }
    /* append to the end of the buket */
    node_type *const nn = new node_type(cur, k, m);
    buckets[bkt] = nn;
    ++h.num_entries;
    return true; /* created */
  }
STKUNIT_UNIT_TEST( PerformanceTestSelector, timings)
{
  // Construction

  // If we are running with STL in debug mode we shrink the problem
  // down in order to keep things running in a reasonable amount of
  // time.
#ifdef _GLIBCXX_DEBUG
  size_t N = 1000;
#else
  size_t N = 10000;
#endif

  VariableSelectorFixture fix(N);

  std::vector<double> selector_creation(N/2);
  std::vector<double> get_buckets_usage(N/2);
  double start_time = stk::wall_time();
  size_t timing_index = 0;
  for (size_t n = 1 ; n<N; n*=2) {
    // Selector creation
    stk::mesh::Selector selectUnion;
    for (size_t part_i = 0 ; part_i<n ; ++part_i) {
      selectUnion |= *fix.m_declared_part_vector[part_i];
    }
    selector_creation[timing_index] = stk::wall_dtime(start_time);

    // Selector usage:
    std::vector<stk::mesh::Bucket*> buckets_out;
    unsigned entity_rank = 0;
    get_buckets(selectUnion, fix.m_BulkData.buckets(entity_rank), buckets_out);
    get_buckets_usage[timing_index] = stk::wall_dtime(start_time);
    ++timing_index;
  }

  // Print out table
  std::cout << "\"N\" \"selector_creation_time\" \"get_buckets_time\" " << std::endl;
  timing_index = 0;
  for (size_t n = 1 ; n<N; n*=2) {
    std::cout << n << " " << selector_creation[timing_index] << " " << get_buckets_usage[timing_index] << std::endl;
    ++timing_index;
  }
  STKUNIT_EXPECT_TRUE(true);
}
Пример #9
0
bool Selector::is_empty(EntityRank entity_rank) const
{
    if (m_expr.empty()) {
        return true;
    }

    BulkData * mesh = this->find_mesh();
    ThrowRequireMsg(mesh != NULL,
                    "ERROR, Selector::empty not available if selector expression does not involve any mesh Parts.");
    if (mesh->in_modifiable_state()) {
      BucketVector const& buckets = this->get_buckets(entity_rank);
      for(size_t i=0; i<buckets.size(); ++i) {
          if (buckets[i]->size() >0) {
              return false;
          }
      }
      return true;
    }
    return get_buckets(entity_rank).empty();
}
Пример #10
0
void bucket_traverse(const EntitySelector &entity_selector, const RelationSelector &relation_selector, Visitor &visitor, Mesh &mesh)
{
  typedef typename sierra::mesh::mesh_traits<Mesh>::bucket_key bucket_key;
  typedef typename sierra::mesh::mesh_traits<Mesh>::selected_bucket_range selected_bucket_range;
  typedef typename sierra::mesh::mesh_traits<Mesh>::bucket_key bucket_descriptor;
  typedef typename sierra::mesh::mesh_traits<Mesh>::bucket_entity_range bucket_entity_range;
  typedef typename sierra::mesh::mesh_traits<Mesh>::bucket_entity_iterator bucket_entity_iterator;
  typedef typename sierra::mesh::mesh_traits<Mesh>::selected_bucket_iterator selected_bucket_iterator;
  typedef typename sierra::mesh::mesh_traits<Mesh>::entity_descriptor entity_descriptor;
  typedef typename sierra::mesh::mesh_traits<Mesh>::entity_descriptor_range entity_descriptor_range;
  typedef typename sierra::mesh::mesh_traits<Mesh>::relation_range relation_range;
  typedef typename sierra::mesh::mesh_traits<Mesh>::relation_descriptor relation_descriptor;
  typedef typename sierra::mesh::mesh_traits<Mesh>::relation_iterator relation_iterator;
  typedef typename sierra::mesh::mesh_traits<Mesh>::entity_rank entity_rank;

  visitor.initialize(mesh);

  selected_bucket_range buckets = get_buckets(entity_selector, mesh);
  for (selected_bucket_iterator b_iter = boost::begin(buckets), b_end = boost::end(buckets);  b_iter != b_end; ++b_iter) {
    bucket_descriptor bucket = *b_iter;
    visitor.discover_bucket(bucket, mesh);

    bucket_entity_range entities = get_entities(*b_iter, mesh);
    for (bucket_entity_iterator ent_iter = boost::begin(entities), ent_end = boost::end(entities); ent_iter != ent_end; ++ent_iter) {
      entity_descriptor entity = *ent_iter;
      visitor.discover_entity(entity, mesh);

      relation_range entity_relations = sierra::mesh::get_relations(entity, relation_selector, mesh);
      visitor.examine_relation_range(entity_relations, mesh);

      for (relation_iterator rel_iter = boost::begin(entity_relations), rel_end = boost::end(entity_relations); rel_iter != rel_end; ++rel_iter) {
        relation_descriptor relation = *rel_iter;
        visitor.examine_relation(relation, mesh);
      }

      visitor.finish_entity(entity, mesh);
    }
    visitor.finish_bucket(bucket, mesh);
  }
  visitor.finalize(mesh);
}
Пример #11
0
void* run(void* arg)
{
	unsigned long i;
	char iamreader;
	int key; long t = (long) arg; long nbn;//same cache line for the best rand!
	double start, end;
	node_t **hd;
	lock_t *lck;

	set_affinity(t);

	/************ init *****************/
	thd_ins = 0;
	thd_del = 0;
	thd_sea = 0;
	nbmallocs = 0;
	nbretry = 0;
	nbrelink = 0;
	nbreprev = 0;
	nbfl = 0;
	thread=t;
	thd_nbupdaters=nbupdaters;
	setsignals();
	iamreader = t >= nbupdaters ? 1 : 0;
	if(!iamreader)	prealloc();
	mysrand(t^time(NULL));
	/************** init done **************/

	/************** barrier ****************/
	atomic_xadd4(&ready, 1);
	while(!go) memory_barrier();

	/******************* START ****************/
	start = d_gettimeofday();
#ifdef RCU
	rcu_register_thread();
#endif

	i=0;
	do{
		key = myrand()%nbkeys;
		//key = rand_r(&thd_seed)%nbthreads;
		//key = (t+key)%nbkeys;
		//key = random() % nbkeys;
		//if(i%100000) printf("%d %d\n", thread, key);

		get_buckets(key, &hd, &lck);
		if(iamreader)
		{
			thd_sea += search(key, hd, lck);
			if(i>= NB_TEST) break;
		}
		else
		{
			if(i%2)
				thd_ins += insert(key, hd, lck);
			else
				thd_del += delete(key, hd, lck);
			if(done) {
				//printf("writer stopped\n");
				break;
			}
		}
		//if(!(i%10000)) 
			//printf("%d loop %d\n", t, i);
#ifdef RCU_QSBR
#if ((defined RCU_QSBR_ACCELERATE) || (defined RCU_Q10))
#ifdef RCU_Q10
		if(!(i%10)) 
#else
		if(!(i%100)) 
#endif
#endif
			rcu_quiescent_state();
#endif
	}while(++i);

#ifdef RCU
	//if(!iamreader) rcu_barrier();
	//printf("iamreader %d, ops %d\n", iamreader, i);
	rcu_unregister_thread();
#endif

	end = d_gettimeofday(); 
	/******************* END ****************/

	
	//number of ops done
	thd_ops[t] = i;
	
	//printf("nbmallocs %g\n", nbmallocs);
	thd_mallocs[t] = nbmallocs;
	thd_retry[t] = nbretry;
	thd_relink[t] = nbrelink;
	thd_reprev[t] = nbreprev;

	//if(t==0) printf("%lu | nbblocked %g\n", t, nbblockeds);
#ifdef RCU
	thd_blockeds[t] = atomic_read_ptr(&rcublockeds);
#else
	thd_blockeds[t] = nbblockeds;
#endif

	//average time per ops
	avg_time[t] = (((end - start))/i);

	//total time
	thd_time[t] = (end - start);

	suc_ins[t] = thd_ins;
	suc_sea[t] = thd_sea;
	suc_del[t] = thd_del;

	return NULL;
}
Пример #12
0
 stk::mesh::BucketVector const& get_buckets()
 {
     return get_buckets(stk::mesh::selectField(scalarField));
 }