static void init(int num, rml::MemoryPool *pl, void **crThread, void **aTerm) {
threadNum = num;
pool = pl;
crossThread = crThread;
afterTerm = aTerm;
startB.initialize(threadNum);
mallocDone.initialize(threadNum);
}
size_t operator()(){
struct _{ static void retrieve_from_cache(self_type* _this, size_t thread_index){
parameter_pack& p = _this->m_parameter_pack;
access_sequence_type::iterator const begin_it =_this->m_access_sequence.begin()+ thread_index * _this->per_thread_sample_size;
access_sequence_type::iterator const end_it = begin_it + _this->per_thread_sample_size;
_this->m_barrier.wait();
tbb::tick_count start = tbb::tick_count::now();
size_t local_loops_count =0;
do {
size_t part_of_the_sample_so_far = (local_loops_count * p.time_check_granularity_ops) % _this->per_thread_sample_size;
access_sequence_type::iterator const iteration_begin_it = begin_it + part_of_the_sample_so_far;
access_sequence_type::iterator const iteration_end_it = iteration_begin_it +
(std::min)(p.time_check_granularity_ops, _this->per_thread_sample_size - part_of_the_sample_so_far);
for (access_sequence_type::iterator it = iteration_begin_it; it < iteration_end_it; ++it){
typename cache_type::handle h = _this->m_cache(*it);
micro_benchmarking::utils::busy_wait(p.time_of_item_use_usec);
micro_benchmarking::utils::disable_elimination(h.value());
}
++local_loops_count;
}while((tbb::tick_count::now()-start).seconds() < p.time_window_sec);
_this->loops_count+=local_loops_count;
}};
m_barrier.initialize(m_parameter_pack.threads_number);
NativeParallelFor(m_parameter_pack.threads_number,std::bind1st(std::ptr_fun(&_::retrieve_from_cache),this));
return loops_count * m_parameter_pack.time_check_granularity_ops;
}
BusyBodyScoped( int nThread_, int workRatiox100_, tbb::enumerable_thread_specific<double> &locals_, int &unprotected_count_, bool test_throw_) :
locals(locals_),
nThread(nThread_),
WorkRatiox100(workRatiox100_),
unprotected_count(unprotected_count_),
test_throw(test_throw_) {
sBarrier.initialize(nThread_);
}
int TestMain () {
if ( P < 2 )
return Harness::Skipped;
theNumObservers = 0;
theWorkersBarrier.initialize(P);
// Fully- and under-utilized mode
for ( int M = 1; M < P; M <<= 1 ) {
if ( M > P/2 ) {
ASSERT( P & (P-1), "Can get here only in case of non power of two cores" );
M = P/2;
if ( M & (M-1) )
break; // Already tested this configuration
}
int T = P / M;
ASSERT( T > 1, NULL );
REMARK( "Masters: %d; Arena size: %d\n", M, T );
theMasterBarrier.initialize(M);
theGlobalBarrier.initialize(M * T);
TestObserver(M, T, 0);
TestObserver(M, T, tmLocalObservation | ( T==P? tmAutoinitialization : 0) );
CleanLocalState();
TestObserver(M, T, tmSynchronized);
TestObserver(M, T, tmSynchronized | tmLocalObservation
#if __TBB_TASK_ARENA
| ( T==P? tmLeavingControl : 0)
#endif
);
}
// Oversubscribed mode
for ( int i = 0; i < 5; ++i ) {
REMARK( "Masters: %d; Arena size: %d\n", P-1, P );
TestObserver(P-1, P, 0);
TestObserver(P-1, P, tmLocalObservation);
}
Harness::Sleep(20);
return Harness::Done;
}
// -- test of producer/consumer with atomic buffer cnt and semaphore
// nTokens are total number of tokens through the pipe
// pWait is the wait time for the producer
// cWait is the wait time for the consumer
void testProducerConsumer( unsigned totTokens, unsigned nTokens, unsigned pWait, unsigned cWait) {
semaphore pSem;
semaphore cSem;
tbb::atomic<unsigned> pTokens;
tbb::atomic<unsigned> cTokens;
cTokens = 0;
unsigned cBuffer[MAX_TOKENS];
FilterBase* myFilters[2]; // one producer, one consumer
REMARK("Testing producer/consumer with %lu total tokens, %lu tokens at a time, producer wait(%lu), consumer wait (%lu)\n", totTokens, nTokens, pWait, cWait);
ASSERT(nTokens <= MAX_TOKENS, "Not enough slots for tokens");
myFilters[0] = new FilterBase(imaProducer, totTokens, pTokens, cTokens, pWait, cSem, pSem, (unsigned *)NULL, &(cBuffer[0]));
myFilters[1] = new FilterBase(imaConsumer, totTokens, cTokens, pTokens, cWait, pSem, cSem, cBuffer, (unsigned *)NULL);
pTokens = nTokens;
ProduceConsumeBody myBody(myFilters);
sBarrier.initialize(2);
NativeParallelFor(2, myBody);
delete myFilters[0];
delete myFilters[1];
}
Body( int nthread_, int niters_ ) : nthread(nthread_), nIters(niters_) { sBarrier.initialize(nthread_); }
Body(int nThread_, int nIter_, semaphore &mySem_,
vector<int>& ourCounts_,
vector<double>& tottime_
) : nThreads(nThread_), nIters(nIter_), mySem(mySem_), ourCounts(ourCounts_), tottime(tottime_) { sBarrier.initialize(nThread_); pCount = 0; }
static void initBarrier(unsigned thrds) { barrier.initialize(thrds); }
