Datasets:
shibing624
/
source_code

Dataset card Data Studio Files Community
2
text
stringlengths
0
2.2M
void *testCase5_fn2(int threadNum, const MyTask& task)
{
CaseData5 *data = reinterpret_cast< CaseData5 *> (task.arg());
Rand rand (threadNum);
for (int i=0; i < data->d_numIter; ++i) {
// get random slot
int slotIndex = rand.get() % data->d_numElements;
bslmt::LockGuard<bslmt::Mutex> guard(&data->d_mutexes[slotIndex]);
data->d_slots[slotIndex] = 0;
ASSERT(data->d_slots[slotIndex] == 0);
data->d_slots[slotIndex] |= 1;
ASSERT(data->d_slots[slotIndex] == 1);
data->d_slots[slotIndex] <<= 1;
ASSERT(data->d_slots[slotIndex] == 2);
data->d_slots[slotIndex] ^= 2;
ASSERT(data->d_slots[slotIndex] == 0);
}
return 0;
}
// ----------------------------------------------------------------------------
// Case 4. Set/Wait Flags Test
//
// Concerns:
// To test internal primitives setFlags/waitOnFlag on which QLock
// is based.
//
// Plan:
// Create two threads and two flags. First thread in the loop sets
// the first flag and waits on second flag. The second thread sets
// the second flag and waits on the first. Ensure that threads
// never have a deadlock.
// 'Flag' means an atomic pointer to the synchronization object and
// can be in one of three states:
// 0 nor 'setFlag' neither 'waitOnFlag' have been called yet
// -1 'setFlag' was called before 'waitOnFlag', so there is no
// need for 'waitOnFlag' to wait on synchronization object
// XXX 'waitOnFlag' was called before 'setFlag' and waits on
// synchronization object with address 'XXX'. 'setFlag' must
// post/signal/notify that synchronization object.
//
// ----------------------------------------------------------------------------
static Semaphore *const dummySemaphorePtr =
reinterpret_cast<Semaphore *const> (-1L);
struct DataCase4 {
bsls::AtomicPointer<Semaphore> d_event1;
bsls::AtomicPointer<Semaphore> d_event2;
bsls::AtomicInt d_flagStart;
bsls::AtomicInt d_flagEnd;
void reset ()
{
d_event1.swap(0);
d_event2.swap(0);
d_flagStart.swap(0);
d_flagEnd.swap(0);
ASSERT (d_flagStart == 0);
ASSERT (d_flagEnd == 0);
}
};
void setFlag(bsls::AtomicPointer<Semaphore> *flag)
{
// set '-1' if it was 0, and get the original value
Semaphore *event = flag->testAndSwap(0, dummySemaphorePtr);
if (event) {
ASSERT (event != dummySemaphorePtr);
// Another thread has already stored an event handle in the flag.
event->post();
}
}
void waitOnFlag(bsls::AtomicPointer<Semaphore> *flag, int spinCount)
{
Semaphore *event = 0;
int i = 0;
do {
// read flag value with memory barrier
event = *flag;
}
while ((event == 0) && (++i < spinCount));
if (event == 0) {