Google Git
Sign in
ara-mdk / platform / external / valgrind / 4d341fdc623fb5c487c1521ec84edb1945df705b / . / unittest / racecheck_unittest.cc
blob: d6d8a839ae02a30e64e858d75d704098aee0e892 [file] [log] [blame]
/*
This file is part of Valgrind, a dynamic binary instrumentation
framework.
Copyright (C) 2008-2008 Google Inc
opensource@google.com
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307, USA.
The GNU General Public License is contained in the file COPYING.
*/
/* Author: Konstantin Serebryany <opensource@google.com>
This file contains a set of unit tests for a data race detection tool.
These tests can be compiled with pthreads (default) or
with any other library that supports threads, locks, cond vars, etc.
*/
#include <fcntl.h>
#include <signal.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <queue>
#include <vector>
#include "old_test_suite.h"
#include "test_utils.h"
#include <gtest/gtest.h>
#include "gtest_fixture_injection.h"
// The tests are
// - Stability tests (marked STAB)
// - Performance tests (marked PERF)
// - Feature tests
// - TN (true negative) : no race exists and the tool is silent.
// - TP (true positive) : a race exists and reported.
// - FN (false negative): a race exists but not reported.
// - FP (false positive): no race exists but the tool reports it.
//
// The feature tests are marked according to the behavior of ThreadSanitizer.
//
// TP and FP tests are annotated with ANNOTATE_EXPECT_RACE,
// so, no error reports should be seen when running under ThreadSanitizer.
//
// When some of the FP cases are fixed in helgrind we'll need
// to update these tests.
//
// Each test resides in its own namespace.
// Namespaces are named test01, test02, ...
// Please, *DO NOT* change the logic of existing tests nor rename them.
// Create a new test instead.
//
// Some tests use sleep()/usleep().
// This is not a synchronization, but a simple way to trigger
// some specific behaviour of the race detector's scheduler.
// Globals and utilities used by several tests. {{{1
static CondVar CV;
static int COND = 0;
// test00: {{{1
namespace test00 {
int GLOB = 0;
void Run() {
printf("test00: negative\n");
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST(Run, 00)
} // namespace test00
// test01: TP. Simple race (write vs write). {{{1
namespace test01 {
int GLOB = 0;
void Worker1() {
GLOB = 1;
}
void Worker2() {
GLOB = 2;
}
void Run() {
ANNOTATE_EXPECT_RACE_FOR_TSAN(&GLOB, "test01. TP.");
ANNOTATE_TRACE_MEMORY(&GLOB);
printf("test01: positive\n");
MyThreadArray t(Worker1, Worker2);
t.Start();
t.Join();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST(Run, 1);
} // namespace test01
// test02: TN. Synchronization via CondVar. {{{1
namespace test02 {
int GLOB = 0;
// Two write accesses to GLOB are synchronized because
// the pair of CV.Signal() and CV.Wait() establish happens-before relation.
//
// Waiter: Waker:
// 1. COND = 0
// 2. Start(Waker)
// 3. MU.Lock() a. write(GLOB)
// b. MU.Lock()
// c. COND = 1
// /--- d. CV.Signal()
// 4. while(COND) / e. MU.Unlock()
// CV.Wait(MU) <---/
// 5. MU.Unlock()
// 6. write(GLOB)
Mutex MU;
void Waker() {
usleep(200000); // Make sure the waiter blocks.
GLOB = 1;
MU.Lock();
COND = 1;
CV.Signal();
MU.Unlock();
}
void Waiter() {
ThreadPool pool(1);
pool.StartWorkers();
COND = 0;
pool.Add(NewCallback(Waker));
MU.Lock();
while(COND != 1)
CV.Wait(&MU);
MU.Unlock();
GLOB = 2;
}
void Run() {
printf("test02: negative\n");
Waiter();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST(Run, 2);
} // namespace test02
// test03: TN. Synchronization via LockWhen, signaller gets there first. {{{1
namespace test03 {
int GLOB = 0;
// Two write accesses to GLOB are synchronized via conditional critical section.
// Note that LockWhen() happens first (we use sleep(1) to make sure)!
//
// Waiter: Waker:
// 1. COND = 0
// 2. Start(Waker)
// a. write(GLOB)
// b. MU.Lock()
// c. COND = 1
// /--- d. MU.Unlock()
// 3. MU.LockWhen(COND==1) <---/
// 4. MU.Unlock()
// 5. write(GLOB)
Mutex MU;
void Waker() {
usleep(100000); // Make sure the waiter blocks.
GLOB = 1;
MU.Lock();
COND = 1; // We are done! Tell the Waiter.
MU.Unlock(); // calls ANNOTATE_CONDVAR_SIGNAL;
}
void Waiter() {
ThreadPool pool(1);
pool.StartWorkers();
COND = 0;
pool.Add(NewCallback(Waker));
MU.LockWhen(Condition(&ArgIsOne, &COND)); // calls ANNOTATE_CONDVAR_WAIT
MU.Unlock(); // Waker is done!
GLOB = 2;
}
void Run() {
printf("test03: negative\n");
Waiter();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST2(Run, 3, FEATURE|NEEDS_ANNOTATIONS);
} // namespace test03
// test04: TN. Synchronization via PCQ. {{{1
namespace test04 {
int GLOB = 0;
ProducerConsumerQueue Q(INT_MAX);
// Two write accesses to GLOB are separated by PCQ Put/Get.
//
// Putter: Getter:
// 1. write(GLOB)
// 2. Q.Put() ---------\ .
// \-------> a. Q.Get()
// b. write(GLOB)
void Putter() {
GLOB = 1;
Q.Put(NULL);
}
void Getter() {
Q.Get();
GLOB = 2;
}
void Run() {
printf("test04: negative\n");
MyThreadArray t(Putter, Getter);
t.Start();
t.Join();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST(Run, 4);
} // namespace test04
// test05: FP. Synchronization via CondVar, but waiter does not block. {{{1
// Since CondVar::Wait() is not called, we get a false positive.
namespace test05 {
int GLOB = 0;
// Two write accesses to GLOB are synchronized via CondVar.
// But race detector can not see it.
// See this for details:
// http://www.valgrind.org/docs/manual/hg-manual.html#hg-manual.effective-use.
//
// Waiter: Waker:
// 1. COND = 0
// 2. Start(Waker)
// 3. MU.Lock() a. write(GLOB)
// b. MU.Lock()
// c. COND = 1
// d. CV.Signal()
// 4. while(COND) e. MU.Unlock()
// CV.Wait(MU) <<< not called
// 5. MU.Unlock()
// 6. write(GLOB)
Mutex MU;
void Waker() {
GLOB = 1;
MU.Lock();
COND = 1;
CV.Signal();
MU.Unlock();
}
void Waiter() {
usleep(100000); // Make sure the signaller gets first.
MU.Lock();
while(COND != 1)
CV.Wait(&MU);
MU.Unlock();
GLOB = 2;
}
void Run() {
printf("test05: unavoidable false positive\n");
COND = 0;
if (!Tsan_PureHappensBefore())
ANNOTATE_EXPECT_RACE_FOR_TSAN(&GLOB, "test05. FP. Unavoidable in hybrid scheme.");
MyThreadArray t(Waker, Waiter);
t.Start();
t.Join();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST(Run, 5);
} // namespace test05
// test06: TN. Synchronization via CondVar, but Waker gets there first. {{{1
namespace test06 {
int GLOB = 0;
// Same as test05 but we annotated the Wait() loop.
//
// Waiter: Waker:
// 1. COND = 0
// 2. Start(Waker)
// 3. MU.Lock() a. write(GLOB)
// b. MU.Lock()
// c. COND = 1
// /------- d. CV.Signal()
// 4. while(COND) / e. MU.Unlock()
// CV.Wait(MU) <<< not called /
// 6. ANNOTATE_CONDVAR_WAIT(CV, MU) <----/
// 5. MU.Unlock()
// 6. write(GLOB)
Mutex MU;
void Waker() {
GLOB = 1;
MU.Lock();
COND = 1;
CV.Signal();
MU.Unlock();
}
void Waiter() {
ThreadPool pool(1);
pool.StartWorkers();
COND = 0;
pool.Add(NewCallback(Waker));
usleep(500000); // Make sure the signaller gets first.
MU.Lock();
while(COND != 1)
CV.Wait(&MU);
ANNOTATE_CONDVAR_LOCK_WAIT(&CV, &MU);
MU.Unlock();
GLOB = 2;
}
void Run() {
printf("test06: negative\n");
Waiter();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST2(Run, 6, FEATURE|NEEDS_ANNOTATIONS);
} // namespace test06
// test07: TN. Synchronization via LockWhen(), Signaller is observed first. {{{1
namespace test07 {
int GLOB = 0;
bool COND = 0;
// Two write accesses to GLOB are synchronized via conditional critical section.
// LockWhen() is observed after COND has been set (due to sleep).
// Unlock() calls ANNOTATE_CONDVAR_SIGNAL().
//
// Waiter: Signaller:
// 1. COND = 0
// 2. Start(Signaller)
// a. write(GLOB)
// b. MU.Lock()
// c. COND = 1
// /--- d. MU.Unlock calls ANNOTATE_CONDVAR_SIGNAL
// 3. MU.LockWhen(COND==1) <---/
// 4. MU.Unlock()
// 5. write(GLOB)
Mutex MU;
void Signaller() {
GLOB = 1;
MU.Lock();
COND = true; // We are done! Tell the Waiter.
MU.Unlock(); // calls ANNOTATE_CONDVAR_SIGNAL;
}
void Waiter() {
COND = false;
MyThread t(Signaller);
t.Start();
usleep(100000); // Make sure the signaller gets there first.
MU.LockWhen(Condition(&ArgIsTrue, &COND)); // calls ANNOTATE_CONDVAR_WAIT
MU.Unlock(); // Signaller is done!
GLOB = 2; // If LockWhen didn't catch the signal, a race may be reported here.
t.Join();
}
void Run() {
printf("test07: negative\n");
Waiter();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST2(Run, 7, FEATURE|NEEDS_ANNOTATIONS);
} // namespace test07
// test08: TN. Synchronization via thread start/join. {{{1
namespace test08 {
int GLOB = 0;
// Three accesses to GLOB are separated by thread start/join.
//
// Parent: Worker:
// 1. write(GLOB)
// 2. Start(Worker) ------------>
// a. write(GLOB)
// 3. Join(Worker) <------------
// 4. write(GLOB)
void Worker() {
GLOB = 2;
}
void Parent() {
MyThread t(Worker);
GLOB = 1;
t.Start();
t.Join();
GLOB = 3;
}
void Run() {
printf("test08: negative\n");
Parent();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST(Run, 8);
} // namespace test08
// test09: TP. Simple race (read vs write). {{{1
namespace test09 {
int GLOB = 0;
// A simple data race between writer and reader.
// Write happens after read (enforced by sleep).
// Usually, easily detectable by a race detector.
void Writer() {
usleep(100000);
GLOB = 3;
}
void Reader() {
CHECK(GLOB != -777);
}
void Run() {
ANNOTATE_TRACE_MEMORY(&GLOB);
ANNOTATE_EXPECT_RACE_FOR_TSAN(&GLOB, "test09. TP.");
printf("test09: positive\n");
MyThreadArray t(Writer, Reader);
t.Start();
t.Join();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST(Run, 9);
} // namespace test09
// test10: FN. Simple race (write vs read). {{{1
namespace test10 {
int GLOB = 0;
// A simple data race between writer and reader.
// Write happens before Read (enforced by sleep),
// otherwise this test is the same as test09.
//
// Writer: Reader:
// 1. write(GLOB) a. sleep(long enough so that GLOB
// is most likely initialized by Writer)
// b. read(GLOB)
//
//
// Eraser algorithm does not detect the race here,
// see Section 2.2 of http://citeseer.ist.psu.edu/savage97eraser.html.
//
void Writer() {
GLOB = 3;
}
void Reader() {
usleep(100000);
CHECK(GLOB != -777);
}
void Run() {
ANNOTATE_EXPECT_RACE_FOR_TSAN(&GLOB, "test10. TP. FN in MSMHelgrind.");
printf("test10: positive\n");
MyThreadArray t(Writer, Reader);
t.Start();
t.Join();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST(Run, 10);
} // namespace test10
// test12: FP. Synchronization via Mutex, then via PCQ. {{{1
namespace test12 {
int GLOB = 0;
// This test is properly synchronized, but currently (Dec 2007)
// helgrind reports a false positive.
//
// First, we write to GLOB under MU, then we synchronize via PCQ,
// which is essentially a semaphore.
//
// Putter: Getter:
// 1. MU.Lock() a. MU.Lock()
// 2. write(GLOB) <---- MU ----> b. write(GLOB)
// 3. MU.Unlock() c. MU.Unlock()
// 4. Q.Put() ---------------> d. Q.Get()
// e. write(GLOB)
ProducerConsumerQueue Q(INT_MAX);
Mutex MU;
void Putter() {
MU.Lock();
GLOB++;
MU.Unlock();
Q.Put(NULL);
}
void Getter() {
MU.Lock();
GLOB++;
MU.Unlock();
Q.Get();
GLOB++;
}
void Run() {
// ANNOTATE_EXPECT_RACE(&GLOB, "test12. FP. Fixed by MSMProp1.");
printf("test12: negative\n");
MyThreadArray t(Putter, Getter);
t.Start();
t.Join();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST(Run, 12);
} // namespace test12
// test13: FP. Synchronization via Mutex, then via LockWhen. {{{1
namespace test13 {
int GLOB = 0;
// This test is essentially the same as test12, but uses LockWhen
// instead of PCQ.
//
// Waker: Waiter:
// 1. MU.Lock() a. MU.Lock()
// 2. write(GLOB) <---------- MU ----------> b. write(GLOB)
// 3. MU.Unlock() c. MU.Unlock()
// 4. MU.Lock() .
// 5. COND = 1 .
// 6. ANNOTATE_CONDVAR_SIGNAL -------\ .
// 7. MU.Unlock() \ .
// \----> d. MU.LockWhen(COND == 1)
// e. MU.Unlock()
// f. write(GLOB)
Mutex MU;
void Waker() {
MU.Lock();
GLOB++;
MU.Unlock();
MU.Lock();
COND = 1;
ANNOTATE_CONDVAR_SIGNAL(&MU);
MU.Unlock();
}
void Waiter() {
MU.Lock();
GLOB++;
MU.Unlock();
MU.LockWhen(Condition(&ArgIsOne, &COND));
MU.Unlock();
GLOB++;
}
void Run() {
// ANNOTATE_EXPECT_RACE(&GLOB, "test13. FP. Fixed by MSMProp1.");
printf("test13: negative\n");
COND = 0;
MyThreadArray t(Waker, Waiter);
t.Start();
t.Join();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST2(Run, 13, FEATURE|NEEDS_ANNOTATIONS);
} // namespace test13
// test14: FP. Synchronization via PCQ, reads, 2 workers. {{{1
namespace test14 {
int GLOB = 0;
// This test is properly synchronized, but currently (Dec 2007)
// helgrind reports a false positive.
//
// This test is similar to test11, but uses PCQ (semaphore).
//
// Putter2: Putter1: Getter:
// 1. read(GLOB) a. read(GLOB)
// 2. Q2.Put() ----\ b. Q1.Put() -----\ .
// \ \--------> A. Q1.Get()
// \----------------------------------> B. Q2.Get()
// C. write(GLOB)
ProducerConsumerQueue Q1(INT_MAX), Q2(INT_MAX);
void Putter1() {
CHECK(GLOB != 777);
Q1.Put(NULL);
}
void Putter2() {
CHECK(GLOB != 777);
Q2.Put(NULL);
}
void Getter() {
Q1.Get();
Q2.Get();
GLOB++;
}
void Run() {
// ANNOTATE_EXPECT_RACE(&GLOB, "test14. FP. Fixed by MSMProp1.");
printf("test14: negative\n");
MyThreadArray t(Getter, Putter1, Putter2);
t.Start();
t.Join();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST(Run, 14);
} // namespace test14
// test15: TN. Synchronization via LockWhen. One waker and 2 waiters. {{{1
namespace test15 {
// Waker: Waiter1, Waiter2:
// 1. write(GLOB)
// 2. MU.Lock()
// 3. COND = 1
// 4. ANNOTATE_CONDVAR_SIGNAL ------------> a. MU.LockWhen(COND == 1)
// 5. MU.Unlock() b. MU.Unlock()
// c. read(GLOB)
int GLOB = 0;
Mutex MU;
void Waker() {
GLOB = 2;
MU.Lock();
COND = 1;
ANNOTATE_CONDVAR_SIGNAL(&MU);
MU.Unlock();
};
void Waiter() {
MU.LockWhen(Condition(&ArgIsOne, &COND));
MU.Unlock();
CHECK(GLOB != 777);
}
void Run() {
COND = 0;
printf("test15: negative\n");
MyThreadArray t(Waker, Waiter, Waiter);
t.Start();
t.Join();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST(Run, 15);
} // namespace test15
// test16: FP. Barrier (emulated by CV), 2 threads. {{{1
namespace test16 {
// Worker1: Worker2:
// 1. MU.Lock() a. MU.Lock()
// 2. write(GLOB) <------------ MU ----------> b. write(GLOB)
// 3. MU.Unlock() c. MU.Unlock()
// 4. MU2.Lock() d. MU2.Lock()
// 5. COND-- e. COND--
// 6. ANNOTATE_CONDVAR_SIGNAL(MU2) ---->V .
// 7. MU2.Await(COND == 0) <------------+------ f. ANNOTATE_CONDVAR_SIGNAL(MU2)
// 8. MU2.Unlock() V-----> g. MU2.Await(COND == 0)
// 9. read(GLOB) h. MU2.Unlock()
// i. read(GLOB)
//
//
// TODO: This way we may create too many edges in happens-before graph.
// Arndt Mühlenfeld in his PhD (TODO: link) suggests creating special nodes in
// happens-before graph to reduce the total number of edges.
// See figure 3.14.
//
//
int GLOB = 0;
Mutex MU;
Mutex MU2;
void Worker() {
MU.Lock();
GLOB++;
MU.Unlock();
MU2.Lock();
COND--;
ANNOTATE_CONDVAR_SIGNAL(&MU2);
MU2.Await(Condition(&ArgIsZero, &COND));
MU2.Unlock();
CHECK(GLOB == 2);
}
void Run() {
// ANNOTATE_EXPECT_RACE(&GLOB, "test16. FP. Fixed by MSMProp1 + Barrier support.");
COND = 2;
printf("test16: negative\n");
MyThreadArray t(Worker, Worker);
t.Start();
t.Join();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST2(Run, 16, FEATURE|NEEDS_ANNOTATIONS);
} // namespace test16
// test17: FP. Barrier (emulated by CV), 3 threads. {{{1
namespace test17 {
// Same as test16, but with 3 threads.
int GLOB = 0;
Mutex MU;
Mutex MU2;
void Worker() {
MU.Lock();
GLOB++;
MU.Unlock();
MU2.Lock();
COND--;
ANNOTATE_CONDVAR_SIGNAL(&MU2);
MU2.Await(Condition(&ArgIsZero, &COND));
MU2.Unlock();
CHECK(GLOB == 3);
}
void Run() {
COND = 3;
printf("test17: negative\n");
MyThreadArray t(Worker, Worker, Worker);
t.Start();
t.Join();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST2(Run, 17, FEATURE|NEEDS_ANNOTATIONS);
} // namespace test17
// test18: TN. Synchronization via Await(), signaller gets there first. {{{1
namespace test18 {
int GLOB = 0;
Mutex MU;
// Same as test03, but uses Mutex::Await() instead of Mutex::LockWhen().
void Waker() {
usleep(100000); // Make sure the waiter blocks.
GLOB = 1;
MU.Lock();
COND = 1; // We are done! Tell the Waiter.
MU.Unlock(); // calls ANNOTATE_CONDVAR_SIGNAL;
}
void Waiter() {
ThreadPool pool(1);
pool.StartWorkers();
COND = 0;
pool.Add(NewCallback(Waker));
MU.Lock();
MU.Await(Condition(&ArgIsOne, &COND)); // calls ANNOTATE_CONDVAR_WAIT
MU.Unlock(); // Waker is done!
GLOB = 2;
}
void Run() {
printf("test18: negative\n");
Waiter();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST2(Run, 18, FEATURE|NEEDS_ANNOTATIONS);
} // namespace test18
// test19: TN. Synchronization via AwaitWithTimeout(). {{{1
namespace test19 {
int GLOB = 0;
// Same as test18, but with AwaitWithTimeout. Do not timeout.
Mutex MU;
void Waker() {
usleep(100000); // Make sure the waiter blocks.
GLOB = 1;
MU.Lock();
COND = 1; // We are done! Tell the Waiter.
MU.Unlock(); // calls ANNOTATE_CONDVAR_SIGNAL;
}
void Waiter() {
ThreadPool pool(1);
pool.StartWorkers();
COND = 0;
pool.Add(NewCallback(Waker));
MU.Lock();
CHECK(MU.AwaitWithTimeout(Condition(&ArgIsOne, &COND), INT_MAX));
MU.Unlock();
GLOB = 2;
}
void Run() {
printf("test19: negative\n");
Waiter();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST2(Run, 19, FEATURE|NEEDS_ANNOTATIONS);
} // namespace test19
// test20: TP. Incorrect synchronization via AwaitWhen(), timeout. {{{1
namespace test20 {
int GLOB = 0;
Mutex MU;
// True race. We timeout in AwaitWhen.
void Waker() {
GLOB = 1;
usleep(100 * 1000);
}
void Waiter() {
MU.Lock();
CHECK(!MU.AwaitWithTimeout(Condition(&ArgIsOne, &COND), 100));
MU.Unlock();
GLOB = 2;
}
void Run() {
printf("test20: positive\n");
COND = 0;
ANNOTATE_EXPECT_RACE_FOR_TSAN(&GLOB, "test20. TP.");
MyThreadArray t(Waker, Waiter);
t.Start();
t.Join();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST2(Run, 20, FEATURE|NEEDS_ANNOTATIONS);
} // namespace test20
// test21: TP. Incorrect synchronization via LockWhenWithTimeout(). {{{1
namespace test21 {
int GLOB = 0;
// True race. We timeout in LockWhenWithTimeout().
Mutex MU;
void Waker() {
GLOB = 1;
usleep(100 * 1000);
}
void Waiter() {
CHECK(!MU.LockWhenWithTimeout(Condition(&ArgIsOne, &COND), 100));
MU.Unlock();
GLOB = 2;
}
void Run() {
printf("test21: positive\n");
COND = 0;
ANNOTATE_EXPECT_RACE_FOR_TSAN(&GLOB, "test21. TP.");
MyThreadArray t(Waker, Waiter);
t.Start();
t.Join();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST2(Run, 21, FEATURE|NEEDS_ANNOTATIONS);
} // namespace test21
// test22: TP. Incorrect synchronization via CondVar::WaitWithTimeout(). {{{1
namespace test22 {
int GLOB = 0;
Mutex MU;
// True race. We timeout in CondVar::WaitWithTimeout().
void Waker() {
GLOB = 1;
usleep(100 * 1000);
}
void Waiter() {
int ms_left_to_wait = 100;
int deadline_ms = GetTimeInMs() + ms_left_to_wait;
MU.Lock();
while(COND != 1 && ms_left_to_wait > 0) {
CV.WaitWithTimeout(&MU, ms_left_to_wait);
ms_left_to_wait = deadline_ms - GetTimeInMs();
}
MU.Unlock();
GLOB = 2;
}
void Run() {
printf("test22: positive\n");
COND = 0;
ANNOTATE_EXPECT_RACE_FOR_TSAN(&GLOB, "test22. TP.");
MyThreadArray t(Waker, Waiter);
t.Start();
t.Join();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST(Run, 22);
} // namespace test22
// test23: TN. TryLock, ReaderLock, ReaderTryLock. {{{1
namespace test23 {
// Correct synchronization with TryLock, Lock, ReaderTryLock, ReaderLock.
int GLOB = 0;
Mutex MU;
void Worker_TryLock() {
for (int i = 0; i < 20; i++) {
while (true) {
if (MU.TryLock()) {
GLOB++;
MU.Unlock();
break;
}
usleep(1000);
}
}
}
void Worker_ReaderTryLock() {
for (int i = 0; i < 20; i++) {
while (true) {
if (MU.ReaderTryLock()) {
CHECK(GLOB != 777);
MU.ReaderUnlock();
break;
}
usleep(1000);
}
}
}
void Worker_ReaderLock() {
for (int i = 0; i < 20; i++) {
MU.ReaderLock();
CHECK(GLOB != 777);
MU.ReaderUnlock();
usleep(1000);
}
}
void Worker_Lock() {
for (int i = 0; i < 20; i++) {
MU.Lock();
GLOB++;
MU.Unlock();
usleep(1000);
}
}
void Run() {
printf("test23: negative\n");
MyThreadArray t(Worker_TryLock,
Worker_ReaderTryLock,
Worker_ReaderLock,
Worker_Lock
);
t.Start();
t.Join();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST(Run, 23);
} // namespace test23
// test24: TN. Synchronization via ReaderLockWhen(). {{{1
namespace test24 {
int GLOB = 0;
Mutex MU;
// Same as test03, but uses ReaderLockWhen().
void Waker() {
usleep(100000); // Make sure the waiter blocks.
GLOB = 1;
MU.Lock();
COND = 1; // We are done! Tell the Waiter.
MU.Unlock(); // calls ANNOTATE_CONDVAR_SIGNAL;
}
void Waiter() {
ThreadPool pool(1);
pool.StartWorkers();
COND = 0;
pool.Add(NewCallback(Waker));
MU.ReaderLockWhen(Condition(&ArgIsOne, &COND));
MU.ReaderUnlock();
GLOB = 2;
}
void Run() {
printf("test24: negative\n");
Waiter();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST2(Run, 24, FEATURE|NEEDS_ANNOTATIONS);
} // namespace test24
// test25: TN. Synchronization via ReaderLockWhenWithTimeout(). {{{1
namespace test25 {
int GLOB = 0;
Mutex MU;
// Same as test24, but uses ReaderLockWhenWithTimeout().
// We do not timeout.
void Waker() {
usleep(100000); // Make sure the waiter blocks.
GLOB = 1;
MU.Lock();
COND = 1; // We are done! Tell the Waiter.
MU.Unlock(); // calls ANNOTATE_CONDVAR_SIGNAL;
}
void Waiter() {
ThreadPool pool(1);
pool.StartWorkers();
COND = 0;
pool.Add(NewCallback(Waker));
CHECK(MU.ReaderLockWhenWithTimeout(Condition(&ArgIsOne, &COND), INT_MAX));
MU.ReaderUnlock();
GLOB = 2;
}
void Run() {
printf("test25: negative\n");
Waiter();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST2(Run, 25, FEATURE|NEEDS_ANNOTATIONS);
} // namespace test25
// test26: TP. Incorrect synchronization via ReaderLockWhenWithTimeout(). {{{1
namespace test26 {
int GLOB = 0;
Mutex MU;
// Same as test25, but we timeout and incorrectly assume happens-before.
void Waker() {
GLOB = 1;
usleep(10000);
}
void Waiter() {
CHECK(!MU.ReaderLockWhenWithTimeout(Condition(&ArgIsOne, &COND), 100));
MU.ReaderUnlock();
GLOB = 2;
}
void Run() {
printf("test26: positive\n");
COND = 0;
ANNOTATE_EXPECT_RACE_FOR_TSAN(&GLOB, "test26. TP");
MyThreadArray t(Waker, Waiter);
t.Start();
t.Join();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST2(Run, 26, FEATURE|NEEDS_ANNOTATIONS);
} // namespace test26
// test27: TN. Simple synchronization via SpinLock. {{{1
namespace test27 {
#ifndef NO_SPINLOCK
int GLOB = 0;
SpinLock MU;
void Worker() {
MU.Lock();
GLOB++;
MU.Unlock();
usleep(10000);
}
void Run() {
printf("test27: negative\n");
MyThreadArray t(Worker, Worker, Worker, Worker);
t.Start();
t.Join();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST2(Run, 27, FEATURE|NEEDS_ANNOTATIONS);
#endif
} // namespace test27
// test28: TN. Synchronization via Mutex, then PCQ. 3 threads {{{1
namespace test28 {
// Putter1: Getter: Putter2:
// 1. MU.Lock() A. MU.Lock()
// 2. write(GLOB) B. write(GLOB)
// 3. MU.Unlock() C. MU.Unlock()
// 4. Q.Put() ---------\ /------- D. Q.Put()
// 5. MU.Lock() \-------> a. Q.Get() / E. MU.Lock()
// 6. read(GLOB) b. Q.Get() <---------/ F. read(GLOB)
// 7. MU.Unlock() (sleep) G. MU.Unlock()
// c. read(GLOB)
ProducerConsumerQueue Q(INT_MAX);
int GLOB = 0;
Mutex MU;
void Putter() {
MU.Lock();
GLOB++;
MU.Unlock();
Q.Put(NULL);
MU.Lock();
CHECK(GLOB != 777);
MU.Unlock();
}
void Getter() {
Q.Get();
Q.Get();
usleep(100000);
CHECK(GLOB == 2);
}
void Run() {
printf("test28: negative\n");
MyThreadArray t(Getter, Putter, Putter);
t.Start();
t.Join();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST(Run, 28);
} // namespace test28
// test29: TN. Synchronization via Mutex, then PCQ. 4 threads. {{{1
namespace test29 {
// Similar to test28, but has two Getters and two PCQs.
ProducerConsumerQueue *Q1, *Q2;
Mutex MU;
int GLOB = 0;
void Putter(ProducerConsumerQueue *q) {
MU.Lock();
GLOB++;
MU.Unlock();
q->Put(NULL);
q->Put(NULL);
MU.Lock();
CHECK(GLOB != 777);
MU.Unlock();
}
void Putter1() { Putter(Q1); }
void Putter2() { Putter(Q2); }
void Getter() {
Q1->Get();
Q2->Get();
usleep(100000);
CHECK(GLOB == 2);
usleep(48000); // TODO: remove this when FP in test32 is fixed.
}
void Run() {
printf("test29: negative\n");
Q1 = new ProducerConsumerQueue(INT_MAX);
Q2 = new ProducerConsumerQueue(INT_MAX);
MyThreadArray t(Getter, Getter, Putter1, Putter2);
t.Start();
t.Join();
printf("\tGLOB=%d\n", GLOB);
delete Q1;
delete Q2;
}
REGISTER_TEST(Run, 29);
} // namespace test29
// test30: TN. Synchronization via 'safe' race. Writer vs multiple Readers. {{{1
namespace test30 {
// This test shows a very risky kind of synchronization which is very easy
// to get wrong. Actually, I am not sure I've got it right.
//
// Writer: Reader1, Reader2, ..., ReaderN:
// 1. write(GLOB[i]: i >= BOUNDARY) a. n = BOUNDARY
// 2. HAPPENS_BEFORE(BOUNDARY+1) -------> b. HAPPENS_AFTER(n)
// 3. BOUNDARY++; c. read(GLOB[i]: i < n)
//
// Here we have a 'safe' race on accesses to BOUNDARY and
// no actual races on accesses to GLOB[]:
// Writer writes to GLOB[i] where i>=BOUNDARY and then increments BOUNDARY.
// Readers read BOUNDARY and read GLOB[i] where i<BOUNDARY.
//
// I am not completely sure that this scheme guaranties no race between
// accesses to GLOB since compilers and CPUs
// are free to rearrange memory operations.
// I am actually sure that this scheme is wrong unless we use
// some smart memory fencing...
const int N = 48;
static int GLOB[N];
volatile int BOUNDARY = 0;
void Writer() {
for (int i = 0; i < N; i++) {
CHECK(BOUNDARY == i);
for (int j = i; j < N; j++) {
GLOB[j] = j;
}
ANNOTATE_HAPPENS_BEFORE(reinterpret_cast<void*>(BOUNDARY+1));
BOUNDARY++;
usleep(1000);
}
}
void Reader() {
int n;
do {
n = BOUNDARY;
if (n == 0) continue;
ANNOTATE_HAPPENS_AFTER(reinterpret_cast<void*>(n));
for (int i = 0; i < n; i++) {
CHECK(GLOB[i] == i);
}
usleep(100);
} while(n < N);
}
void Run() {
ANNOTATE_EXPECT_RACE((void*)(&BOUNDARY), "test30. Sync via 'safe' race.");
printf("test30: negative\n");
MyThreadArray t(Writer, Reader, Reader, Reader);
t.Start();
t.Join();
printf("\tGLOB=%d\n", GLOB[N-1]);
}
REGISTER_TEST2(Run, 30, FEATURE|NEEDS_ANNOTATIONS);
} // namespace test30
// test31: TN. Synchronization via 'safe' race. Writer vs Writer. {{{1
namespace test31 {
// This test is similar to test30, but
// it has one Writer instead of mulitple Readers.
//
// Writer1: Writer2
// 1. write(GLOB[i]: i >= BOUNDARY) a. n = BOUNDARY
// 2. HAPPENS_BEFORE(BOUNDARY+1) -------> b. HAPPENS_AFTER(n)
// 3. BOUNDARY++; c. write(GLOB[i]: i < n)
//
const int N = 48;
static int GLOB[N];
volatile int BOUNDARY = 0;
void Writer1() {
for (int i = 0; i < N; i++) {
CHECK(BOUNDARY == i);
for (int j = i; j < N; j++) {
GLOB[j] = j;
}
ANNOTATE_HAPPENS_BEFORE(reinterpret_cast<void*>(BOUNDARY+1));
BOUNDARY++;
usleep(1000);
}
}
void Writer2() {
int n;
do {
n = BOUNDARY;
if (n == 0) continue;
ANNOTATE_HAPPENS_AFTER(reinterpret_cast<void*>(n));
for (int i = 0; i < n; i++) {
if(GLOB[i] == i) {
GLOB[i]++;
}
}
usleep(100);
} while(n < N);
}
void Run() {
ANNOTATE_EXPECT_RACE((void*)(&BOUNDARY), "test31. Sync via 'safe' race.");
printf("test31: negative\n");
MyThreadArray t(Writer1, Writer2);
t.Start();
t.Join();
printf("\tGLOB=%d\n", GLOB[N-1]);
}
REGISTER_TEST2(Run, 31, FEATURE|NEEDS_ANNOTATIONS);
} // namespace test31
// test32: FP. Synchronization via thread create/join. W/R. {{{1
namespace test32 {
// This test is well synchronized but helgrind 3.3.0 reports a race.
//
// Parent: Writer: Reader:
// 1. Start(Reader) -----------------------\ .
// \ .
// 2. Start(Writer) ---\ \ .
// \---> a. MU.Lock() \--> A. sleep(long enough)
// b. write(GLOB)
// /---- c. MU.Unlock()
// 3. Join(Writer) <---/
// B. MU.Lock()
// C. read(GLOB)
// /------------ D. MU.Unlock()
// 4. Join(Reader) <----------------/
// 5. write(GLOB)
//
//
// The call to sleep() in Reader is not part of synchronization,
// it is required to trigger the false positive in helgrind 3.3.0.
//
int GLOB = 0;
Mutex MU;
void Writer() {
MU.Lock();
GLOB = 1;
MU.Unlock();
}
void Reader() {
usleep(480000);
MU.Lock();
CHECK(GLOB != 777);
MU.Unlock();
}
void Parent() {
MyThread r(Reader);
MyThread w(Writer);
r.Start();
w.Start();
w.Join(); // 'w' joins first.
r.Join();
GLOB = 2;
}
void Run() {
// ANNOTATE_EXPECT_RACE(&GLOB, "test32. FP. Fixed by MSMProp1.");
printf("test32: negative\n");
Parent();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST(Run, 32);
} // namespace test32
// test33: STAB. Stress test for the number of thread sets (TSETs). {{{1
namespace test33 {
int GLOB = 0;
// Here we access N memory locations from within log(N) threads.
// We do it in such a way that helgrind creates nearly all possible TSETs.
// Then we join all threads and start again (N_iter times).
const int N_iter = 48;
const int Nlog = 15;
const int N = 1 << Nlog;
static int ARR[N];
Mutex MU;
void Worker() {
MU.Lock();
int n = ++GLOB;
MU.Unlock();
n %= Nlog;
for (int i = 0; i < N; i++) {
// ARR[i] is accessed by threads from i-th subset
if (i & (1 << n)) {
CHECK(ARR[i] == 0);
}
}
}
void Run() {
printf("test33:\n");
std::vector<MyThread*> vec(Nlog);
for (int j = 0; j < N_iter; j++) {
// Create and start Nlog threads
for (int i = 0; i < Nlog; i++) {
vec[i] = new MyThread(Worker);
}
for (int i = 0; i < Nlog; i++) {
vec[i]->Start();
}
// Join all threads.
for (int i = 0; i < Nlog; i++) {
vec[i]->Join();
delete vec[i];
}
printf("------------------\n");
}
printf("\tGLOB=%d; ARR[1]=%d; ARR[7]=%d; ARR[N-1]=%d\n",
GLOB, ARR[1], ARR[7], ARR[N-1]);
}
REGISTER_TEST2(Run, 33, STABILITY|EXCLUDE_FROM_ALL);
} // namespace test33
// test34: STAB. Stress test for the number of locks sets (LSETs). {{{1
namespace test34 {
// Similar to test33, but for lock sets.
int GLOB = 0;
const int N_iter = 48;
const int Nlog = 10;
const int N = 1 << Nlog;
static int ARR[N];
static Mutex *MUs[Nlog];
void Worker() {
for (int i = 0; i < N; i++) {
// ARR[i] is protected by MUs from i-th subset of all MUs
for (int j = 0; j < Nlog; j++) if (i & (1 << j)) MUs[j]->Lock();
CHECK(ARR[i] == 0);
for (int j = 0; j < Nlog; j++) if (i & (1 << j)) MUs[j]->Unlock();
}
}
void Run() {
printf("test34:\n");
for (int iter = 0; iter < N_iter; iter++) {
for (int i = 0; i < Nlog; i++) {
MUs[i] = new Mutex;
}
MyThreadArray t(Worker, Worker);
t.Start();
t.Join();
for (int i = 0; i < Nlog; i++) {
delete MUs[i];
}
printf("------------------\n");
}
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST2(Run, 34, STABILITY|EXCLUDE_FROM_ALL);
} // namespace test34
// test35: PERF. Lots of mutexes and lots of call to free(). {{{1
namespace test35 {
// Helgrind 3.3.0 has very slow in shadow_mem_make_NoAccess(). Fixed locally.
// With the fix helgrind runs this test about a minute.
// Without the fix -- about 5 minutes. (on c2d 2.4GHz).
//
// TODO: need to figure out the best way for performance testing.
int **ARR;
const int N_mu = 25000;
const int N_free = 48000;
void Worker() {
for (int i = 0; i < N_free; i++)
CHECK(777 == *ARR[i]);
}
void Run() {
printf("test35:\n");
std::vector<Mutex*> mus;
ARR = new int *[N_free];
for (int i = 0; i < N_free; i++) {
const int c = N_free / N_mu;
if ((i % c) == 0) {
mus.push_back(new Mutex);
mus.back()->Lock();
mus.back()->Unlock();
}
ARR[i] = new int(777);
}
// Need to put all ARR[i] into shared state in order
// to trigger the performance bug.
MyThreadArray t(Worker, Worker);
t.Start();
t.Join();
for (int i = 0; i < N_free; i++) delete ARR[i];
delete [] ARR;
for (size_t i = 0; i < mus.size(); i++) {
delete mus[i];
}
}
REGISTER_TEST2(Run, 35, PERFORMANCE|EXCLUDE_FROM_ALL);
} // namespace test35
// test36: TN. Synchronization via Mutex, then PCQ. 3 threads. W/W {{{1
namespace test36 {
// variation of test28 (W/W instead of W/R)
// Putter1: Getter: Putter2:
// 1. MU.Lock(); A. MU.Lock()
// 2. write(GLOB) B. write(GLOB)
// 3. MU.Unlock() C. MU.Unlock()
// 4. Q.Put() ---------\ /------- D. Q.Put()
// 5. MU1.Lock() \-------> a. Q.Get() / E. MU1.Lock()
// 6. MU.Lock() b. Q.Get() <---------/ F. MU.Lock()
// 7. write(GLOB) G. write(GLOB)
// 8. MU.Unlock() H. MU.Unlock()
// 9. MU1.Unlock() (sleep) I. MU1.Unlock()
// c. MU1.Lock()
// d. write(GLOB)
// e. MU1.Unlock()
ProducerConsumerQueue Q(INT_MAX);
int GLOB = 0;
Mutex MU, MU1;
void Putter() {
MU.Lock();
GLOB++;
MU.Unlock();
Q.Put(NULL);
MU1.Lock();
MU.Lock();
GLOB++;
MU.Unlock();
MU1.Unlock();
}
void Getter() {
Q.Get();
Q.Get();
usleep(100000);
MU1.Lock();
GLOB++;
MU1.Unlock();
}
void Run() {
printf("test36: negative \n");
MyThreadArray t(Getter, Putter, Putter);
t.Start();
t.Join();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST(Run, 36);
} // namespace test36
// test37: TN. Simple synchronization (write vs read). {{{1
namespace test37 {
int GLOB = 0;
Mutex MU;
// Similar to test10, but properly locked.
// Writer: Reader:
// 1. MU.Lock()
// 2. write
// 3. MU.Unlock()
// a. MU.Lock()
// b. read
// c. MU.Unlock();
void Writer() {
MU.Lock();
GLOB = 3;
MU.Unlock();
}
void Reader() {
usleep(100000);
MU.Lock();
CHECK(GLOB != -777);
MU.Unlock();
}
void Run() {
printf("test37: negative\n");
MyThreadArray t(Writer, Reader);
t.Start();
t.Join();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST(Run, 37);
} // namespace test37
// test38: TN. Synchronization via Mutexes and PCQ. 4 threads. W/W {{{1
namespace test38 {
// Fusion of test29 and test36.
// Putter1: Putter2: Getter1: Getter2:
// MU1.Lock() MU1.Lock()
// write(GLOB) write(GLOB)
// MU1.Unlock() MU1.Unlock()
// Q1.Put() Q2.Put()
// Q1.Put() Q2.Put()
// MU1.Lock() MU1.Lock()
// MU2.Lock() MU2.Lock()
// write(GLOB) write(GLOB)
// MU2.Unlock() MU2.Unlock()
// MU1.Unlock() MU1.Unlock() sleep sleep
// Q1.Get() Q1.Get()
// Q2.Get() Q2.Get()
// MU2.Lock() MU2.Lock()
// write(GLOB) write(GLOB)
// MU2.Unlock() MU2.Unlock()
//
ProducerConsumerQueue *Q1, *Q2;
int GLOB = 0;
Mutex MU, MU1, MU2;
void Putter(ProducerConsumerQueue *q) {
MU1.Lock();
GLOB++;
MU1.Unlock();
q->Put(NULL);
q->Put(NULL);
MU1.Lock();
MU2.Lock();
GLOB++;
MU2.Unlock();
MU1.Unlock();
}
void Putter1() { Putter(Q1); }
void Putter2() { Putter(Q2); }
void Getter() {
usleep(100000);
Q1->Get();
Q2->Get();
MU2.Lock();
GLOB++;
MU2.Unlock();
usleep(48000); // TODO: remove this when FP in test32 is fixed.
}
void Run() {
printf("test38: negative\n");
Q1 = new ProducerConsumerQueue(INT_MAX);
Q2 = new ProducerConsumerQueue(INT_MAX);
MyThreadArray t(Getter, Getter, Putter1, Putter2);
t.Start();
t.Join();
printf("\tGLOB=%d\n", GLOB);
delete Q1;
delete Q2;
}
REGISTER_TEST(Run, 38);
} // namespace test38
namespace NegativeTests_Barrier { // {{{1
#ifndef NO_BARRIER
// Same as test17 but uses Barrier class (pthread_barrier_t).
int GLOB = 0;
const int N_threads = 3;
Barrier barrier(N_threads);
Mutex MU;
void Worker() {
MU.Lock();
GLOB++;
MU.Unlock();
barrier.Block();
CHECK(GLOB == N_threads);
}
TEST(NegativeTests, Barrier) {
ANNOTATE_TRACE_MEMORY(&GLOB);
{
ThreadPool pool(N_threads);
pool.StartWorkers();
for (int i = 0; i < N_threads; i++) {
pool.Add(NewCallback(Worker));
}
} // all folks are joined here.
CHECK(GLOB == 3);
}
#endif // NO_BARRIER
} // namespace test39
// test40: FP. Synchronization via Mutexes and PCQ. 4 threads. W/W {{{1
namespace test40 {
// Similar to test38 but with different order of events (due to sleep).
// Putter1: Putter2: Getter1: Getter2:
// MU1.Lock() MU1.Lock()
// write(GLOB) write(GLOB)
// MU1.Unlock() MU1.Unlock()
// Q1.Put() Q2.Put()
// Q1.Put() Q2.Put()
// Q1.Get() Q1.Get()
// Q2.Get() Q2.Get()
// MU2.Lock() MU2.Lock()
// write(GLOB) write(GLOB)
// MU2.Unlock() MU2.Unlock()
//
// MU1.Lock() MU1.Lock()
// MU2.Lock() MU2.Lock()
// write(GLOB) write(GLOB)
// MU2.Unlock() MU2.Unlock()
// MU1.Unlock() MU1.Unlock()
ProducerConsumerQueue *Q1, *Q2;
int GLOB = 0;
Mutex MU, MU1, MU2;
void Putter(ProducerConsumerQueue *q) {
MU1.Lock();
GLOB++;
MU1.Unlock();
q->Put(NULL);
q->Put(NULL);
usleep(100000);
MU1.Lock();
MU2.Lock();
GLOB++;
MU2.Unlock();
MU1.Unlock();
}
void Putter1() { Putter(Q1); }
void Putter2() { Putter(Q2); }
void Getter() {
Q1->Get();
Q2->Get();
MU2.Lock();
GLOB++;
MU2.Unlock();
usleep(48000); // TODO: remove this when FP in test32 is fixed.
}
void Run() {
// ANNOTATE_EXPECT_RACE(&GLOB, "test40. FP. Fixed by MSMProp1. Complex Stuff.");
printf("test40: negative\n");
Q1 = new ProducerConsumerQueue(INT_MAX);
Q2 = new ProducerConsumerQueue(INT_MAX);
MyThreadArray t(Getter, Getter, Putter1, Putter2);
t.Start();
t.Join();
printf("\tGLOB=%d\n", GLOB);
delete Q1;
delete Q2;
}
REGISTER_TEST(Run, 40);
} // namespace test40
// test41: TN. Test for race that appears when loading a dynamic symbol. {{{1
namespace test41 {
void Worker() {
ANNOTATE_NO_OP(NULL); // An empty function, loaded from dll.
}
void Run() {
printf("test41: negative\n");
MyThreadArray t(Worker, Worker, Worker);
t.Start();
t.Join();
}
REGISTER_TEST2(Run, 41, FEATURE|NEEDS_ANNOTATIONS);
} // namespace test41
// test42: TN. Using the same cond var several times. {{{1
namespace test42 {
int GLOB = 0;
int COND = 0;
int N_threads = 3;
Mutex MU;
void Worker1() {
GLOB=1;
MU.Lock();
COND = 1;
CV.Signal();
MU.Unlock();
MU.Lock();
while (COND != 0)
CV.Wait(&MU);
ANNOTATE_CONDVAR_LOCK_WAIT(&CV, &MU);
MU.Unlock();
GLOB=3;
}
void Worker2() {
MU.Lock();
while (COND != 1)
CV.Wait(&MU);
ANNOTATE_CONDVAR_LOCK_WAIT(&CV, &MU);
MU.Unlock();
GLOB=2;
MU.Lock();
COND = 0;
CV.Signal();
MU.Unlock();
}
void Run() {
// ANNOTATE_EXPECT_RACE(&GLOB, "test42. TN. debugging.");
printf("test42: negative\n");
MyThreadArray t(Worker1, Worker2);
t.Start();
t.Join();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST2(Run, 42, FEATURE|NEEDS_ANNOTATIONS);
} // namespace test42
// test43: TN. {{{1
namespace test43 {
//
// Putter: Getter:
// 1. write
// 2. Q.Put() --\ .
// 3. read \--> a. Q.Get()
// b. read
int GLOB = 0;
ProducerConsumerQueue Q(INT_MAX);
void Putter() {
GLOB = 1;
Q.Put(NULL);
CHECK(GLOB == 1);
}
void Getter() {
Q.Get();
usleep(100000);
CHECK(GLOB == 1);
}
void Run() {
printf("test43: negative\n");
MyThreadArray t(Putter, Getter);
t.Start();
t.Join();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST(Run, 43)
} // namespace test43
// test44: FP. {{{1
namespace test44 {
//
// Putter: Getter:
// 1. read
// 2. Q.Put() --\ .
// 3. MU.Lock() \--> a. Q.Get()
// 4. write
// 5. MU.Unlock()
// b. MU.Lock()
// c. write
// d. MU.Unlock();
int GLOB = 0;
Mutex MU;
ProducerConsumerQueue Q(INT_MAX);
void Putter() {
CHECK(GLOB == 0);
Q.Put(NULL);
MU.Lock();
GLOB = 1;
MU.Unlock();
}
void Getter() {
Q.Get();
usleep(100000);
MU.Lock();
GLOB = 1;
MU.Unlock();
}
void Run() {
// ANNOTATE_EXPECT_RACE(&GLOB, "test44. FP. Fixed by MSMProp1.");
printf("test44: negative\n");
MyThreadArray t(Putter, Getter);
t.Start();
t.Join();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST(Run, 44)
} // namespace test44
// test45: TN. {{{1
namespace test45 {
//
// Putter: Getter:
// 1. read
// 2. Q.Put() --\ .
// 3. MU.Lock() \--> a. Q.Get()
// 4. write
// 5. MU.Unlock()
// b. MU.Lock()
// c. read
// d. MU.Unlock();
int GLOB = 0;
Mutex MU;
ProducerConsumerQueue Q(INT_MAX);
void Putter() {
CHECK(GLOB == 0);
Q.Put(NULL);
MU.Lock();
GLOB++;
MU.Unlock();
}
void Getter() {
Q.Get();
usleep(100000);
MU.Lock();
CHECK(GLOB <= 1);
MU.Unlock();
}
void Run() {
printf("test45: negative\n");
MyThreadArray t(Putter, Getter);
t.Start();
t.Join();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST(Run, 45)
} // namespace test45
// test46: FN. {{{1
namespace test46 {
//
// First: Second:
// 1. write
// 2. MU.Lock()
// 3. write
// 4. MU.Unlock() (sleep)
// a. MU.Lock()
// b. write
// c. MU.Unlock();
int GLOB = 0;
Mutex MU;
void First() {
GLOB++;
MU.Lock();
GLOB++;
MU.Unlock();
}
void Second() {
usleep(480000);
MU.Lock();
GLOB++;
MU.Unlock();
// just a print.
// If we move it to Run() we will get report in MSMHelgrind
// due to its false positive (test32).
MU.Lock();
printf("\tGLOB=%d\n", GLOB);
MU.Unlock();
}
void Run() {
ANNOTATE_TRACE_MEMORY(&GLOB);
MyThreadArray t(First, Second);
t.Start();
t.Join();
}
REGISTER_TEST(Run, 46)
} // namespace test46
// test47: TP. Not detected by pure happens-before detectors. {{{1
namespace test47 {
// A true race that can not be detected by a pure happens-before
// race detector.
//
// First: Second:
// 1. write
// 2. MU.Lock()
// 3. MU.Unlock() (sleep)
// a. MU.Lock()
// b. MU.Unlock();
// c. write
int GLOB = 0;
Mutex MU;
void First() {
GLOB=1;
MU.Lock();
MU.Unlock();
}
void Second() {
usleep(480000);
MU.Lock();
MU.Unlock();
GLOB++;
}
void Run() {
if (!Tsan_PureHappensBefore())
ANNOTATE_EXPECT_RACE_FOR_TSAN(&GLOB, "test47. TP. Not detected by pure HB.");
printf("test47: positive\n");
MyThreadArray t(First, Second);
t.Start();
t.Join();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST(Run, 47)
} // namespace test47
// test48: FN. Simple race (single write vs multiple reads). {{{1
namespace test48 {
int GLOB = 0;
// same as test10 but with single writer and multiple readers
// A simple data race between single writer and multiple readers.
// Write happens before Reads (enforced by sleep(1)),
//
// Writer: Readers:
// 1. write(GLOB) a. sleep(long enough so that GLOB
// is most likely initialized by Writer)
// b. read(GLOB)
//
//
// Eraser algorithm does not detect the race here,
// see Section 2.2 of http://citeseer.ist.psu.edu/savage97eraser.html.
//
void Writer() {
GLOB = 3;
}
void Reader() {
usleep(100000);
CHECK(GLOB != -777);
}
void Run() {
ANNOTATE_EXPECT_RACE_FOR_TSAN(&GLOB, "test48. TP. FN in MSMHelgrind.");
printf("test48: positive\n");
MyThreadArray t(Writer, Reader,Reader,Reader);
t.Start();
t.Join();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST(Run, 48)
} // namespace test48
// test49: FN. Simple race (single write vs multiple reads). {{{1
namespace test49 {
int GLOB = 0;
// same as test10 but with multiple read operations done by a single reader
// A simple data race between writer and readers.
// Write happens before Read (enforced by sleep(1)),
//
// Writer: Reader:
// 1. write(GLOB) a. sleep(long enough so that GLOB
// is most likely initialized by Writer)
// b. read(GLOB)
// c. read(GLOB)
// d. read(GLOB)
// e. read(GLOB)
//
//
// Eraser algorithm does not detect the race here,
// see Section 2.2 of http://citeseer.ist.psu.edu/savage97eraser.html.
//
void Writer() {
GLOB = 3;
}
void Reader() {
usleep(100000);
CHECK(GLOB != -777);
CHECK(GLOB != -777);
CHECK(GLOB != -777);
CHECK(GLOB != -777);
}
void Run() {
ANNOTATE_EXPECT_RACE_FOR_TSAN(&GLOB, "test49. TP. FN in MSMHelgrind.");
printf("test49: positive\n");
MyThreadArray t(Writer, Reader);
t.Start();
t.Join();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST(Run, 49);
} // namespace test49
// test50: TP. Synchronization via CondVar. {{{1
namespace test50 {
int GLOB = 0;
Mutex MU;
// Two last write accesses to GLOB are not synchronized
//
// Waiter: Waker:
// 1. COND = 0
// 2. Start(Waker)
// 3. MU.Lock() a. write(GLOB)
// b. MU.Lock()
// c. COND = 1
// /--- d. CV.Signal()
// 4. while(COND != 1) / e. MU.Unlock()
// CV.Wait(MU) <---/
// 5. MU.Unlock()
// 6. write(GLOB) f. MU.Lock()
// g. write(GLOB)
// h. MU.Unlock()
void Waker() {
usleep(100000); // Make sure the waiter blocks.
GLOB = 1;
MU.Lock();
COND = 1;
CV.Signal();
MU.Unlock();
usleep(100000);
MU.Lock();
GLOB = 3;
MU.Unlock();
}
void Waiter() {
MU.Lock();
while(COND != 1)
CV.Wait(&MU);
ANNOTATE_CONDVAR_LOCK_WAIT(&CV, &MU);
MU.Unlock();
GLOB = 2;
}
void Run() {
printf("test50: positive\n");
COND = 0;
ANNOTATE_EXPECT_RACE_FOR_TSAN(&GLOB, "test50. TP.");
MyThreadArray t(Waker, Waiter);
t.Start();
t.Join();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST2(Run, 50, FEATURE|NEEDS_ANNOTATIONS);
} // namespace test50
// test51: TP. Synchronization via CondVar: problem with several signals. {{{1
namespace test51 {
int GLOB = 0;
int COND = 0;
Mutex MU;
StealthNotification n1, n2;
// scheduler dependent results because of several signals
// second signal will be lost
//
// Waiter: Waker:
// 1. Start(Waker)
// 2. MU.Lock()
// 3. while(COND)
// CV.Wait(MU)<-\ .
// 4. MU.Unlock() \ .
// 5. write(GLOB) \ a. write(GLOB)
// \ b. MU.Lock()
// \ c. COND = 1
// \--- d. CV.Signal()
// e. MU.Unlock()
//
// f. write(GLOB)
//
// g. MU.Lock()
// h. COND = 1
// LOST<---- i. CV.Signal()
// j. MU.Unlock()
void Waker() {
n1.wait(); // Make sure the waiter blocks.
GLOB = 1;
MU.Lock();
COND = 1;
CV.Signal();
MU.Unlock();
n2.wait(); // Make sure the waiter continued.
GLOB = 2;
MU.Lock();
COND = 1;
CV.Signal(); //Lost Signal
MU.Unlock();
}
void Waiter() {
MU.Lock();
n1.signal(); // Ready to get the first signal.
while(COND != 1)
CV.Wait(&MU);
MU.Unlock();
GLOB = 3;
n2.signal(); // Ready to miss the second signal.
}
void Run() {
ANNOTATE_EXPECT_RACE(&GLOB, "test51. TP.");
printf("test51: positive\n");
MyThreadArray t(Waiter, Waker);
t.Start();
t.Join();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST(Run, 51);
} // namespace test51
// test52: TP. Synchronization via CondVar: problem with several signals. {{{1
namespace test52 {
int GLOB = 0;
int COND = 0;
Mutex MU;
StealthNotification n1, n2;
// same as test51 but the first signal will be lost
// scheduler dependent results because of several signals
//
// Waiter: Waker:
// 1. Start(Waker)
// a. write(GLOB)
// b. MU.Lock()
// c. COND = 1
// LOST<---- d. CV.Signal()
// e. MU.Unlock()
//
// 2. MU.Lock()
// 3. while(COND)
// CV.Wait(MU)<-\ .
// 4. MU.Unlock() \ f. write(GLOB)
// 5. write(GLOB) \ .
// \ g. MU.Lock()
// \ h. COND = 1
// \--- i. CV.Signal()
// j. MU.Unlock()
void Waker() {
GLOB = 1;
MU.Lock();
COND = 1;
CV.Signal(); //lost signal
MU.Unlock();
n1.signal(); // Ok, now we may block.
n2.wait(); // We blocked.
GLOB = 2;
MU.Lock();
COND = 1;
CV.Signal();
MU.Unlock();
}
void Waiter() {
n1.wait(); // The first signal is lost.
MU.Lock();
n2.signal(); // The 2-nd signal may go.
while(COND != 1)
CV.Wait(&MU);
MU.Unlock();
GLOB = 3;
}
void Run() {
printf("test52: positive\n");
ANNOTATE_EXPECT_RACE(&GLOB, "test52. TP.");
MyThreadArray t(Waker, Waiter);
t.Start();
t.Join();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST(Run, 52);
} // namespace test52
// test53: FP. Synchronization via implicit semaphore. {{{1
namespace test53 {
// Correctly synchronized test, but the common lockset is empty.
// The variable FLAG works as an implicit semaphore.
// MSMHelgrind still does not complain since it does not maintain the lockset
// at the exclusive state. But MSMProp1 does complain.
// See also test54.
//
//
// Initializer: Users
// 1. MU1.Lock()
// 2. write(GLOB)
// 3. FLAG = true
// 4. MU1.Unlock()
// a. MU1.Lock()
// b. f = FLAG;
// c. MU1.Unlock()
// d. if (!f) goto a.
// e. MU2.Lock()
// f. write(GLOB)
// g. MU2.Unlock()
//
int GLOB = 0;
bool FLAG = false;
Mutex MU1, MU2;
void Initializer() {
MU1.Lock();
GLOB = 1000;
FLAG = true;
MU1.Unlock();
usleep(100000); // just in case
}
void User() {
bool f = false;
while(!f) {
MU1.Lock();
f = FLAG;
MU1.Unlock();
usleep(10000);
}
// at this point Initializer will not access GLOB again
MU2.Lock();
CHECK(GLOB >= 1000);
GLOB++;
MU2.Unlock();
}
void Run() {
if (!Tsan_PureHappensBefore())
ANNOTATE_EXPECT_RACE_FOR_TSAN(&GLOB, "test53. FP. Implicit semaphore");
printf("test53: FP. false positive, Implicit semaphore\n");
MyThreadArray t(Initializer, User, User);
t.Start();
t.Join();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST(Run, 53)
} // namespace test53
// test54: TN. Synchronization via implicit semaphore. Annotated {{{1
namespace test54 {
// Same as test53, but annotated.
int GLOB = 0;
bool FLAG = false;
Mutex MU1, MU2;
void Initializer() {
MU1.Lock();
GLOB = 1000;
FLAG = true;
ANNOTATE_CONDVAR_SIGNAL(&GLOB);
MU1.Unlock();
usleep(100000); // just in case
}
void User() {
bool f = false;
while(!f) {
MU1.Lock();
f = FLAG;
MU1.Unlock();
usleep(10000);
}
// at this point Initializer will not access GLOB again
ANNOTATE_CONDVAR_WAIT(&GLOB);
MU2.Lock();
CHECK(GLOB >= 1000);
GLOB++;
MU2.Unlock();
}
void Run() {
printf("test54: negative\n");
MyThreadArray t(Initializer, User, User);
t.Start();
t.Join();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST2(Run, 54, FEATURE|NEEDS_ANNOTATIONS)
} // namespace test54
// test55: FP. Synchronization with TryLock. Not easy for race detectors {{{1
namespace test55 {
// "Correct" synchronization with TryLock and Lock.
//
// This scheme is actually very risky.
// It is covered in detail in this video:
// http://youtube.com/watch?v=mrvAqvtWYb4 (slide 36, near 50-th minute).
int GLOB = 0;
Mutex MU;
void Worker_Lock() {
GLOB = 1;
MU.Lock();
}
void Worker_TryLock() {
while (true) {
if (!MU.TryLock()) {
MU.Unlock();
break;
}
else
MU.Unlock();
usleep(100);
}
GLOB = 2;
}
void Run() {
printf("test55:\n");
MyThreadArray t(Worker_Lock, Worker_TryLock);
t.Start();
t.Join();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST2(Run, 55, FEATURE|EXCLUDE_FROM_ALL);
} // namespace test55
// test56: TP. Use of ANNOTATE_BENIGN_RACE. {{{1
namespace test56 {
// For whatever reason the user wants to treat
// a race on GLOB as a benign race.
int GLOB = 0;
int GLOB2 = 0;
void Worker() {
GLOB++;
}
void Run() {
ANNOTATE_BENIGN_RACE(&GLOB, "test56. Use of ANNOTATE_BENIGN_RACE.");
ANNOTATE_BENIGN_RACE(&GLOB2, "No race. The tool should be silent");
printf("test56: positive\n");
MyThreadArray t(Worker, Worker, Worker, Worker);
t.Start();
t.Join();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST2(Run, 56, FEATURE|NEEDS_ANNOTATIONS)
} // namespace test56
// test57: TN: Correct use of atomics. {{{1
namespace test57 {
int GLOB = 0;
void Writer() {
for (int i = 0; i < 10; i++) {
AtomicIncrement(&GLOB, 1);
usleep(1000);
}
}
void Reader() {
while (GLOB < 20) usleep(1000);
}
void Run() {
printf("test57: negative\n");
MyThreadArray t(Writer, Writer, Reader, Reader);
t.Start();
t.Join();
CHECK(GLOB == 20);
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST(Run, 57)
} // namespace test57
// test58: TN. User defined synchronization. {{{1
namespace test58 {
int GLOB1 = 1;
int GLOB2 = 2;
int FLAG1 = 0;
int FLAG2 = 0;
// Correctly synchronized test, but the common lockset is empty.
// The variables FLAG1 and FLAG2 used for synchronization and as
// temporary variables for swapping two global values.
// Such kind of synchronization is rarely used (Excluded from all tests??).
void Worker2() {
FLAG1=GLOB2;
while(!FLAG2)
;
GLOB2=FLAG2;
}
void Worker1() {
FLAG2=GLOB1;
while(!FLAG1)
;
GLOB1=FLAG1;
}
void Run() {
printf("test58:\n");
MyThreadArray t(Worker1, Worker2);
t.Start();
t.Join();
printf("\tGLOB1=%d\n", GLOB1);
printf("\tGLOB2=%d\n", GLOB2);
}
REGISTER_TEST2(Run, 58, FEATURE|EXCLUDE_FROM_ALL)
} // namespace test58
// test59: TN. User defined synchronization. Annotated {{{1
namespace test59 {
int COND1 = 0;
int COND2 = 0;
int GLOB1 = 1;
int GLOB2 = 2;
int FLAG1 = 0;
int FLAG2 = 0;
// same as test 58 but annotated
void Worker2() {
FLAG1=GLOB2;
ANNOTATE_CONDVAR_SIGNAL(&COND2);
while(!FLAG2) usleep(1);
ANNOTATE_CONDVAR_WAIT(&COND1);
GLOB2=FLAG2;
}
void Worker1() {
FLAG2=GLOB1;
ANNOTATE_CONDVAR_SIGNAL(&COND1);
while(!FLAG1) usleep(1);
ANNOTATE_CONDVAR_WAIT(&COND2);
GLOB1=FLAG1;
}
void Run() {
printf("test59: negative\n");
ANNOTATE_BENIGN_RACE(&FLAG1, "synchronization via 'safe' race");
ANNOTATE_BENIGN_RACE(&FLAG2, "synchronization via 'safe' race");
MyThreadArray t(Worker1, Worker2);
t.Start();
t.Join();
printf("\tGLOB1=%d\n", GLOB1);
printf("\tGLOB2=%d\n", GLOB2);
}
REGISTER_TEST2(Run, 59, FEATURE|NEEDS_ANNOTATIONS)
} // namespace test59
// test60: TN. Correct synchronization using signal-wait {{{1
namespace test60 {
int COND1 = 0;
int COND2 = 0;
int GLOB1 = 1;
int GLOB2 = 2;
int FLAG2 = 0;
int FLAG1 = 0;
Mutex MU;
// same as test 59 but synchronized with signal-wait.
void Worker2() {
FLAG1=GLOB2;
MU.Lock();
COND1 = 1;
CV.Signal();
MU.Unlock();
MU.Lock();
while(COND2 != 1)
CV.Wait(&MU);
ANNOTATE_CONDVAR_LOCK_WAIT(&CV, &MU);
MU.Unlock();
GLOB2=FLAG2;
}
void Worker1() {
FLAG2=GLOB1;
MU.Lock();
COND2 = 1;
CV.Signal();
MU.Unlock();
MU.Lock();
while(COND1 != 1)
CV.Wait(&MU);
ANNOTATE_CONDVAR_LOCK_WAIT(&CV, &MU);
MU.Unlock();
GLOB1=FLAG1;
}
void Run() {
printf("test60: negative\n");
MyThreadArray t(Worker1, Worker2);
t.Start();
t.Join();
printf("\tGLOB1=%d\n", GLOB1);
printf("\tGLOB2=%d\n", GLOB2);
}
REGISTER_TEST2(Run, 60, FEATURE|NEEDS_ANNOTATIONS)
} // namespace test60
// test61: TN. Synchronization via Mutex as in happens-before, annotated. {{{1
namespace test61 {
Mutex MU;
int GLOB = 0;
int *P1 = NULL, *P2 = NULL;
// In this test Mutex lock/unlock operations introduce happens-before relation.
// We annotate the code so that MU is treated as in pure happens-before detector.
void Putter() {
ANNOTATE_PURE_HAPPENS_BEFORE_MUTEX(&MU);
MU.Lock();
if (P1 == NULL) {
P1 = &GLOB;
*P1 = 1;
}
MU.Unlock();
}
void Getter() {
bool done = false;
while (!done) {
MU.Lock();
if (P1) {
done = true;
P2 = P1;
P1 = NULL;
}
MU.Unlock();
}
*P2 = 2;
}
void Run() {
printf("test61: negative\n");
MyThreadArray t(Putter, Getter);
t.Start();
t.Join();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST2(Run, 61, FEATURE|NEEDS_ANNOTATIONS)
} // namespace test61
// test62: STAB. Create as many segments as possible. {{{1
namespace test62 {
// Helgrind 3.3.0 will fail as it has a hard limit of < 2^24 segments.
// A better scheme is to implement garbage collection for segments.
ProducerConsumerQueue Q(INT_MAX);
const int N = 1 << 22;
void Putter() {
for (int i = 0; i < N; i++){
if ((i % (N / 8)) == 0) {
printf("i=%d\n", i);
}
Q.Put(NULL);
}
}
void Getter() {
for (int i = 0; i < N; i++)
Q.Get();
}
void Run() {
printf("test62:\n");
MyThreadArray t(Putter, Getter);
t.Start();
t.Join();
}
REGISTER_TEST2(Run, 62, STABILITY|EXCLUDE_FROM_ALL)
} // namespace test62
// test63: STAB. Create as many segments as possible and do it fast. {{{1
namespace test63 {
// Helgrind 3.3.0 will fail as it has a hard limit of < 2^24 segments.
// A better scheme is to implement garbage collection for segments.
const int N = 1 << 24;
int C = 0;
void Putter() {
for (int i = 0; i < N; i++){
if ((i % (N / 8)) == 0) {
printf("i=%d\n", i);
}
ANNOTATE_CONDVAR_SIGNAL(&C);
}
}
void Getter() {
}
void Run() {
printf("test63:\n");
MyThreadArray t(Putter, Getter);
t.Start();
t.Join();
}
REGISTER_TEST2(Run, 63, STABILITY|EXCLUDE_FROM_ALL)
} // namespace test63
// test64: TP. T2 happens-before T3, but T1 is independent. Reads in T1/T2. {{{1
namespace test64 {
// True race between T1 and T3:
//
// T1: T2: T3:
// 1. read(GLOB) (sleep)
// a. read(GLOB)
// b. Q.Put() -----> A. Q.Get()
// B. write(GLOB)
//
//
int GLOB = 0;
ProducerConsumerQueue Q(INT_MAX);
void T1() {
CHECK(GLOB == 0);
}
void T2() {
usleep(100000);
CHECK(GLOB == 0);
Q.Put(NULL);
}
void T3() {
Q.Get();
GLOB = 1;
}
void Run() {
ANNOTATE_EXPECT_RACE_FOR_TSAN(&GLOB, "test64: TP.");
printf("test64: positive\n");
MyThreadArray t(T1, T2, T3);
t.Start();
t.Join();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST(Run, 64)
} // namespace test64
// test65: TP. T2 happens-before T3, but T1 is independent. Writes in T1/T2. {{{1
namespace test65 {
// Similar to test64.
// True race between T1 and T3:
//
// T1: T2: T3:
// 1. MU.Lock()
// 2. write(GLOB)
// 3. MU.Unlock() (sleep)
// a. MU.Lock()
// b. write(GLOB)
// c. MU.Unlock()
// d. Q.Put() -----> A. Q.Get()
// B. write(GLOB)
//
//
int GLOB = 0;
Mutex MU;
ProducerConsumerQueue Q(INT_MAX);
void T1() {
MU.Lock();
GLOB++;
MU.Unlock();
}
void T2() {
usleep(100000);
MU.Lock();
GLOB++;
MU.Unlock();
Q.Put(NULL);
}
void T3() {
Q.Get();
GLOB = 1;
}
void Run() {
if (!Tsan_PureHappensBefore())
ANNOTATE_EXPECT_RACE_FOR_TSAN(&GLOB, "test65. TP.");
printf("test65: positive\n");
MyThreadArray t(T1, T2, T3);
t.Start();
t.Join();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST(Run, 65)
} // namespace test65
// test66: TN. Two separate pairs of signaller/waiter using the same CV. {{{1
namespace test66 {
int GLOB1 = 0;
int GLOB2 = 0;
int C1 = 0;
int C2 = 0;
Mutex MU;
void Signaller1() {
GLOB1 = 1;
MU.Lock();
C1 = 1;
CV.Signal();
MU.Unlock();
}
void Signaller2() {
GLOB2 = 1;
usleep(100000);
MU.Lock();
C2 = 1;
CV.Signal();
MU.Unlock();
}
void Waiter1() {
MU.Lock();
while (C1 != 1) CV.Wait(&MU);
ANNOTATE_CONDVAR_WAIT(&CV);
MU.Unlock();
GLOB1 = 2;
}
void Waiter2() {
MU.Lock();
while (C2 != 1) CV.Wait(&MU);
ANNOTATE_CONDVAR_WAIT(&CV);
MU.Unlock();
GLOB2 = 2;
}
void Run() {
printf("test66: negative\n");
MyThreadArray t(Signaller1, Signaller2, Waiter1, Waiter2);
t.Start();
t.Join();
printf("\tGLOB=%d/%d\n", GLOB1, GLOB2);
}
REGISTER_TEST2(Run, 66, FEATURE|NEEDS_ANNOTATIONS)
} // namespace test66
// test67: FN. Race between Signaller1 and Waiter2 {{{1
namespace test67 {
// Similar to test66, but there is a real race here.
//
// Here we create a happens-before arc between Signaller1 and Waiter2
// even though there should be no such arc.
// However, it's probably improssible (or just very hard) to avoid it.
int GLOB = 0;
int C1 = 0;
int C2 = 0;
Mutex MU;
void Signaller1() {
GLOB = 1;
MU.Lock();
C1 = 1;
CV.Signal();
MU.Unlock();
}
void Signaller2() {
usleep(100000);
MU.Lock();
C2 = 1;
CV.Signal();
MU.Unlock();
}
void Waiter1() {
MU.Lock();
while (C1 != 1) CV.Wait(&MU);
ANNOTATE_CONDVAR_WAIT(&CV);
MU.Unlock();
}
void Waiter2() {
MU.Lock();
while (C2 != 1) CV.Wait(&MU);
ANNOTATE_CONDVAR_WAIT(&CV);
MU.Unlock();
GLOB = 2;
}
void Run() {
ANNOTATE_EXPECT_RACE(&GLOB, "test67. FN. Race between Signaller1 and Waiter2");
printf("test67: positive\n");
MyThreadArray t(Signaller1, Signaller2, Waiter1, Waiter2);
t.Start();
t.Join();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST2(Run, 67, FEATURE|NEEDS_ANNOTATIONS|EXCLUDE_FROM_ALL)
} // namespace test67
// test68: TP. Writes are protected by MU, reads are not. {{{1
namespace test68 {
// In this test, all writes to GLOB are protected by a mutex
// but some reads go unprotected.
// This is certainly a race, but in some cases such code could occur in
// a correct program. For example, the unprotected reads may be used
// for showing statistics and are not required to be precise.
int GLOB = 0;
int COND = 0;
const int N_writers = 3;
Mutex MU, MU1;
void Writer() {
for (int i = 0; i < 100; i++) {
MU.Lock();
GLOB++;
MU.Unlock();
}
// we are done
MU1.Lock();
COND++;
MU1.Unlock();
}
void Reader() {
bool cont = true;
while (cont) {
CHECK(GLOB >= 0);
// are we done?
MU1.Lock();
if (COND == N_writers)
cont = false;
MU1.Unlock();
usleep(100);
}
}
void Run() {
ANNOTATE_EXPECT_RACE(&GLOB, "TP. Writes are protected, reads are not.");
printf("test68: positive\n");
MyThreadArray t(Reader, Writer, Writer, Writer);
t.Start();
t.Join();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST(Run, 68)
} // namespace test68
// test69: {{{1
namespace test69 {
// This is the same as test68, but annotated.
// We do not want to annotate GLOB as a benign race
// because we want to allow racy reads only in certain places.
//
// TODO:
int GLOB = 0;
int COND = 0;
const int N_writers = 3;
int FAKE_MU = 0;
Mutex MU, MU1;
void Writer() {
for (int i = 0; i < 10; i++) {
MU.Lock();
GLOB++;
MU.Unlock();
}
// we are done
MU1.Lock();
COND++;
MU1.Unlock();
}
void Reader() {
bool cont = true;
while (cont) {
ANNOTATE_IGNORE_READS_BEGIN();
CHECK(GLOB >= 0);
ANNOTATE_IGNORE_READS_END();
// are we done?
MU1.Lock();
if (COND == N_writers)
cont = false;
MU1.Unlock();
usleep(100);
}
}
void Run() {
printf("test69: negative\n");
MyThreadArray t(Reader, Writer, Writer, Writer);
t.Start();
t.Join();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST(Run, 69)
} // namespace test69
// test70: STAB. Check that TRACE_MEMORY works. {{{1
namespace test70 {
int GLOB = 0;
void Run() {
printf("test70: negative\n");
ANNOTATE_TRACE_MEMORY(&GLOB);
GLOB = 1;
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST(Run, 70)
} // namespace test70
namespace NegativeTests_Strlen { // {{{1
// This test is a reproducer for a benign race in strlen (as well as index, etc).
// Some implementations of strlen may read up to 7 bytes past the end of the string
// thus touching memory which may not belong to this string.
// Such race is benign because the data read past the end of the string is not used.
//
// Here, we allocate a 8-byte aligned string str and initialize first 5 bytes.
// Then one thread calls strlen(str) (as well as index & rindex)
// and another thread initializes str[5]..str[7].
//
// This can be fixed in Helgrind by intercepting strlen and replacing it
// with a simpler implementation.
char *str;
char *tmp2;
void WorkerX() {
usleep(100000);
ASSERT_TRUE(strlen(str) == 4);
#ifndef WIN32
EXPECT_TRUE(index(str, 'X') == str);
EXPECT_TRUE(index(str, 'x') == str+1);
EXPECT_TRUE(index(str, 'Y') == NULL);
#ifndef ANDROID
EXPECT_TRUE(rindex(str, 'X') == str+2);
EXPECT_TRUE(rindex(str, 'x') == str+3);
EXPECT_TRUE(rindex(str, 'Y') == NULL);
#endif
#else
EXPECT_TRUE(lstrlenA(NULL) == 0);
EXPECT_TRUE(lstrlenW(NULL) == 0);
#endif
EXPECT_TRUE(strchr(str, 'X') == str);
EXPECT_TRUE(strchr(str, 'x') == str+1);
EXPECT_TRUE(strchr(str, 'Y') == NULL);
EXPECT_TRUE(memchr(str, 'X', 8) == str);
EXPECT_TRUE(memchr(str, 'x', 8) == str+1);
char tmp[100] = "Zzz";
EXPECT_TRUE(memmove(tmp, str, strlen(str) + 1) == tmp);
EXPECT_TRUE(strcmp(tmp,str) == 0);
EXPECT_TRUE(strncmp(tmp,str, 4) == 0);
EXPECT_TRUE(memmove(str, tmp, strlen(tmp) + 1) == str);
#ifndef WIN32
#ifndef ANDROID
EXPECT_TRUE(stpcpy(tmp2, str) == tmp2+4);
#endif
EXPECT_TRUE(strcpy(tmp2, str) == tmp2);
EXPECT_TRUE(strncpy(tmp, str, 4) == tmp);
// These may not be properly intercepted since gcc -O1 may inline
// strcpy/stpcpy in presence of a statically sized array. Damn.
// EXPECT_TRUE(stpcpy(tmp, str) == tmp+4);
// EXPECT_TRUE(strcpy(tmp, str) == tmp);
#endif
EXPECT_TRUE(strrchr(str, 'X') == str+2);
EXPECT_TRUE(strrchr(str, 'x') == str+3);
EXPECT_TRUE(strrchr(str, 'Y') == NULL);
}
void WorkerY() {
str[5] = 'Y';
str[6] = 'Y';
str[7] = '\0';
}
TEST(NegativeTests, StrlenAndFriends) {
str = new char[8];
tmp2 = new char[8];
str[0] = 'X';
str[1] = 'x';
str[2] = 'X';
str[3] = 'x';
str[4] = '\0';
MyThread t1(WorkerY);
MyThread t2(WorkerX);
t1.Start();
t2.Start();
t1.Join();
t2.Join();
ASSERT_STREQ("XxXx", str);
ASSERT_STREQ("YY", str+5);
char foo[8] = {10, 20, 127, (char)128, (char)250, -50, 0};
EXPECT_TRUE(strchr(foo, 10) != 0);
EXPECT_TRUE(strchr(foo, 127) != 0);
EXPECT_TRUE(strchr(foo, 128) != 0);
EXPECT_TRUE(strchr(foo, 250) != 0);
EXPECT_TRUE(strchr(foo, -50) != 0);
EXPECT_TRUE(strchr(foo, -60) == 0);
EXPECT_TRUE(strchr(foo, 0) != 0);
EXPECT_TRUE(strchr(foo, 0) == foo + strlen(foo));
EXPECT_TRUE(strrchr(foo, 10) != 0);
EXPECT_TRUE(strrchr(foo, 0) != 0);
EXPECT_TRUE(strrchr(foo, 0) == foo + strlen(foo));
EXPECT_TRUE(strrchr(foo, 250) != 0);
EXPECT_TRUE(strrchr(foo, -60) == 0);
delete [] str;
delete [] tmp2;
// TODO(kcc): add more tests to check that interceptors are correct.
}
} // namespace test71
namespace NegativeTests_EmptyRep { // {{{1
void Worker() {
string s;
s.erase();
}
TEST(NegativeTests, DISABLED_EmptyRepTest) {
// This is a test for the reports on an internal race in std::string implementation.
// See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=40518
// ThreadSanitizer should be silent on this, but currently it is silent
// only on Valgrind/Linux.
MyThreadArray mta(Worker, Worker);
mta.Start();
mta.Join();
}
} //namespace NegativeTests_EmptyRep
namespace NegativeTests_StdStringDtor { // {{{1
// Some implementations of std::string (including the one on Linux)
// are unfriendly to race detectors since they use atomic reference counting
// in a way that race detectors can not understand.
//
// See http://code.google.com/p/data-race-test/issues/detail?id=40
string *s = NULL;
BlockingCounter *counter = NULL;
void DestroyWorker() {
string x = *s; // force string copy (increments ref count).
counter->DecrementCount();
// x is destructed, ref count is decremented.
}
void AssignWorker() {
string x = *s; // force string copy (increments ref count).
counter->DecrementCount();
// x is assigned, the ref count is decremented.
usleep(100000);
x = "ZZZ";
}
TEST(NegativeTests, StdStringDtorVsDtor) {
MyThreadArray mta(DestroyWorker, DestroyWorker, DestroyWorker);
counter = new BlockingCounter(3);
s = new string ("foo");
mta.Start();
counter->Wait();
delete s; // ref count becomes zero and the object is destroyed.
mta.Join();
delete counter;
}
TEST(NegativeTests, DISABLED_StdStringDtorVsAssign) {
MyThreadArray mta(AssignWorker, AssignWorker, AssignWorker);
counter = new BlockingCounter(3);
s = new string ("foo");
mta.Start();
counter->Wait();
delete s; // ref count becomes zero and the object is destroyed.
mta.Join();
delete counter;
}
} //namespace NegativeTests_EmptyRep
namespace PositiveTests_MutexDtorNoSync {
// Check that Mutex::~Mutex() doesn't introduce h-b arcs.
int *GLOB = NULL;
void WriteThenScopedLocalMutex() {
*GLOB = 1;
{
Mutex l;
}
}
void ScopedLocalMutexThenWrite() {
{
Mutex l;
}
*GLOB = 2;
}
TEST(PositiveTests, MutexDtorNoSyncTest) {
GLOB = new int(0);
ANNOTATE_EXPECT_RACE(GLOB, "TP: PositiveTests.MutexDtorNoSyncTest");
MyThreadArray t(WriteThenScopedLocalMutex,
ScopedLocalMutexThenWrite);
t.Start();
t.Join();
delete GLOB;
}
void WriteThenScopedLocalMutexLockUnlock() {
*GLOB = 1;
{
Mutex l;
l.Lock();
l.Unlock();
}
}
void ScopedLocalMutexLockUnlockThenWrite() {
{
Mutex l;
l.Lock();
l.Unlock();
}
*GLOB = 2;
}
TEST(PositiveTests, MutexDtorNoSyncTest2) {
GLOB = new int(0);
ANNOTATE_EXPECT_RACE(GLOB, "TP: PositiveTests.MutexDtorNoSyncTest2");
MyThreadArray t(WriteThenScopedLocalMutexLockUnlock,
ScopedLocalMutexLockUnlockThenWrite);
t.Start();
t.Join();
delete GLOB;
}
} // namespace PositiveTests_MutexDtorSync
namespace PositiveTests_FprintfThreadCreateTest {
// Check that fprintf doesn't introduce h-b with the start of the
// following thread
int *GLOB;
StealthNotification *n;
void Worker1() {
*GLOB = 1;
fprintf(stdout, "Hello, world!\n");
n->signal();
}
void Worker2() {
*GLOB = 2;
}
#if !defined(_MSC_VER)
// TODO(timurrrr): investigate Windows FN and un-#if
TEST(PositiveTests, FprintfThreadCreateTest) {
GLOB = new int;
ANNOTATE_EXPECT_RACE(GLOB, "TP: PositiveTests.FprintfThreadCreateTest");
n = new StealthNotification;
MyThread t1(Worker1);
t1.Start();
n->wait();
MyThread t2(Worker2);
t2.Start();
t2.Join();
t1.Join();
delete n;
delete GLOB;
}
#endif
} // namespace PositiveTests_FprintfThreadCreateTest
// test72: STAB. Stress test for the number of segment sets (SSETs). {{{1
namespace test72 {
#ifndef NO_BARRIER
// Variation of test33.
// Instead of creating Nlog*N_iter threads,
// we create Nlog threads and do N_iter barriers.
int GLOB = 0;
const int N_iter = 30;
const int Nlog = 16;
const int N = 1 << Nlog;
static int64_t ARR1[N];
static int64_t ARR2[N];
Barrier *barriers[N_iter];
Mutex MU;
void Worker() {
MU.Lock();
int n = ++GLOB;
MU.Unlock();
n %= Nlog;
for (int it = 0; it < N_iter; it++) {
// Iterate N_iter times, block on barrier after each iteration.
// This way Helgrind will create new segments after each barrier.
for (int x = 0; x < 2; x++) {
// run the inner loop twice.
// When a memory location is accessed second time it is likely
// that the state (SVal) will be unchanged.
// The memory machine may optimize this case.
for (int i = 0; i < N; i++) {
// ARR1[i] and ARR2[N-1-i] are accessed by threads from i-th subset
if (i & (1 << n)) {
CHECK(ARR1[i] == 0);
CHECK(ARR2[N-1-i] == 0);
}
}
}
barriers[it]->Block();
}
}
void Run() {
printf("test72:\n");
std::vector<MyThread*> vec(Nlog);
for (int i = 0; i < N_iter; i++)
barriers[i] = new Barrier(Nlog);
// Create and start Nlog threads
for (int i = 0; i < Nlog; i++) {
vec[i] = new MyThread(Worker);
vec[i]->Start();
}
// Join all threads.
for (int i = 0; i < Nlog; i++) {
vec[i]->Join();
delete vec[i];
}
for (int i = 0; i < N_iter; i++)
delete barriers[i];
/*printf("\tGLOB=%d; ARR[1]=%d; ARR[7]=%d; ARR[N-1]=%d\n",
GLOB, (int)ARR1[1], (int)ARR1[7], (int)ARR1[N-1]);*/
}
REGISTER_TEST2(Run, 72, STABILITY|PERFORMANCE|EXCLUDE_FROM_ALL);
#endif // NO_BARRIER
} // namespace test72
// test73: STAB. Stress test for the number of (SSETs), different access sizes. {{{1
namespace test73 {
#ifndef NO_BARRIER
// Variation of test72.
// We perform accesses of different sizes to the same location.
int GLOB = 0;
const int N_iter = 2;
const int Nlog = 16;
const int N = 1 << Nlog;
static int64_t ARR1[N];
static int ARR2[N];
Barrier *barriers[N_iter];
Mutex MU;
void Worker() {
MU.Lock();
int n = ++GLOB;
MU.Unlock();
n %= Nlog;
for (int it = 0; it < N_iter; it++) {
// Iterate N_iter times, block on barrier after each iteration.
// This way Helgrind will create new segments after each barrier.
for (int x = 0; x < 4; x++) {
for (int i = 0; i < N; i++) {
// ARR1[i] are accessed by threads from i-th subset
if (i & (1 << n)) {
for (int off = 0; off < (1 << x); off++) {
switch(x) {
case 0: CHECK( ARR1 [i * (1<<x) + off] == 0); break;
case 1: CHECK(((int*) (ARR1))[i * (1<<x) + off] == 0); break;
case 2: CHECK(((short*)(ARR1))[i * (1<<x) + off] == 0); break;
case 3: CHECK(((char*) (ARR1))[i * (1<<x) + off] == 0); break;
}
switch(x) {
case 1: CHECK(((int*) (ARR2))[i * (1<<x) + off] == 0); break;
case 2: CHECK(((short*)(ARR2))[i * (1<<x) + off] == 0); break;
case 3: CHECK(((char*) (ARR2))[i * (1<<x) + off] == 0); break;
}
}
}
}
}
barriers[it]->Block();
}
}
void Run() {
printf("test73:\n");
std::vector<MyThread*> vec(Nlog);
for (int i = 0; i < N_iter; i++)
barriers[i] = new Barrier(Nlog);
// Create and start Nlog threads
for (int i = 0; i < Nlog; i++) {
vec[i] = new MyThread(Worker);
vec[i]->Start();
}
// Join all threads.
for (int i = 0; i < Nlog; i++) {
vec[i]->Join();
delete vec[i];
}
for (int i = 0; i < N_iter; i++)
delete barriers[i];
/*printf("\tGLOB=%d; ARR[1]=%d; ARR[7]=%d; ARR[N-1]=%d\n",
GLOB, (int)ARR1[1], (int)ARR1[7], (int)ARR1[N-1]);*/
}
REGISTER_TEST2(Run, 73, STABILITY|PERFORMANCE|EXCLUDE_FROM_ALL);
#endif // NO_BARRIER
} // namespace test73
// test74: PERF. A lot of lock/unlock calls. {{{1
namespace test74 {
const int N = 100000;
Mutex MU;
TEST(StressTests, ManyLocksUnlocks) {
for (int i = 0; i < N; i++ ) {
MU.Lock();
MU.Unlock();
}
}
} // namespace test74
// RefCountedClass {{{1
struct RefCountedClass {
public:
RefCountedClass() {
annotate_unref_ = false;
ref_ = 0;
data_ = 0;
}
~RefCountedClass() {
CHECK(ref_ == 0); // race may be reported here
int data_val = data_; // and here
// if MU is not annotated
data_ = 0;
ref_ = -1;
printf("\tRefCountedClass::data_ = %d\n", data_val);
}
void AccessData() {
this->mu_.Lock();
this->data_++;
this->mu_.Unlock();
}
void Ref() {
MU.Lock();
CHECK(ref_ >= 0);
ref_++;
MU.Unlock();
}
void Unref() {
MU.Lock();
CHECK(ref_ > 0);
ref_--;
bool do_delete = ref_ == 0;
if (annotate_unref_) {
ANNOTATE_HAPPENS_BEFORE(this);
}
MU.Unlock();
if (do_delete) {
if (annotate_unref_) {
ANNOTATE_HAPPENS_AFTER(this);
}
delete this;
}
}
static void Annotate_MU() {
ANNOTATE_PURE_HAPPENS_BEFORE_MUTEX(&MU);
}
void AnnotateUnref() {
annotate_unref_ = true;
}
void Annotate_Race() {
ANNOTATE_BENIGN_RACE_SIZED(this, sizeof(*this), "needs annotation");
}
private:
bool annotate_unref_;
int data_;
Mutex mu_; // protects data_
int ref_;
static Mutex MU; // protects ref_
};
Mutex RefCountedClass::MU;
// test76: FP. Ref counting, no annotations. {{{1
namespace test76 {
#ifndef NO_BARRIER
int GLOB = 0;
Barrier barrier(4);
RefCountedClass *object = NULL;
void Worker() {
object->Ref();
barrier.Block();
object->AccessData();
object->Unref();
}
void Run() {
printf("test76: false positive (ref counting)\n");
object = new RefCountedClass;
object->Annotate_Race();
MyThreadArray t(Worker, Worker, Worker, Worker);
t.Start();
t.Join();
}
REGISTER_TEST2(Run, 76, FEATURE)
#endif // NO_BARRIER
} // namespace test76
// test77: TN. Ref counting, MU is annotated. {{{1
namespace test77 {
#ifndef NO_BARRIER
// same as test76, but RefCountedClass::MU is annotated.
int GLOB = 0;
Barrier barrier(4);
RefCountedClass *object = NULL;
void Worker() {
object->Ref();
barrier.Block();
object->AccessData();
object->Unref();
}
void Run() {
printf("test77: true negative (ref counting), mutex is annotated\n");
RefCountedClass::Annotate_MU();
object = new RefCountedClass;
MyThreadArray t(Worker, Worker, Worker, Worker);
t.Start();
t.Join();
}
REGISTER_TEST(Run, 77)
#endif // NO_BARRIER
} // namespace test77
// test78: TN. Ref counting, Unref is annotated. {{{1
namespace test78 {
#ifndef NO_BARRIER
// same as test76, but RefCountedClass::Unref is annotated.
int GLOB = 0;
Barrier barrier(4);
RefCountedClass *object = NULL;
void Worker() {
object->Ref();
barrier.Block();
object->AccessData();
object->Unref();
}
void Run() {
printf("test78: true negative (ref counting), Unref is annotated\n");
RefCountedClass::Annotate_MU();
object = new RefCountedClass;
MyThreadArray t(Worker, Worker, Worker, Worker);
t.Start();
t.Join();
}
REGISTER_TEST(Run, 78)
#endif // NO_BARRIER
} // namespace test78
// test79 TN. Swap. {{{1
namespace test79 {
#if 0
typedef __gnu_cxx::hash_map<int, int> map_t;
#else
typedef std::map<int, int> map_t;
#endif
map_t MAP;
Mutex MU;
// Here we use swap to pass MAP between threads.
// The synchronization is correct, but w/o ANNOTATE_PURE_HAPPENS_BEFORE_MUTEX
// Helgrind will complain.
void Worker1() {
map_t tmp;
MU.Lock();
// We swap the new empty map 'tmp' with 'MAP'.
MAP.swap(tmp);
MU.Unlock();
// tmp (which is the old version of MAP) is destroyed here.
}
void Worker2() {
MU.Lock();
MAP[1]++; // Just update MAP under MU.
MU.Unlock();
}
void Worker3() { Worker1(); }
void Worker4() { Worker2(); }
void Run() {
ANNOTATE_PURE_HAPPENS_BEFORE_MUTEX(&MU);
printf("test79: negative\n");
MyThreadArray t(Worker1, Worker2, Worker3, Worker4);
t.Start();
t.Join();
}
REGISTER_TEST(Run, 79)
} // namespace test79
// AtomicRefCountedClass. {{{1
// Same as RefCountedClass, but using atomic ops instead of mutex.
struct AtomicRefCountedClass {
public:
AtomicRefCountedClass() {
annotate_unref_ = false;
ref_ = 0;
data_ = 0;
}
~AtomicRefCountedClass() {
CHECK(ref_ == 0); // race may be reported here
int data_val = data_; // and here
data_ = 0;
ref_ = -1;
printf("\tRefCountedClass::data_ = %d\n", data_val);
}
void AccessData() {
this->mu_.Lock();
this->data_++;
this->mu_.Unlock();
}
void Ref() {
AtomicIncrement(&ref_, 1);
}
void Unref() {
// DISCLAIMER: I am not sure I've implemented this correctly
// (might require some memory barrier, etc).
// But this implementation of reference counting is enough for
// the purpose of Helgrind demonstration.
AtomicIncrement(&ref_, -1);
if (annotate_unref_) { ANNOTATE_HAPPENS_BEFORE(this); }
if (ref_ == 0) {
if (annotate_unref_) { ANNOTATE_HAPPENS_AFTER(this); }
delete this;
}
}
void AnnotateUnref() {
annotate_unref_ = true;
}
void Annotate_Race() {
ANNOTATE_BENIGN_RACE(&this->data_, "needs annotation");
}
private:
bool annotate_unref_;
Mutex mu_;
int data_; // under mu_
int ref_; // used in atomic ops.
};
// test80: FP. Ref counting with atomics, no annotations. {{{1
namespace test80 {
#ifndef NO_BARRIER
int GLOB = 0;
Barrier barrier(4);
AtomicRefCountedClass *object = NULL;
void Worker() {
object->Ref();
barrier.Block();
object->AccessData();
object->Unref(); // All the tricky stuff is here.
}
void Run() {
printf("test80: false positive (ref counting)\n");
object = new AtomicRefCountedClass;
object->Annotate_Race();
MyThreadArray t(Worker, Worker, Worker, Worker);
t.Start();
t.Join();
}
REGISTER_TEST2(Run, 80, FEATURE|EXCLUDE_FROM_ALL)
#endif // NO_BARRIER
} // namespace test80
// test81: TN. Ref counting with atomics, Unref is annotated. {{{1
namespace test81 {
#ifndef NO_BARRIER
// same as test80, but Unref is annotated.
int GLOB = 0;
Barrier barrier(4);
AtomicRefCountedClass *object = NULL;
void Worker() {
object->Ref();
barrier.Block();
object->AccessData();
object->Unref(); // All the tricky stuff is here.
}
void Run() {
printf("test81: negative (annotated ref counting)\n");
object = new AtomicRefCountedClass;
object->AnnotateUnref();
MyThreadArray t(Worker, Worker, Worker, Worker);
t.Start();
t.Join();
}
REGISTER_TEST2(Run, 81, FEATURE|EXCLUDE_FROM_ALL)
#endif // NO_BARRIER
} // namespace test81
// test82: Object published w/o synchronization. {{{1
namespace test82 {
// Writer creates a new object and makes the pointer visible to the Reader.
// Reader waits until the object pointer is non-null and reads the object.
//
// On Core 2 Duo this test will sometimes (quite rarely) fail in
// the CHECK below, at least if compiled with -O2.
//
// The sequence of events::
// Thread1: Thread2:
// a. arr_[...] = ...
// b. foo[i] = ...
// A. ... = foo[i]; // non NULL
// B. ... = arr_[...];
//
// Since there is no proper synchronization, during the even (B)
// Thread2 may not see the result of the event (a).
// On x86 and x86_64 this happens due to compiler reordering instructions.
// On other arcitectures it may also happen due to cashe inconsistency.
class FOO {
public:
FOO() {
idx_ = rand() % 1024;
arr_[idx_] = 77777;
// __asm__ __volatile__("" : : : "memory"); // this fixes!
}
static void check(volatile FOO *foo) {
CHECK(foo->arr_[foo->idx_] == 77777);
}
private:
int idx_;
int arr_[1024];
};
const int N = 100000;
static volatile FOO *foo[N];
Mutex MU;
void Writer() {
for (int i = 0; i < N; i++) {
foo[i] = new FOO;
usleep(100);
}
}
void Reader() {
for (int i = 0; i < N; i++) {
while (!foo[i]) {
MU.Lock(); // this is NOT a synchronization,
MU.Unlock(); // it just helps foo[i] to become visible in Reader.
}
if ((i % 100) == 0) {
printf("rd %d\n", i);
}
// At this point Reader() sees the new value of foo[i]
// but in very rare cases will not see the new value of foo[i]->arr_.
// Thus this CHECK will sometimes fail.
FOO::check(foo[i]);
}
}
void Run() {
printf("test82: positive\n");
MyThreadArray t(Writer, Reader);
t.Start();
t.Join();
}
REGISTER_TEST2(Run, 82, FEATURE|EXCLUDE_FROM_ALL)
} // namespace test82
// test83: Object published w/o synchronization (simple version){{{1
namespace test83 {
// A simplified version of test83 (example of a wrong code).
// This test, though incorrect, will almost never fail.
volatile static int *ptr = NULL;
Mutex MU;
void Writer() {
usleep(100);
ptr = new int(777);
}
void Reader() {
while(!ptr) {
MU.Lock(); // Not a synchronization!
MU.Unlock();
}
CHECK(*ptr == 777);
}
void Run() {
// printf("test83: positive\n");
MyThreadArray t(Writer, Reader);
t.Start();
t.Join();
}
REGISTER_TEST2(Run, 83, FEATURE|EXCLUDE_FROM_ALL)
} // namespace test83
// test84: TP. True race (regression test for a bug related to atomics){{{1
namespace test84 {
// Helgrind should not create HB arcs for the bus lock even when
// --pure-happens-before=yes is used.
// Bug found in by Bart Van Assche, the test is taken from
// valgrind file drd/tests/atomic_var.c.
static int s_x = 0;
/* s_dummy[] ensures that s_x and s_y are not in the same cache line. */
static char s_dummy[512] = {0};
static int s_y;
void thread_func_1()
{
s_y = 1;
AtomicIncrement(&s_x, 1);
}
void thread_func_2()
{
while (AtomicIncrement(&s_x, 0) == 0)
;
printf("y = %d\n", s_y);
}
void Run() {
CHECK(s_dummy[0] == 0); // Avoid compiler warning about 's_dummy unused'.
printf("test84: positive\n");
ANNOTATE_EXPECT_RACE_FOR_TSAN(&s_y, "test84: TP. true race.");
MyThreadArray t(thread_func_1, thread_func_2);
t.Start();
t.Join();
}
REGISTER_TEST(Run, 84)
} // namespace test84
// Test for RunningOnValgrind(). {{{1
TEST(NegativeTests, RunningOnValgrindTest) {
printf("RunningOnValgrind() = %d\n", RunningOnValgrind());
}
namespace NegativeTests_BenignRaceInDtor { // {{{
// Test for race inside DTOR: racey write to vptr. Benign.
// This test shows a racey access to vptr (the pointer to vtbl).
// We have class A and class B derived from A.
// Both classes have a virtual function f() and a virtual DTOR.
// We create an object 'A *a = new B'
// and pass this object from Thread1 to Thread2.
// Thread2 calls a->f(). This call reads a->vtpr.
// Thread1 deletes the object. B::~B waits untill the object can be destroyed
// (flag_stopped == true) but at the very beginning of B::~B
// a->vptr is written to.
// So, we have a race on a->vptr.
// On this particular test this race is benign, but HarmfulRaceInDtor shows
// how such race could harm.
//
//
//
// Threa1: Thread2:
// 1. A a* = new B;
// 2. Q.Put(a); ------------\ .
// \--------------------> a. a = Q.Get();
// b. a->f();
// /--------- c. flag_stopped = true;
// 3. delete a; /
// waits untill flag_stopped <------/
// inside the dtor
//
bool flag_stopped = false;
Mutex mu;
ProducerConsumerQueue Q(INT_MAX); // Used to pass A* between threads.
struct A {
A() { printf("A::A()\n"); }
virtual ~A() { printf("A::~A()\n"); }
virtual void f() { }
uintptr_t padding[15];
} ALIGNED(64);
struct B: A {
B() { printf("B::B()\n"); }
virtual ~B() {
// The race is here. <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
printf("B::~B()\n");
// wait until flag_stopped is true.
mu.LockWhen(Condition(&ArgIsTrue, &flag_stopped));
mu.Unlock();
printf("B::~B() done\n");
}
virtual void f() { }
};
void Waiter() {
A *a = new B;
printf("Waiter: B created\n");
Q.Put(a);
usleep(100000); // so that Worker calls a->f() first.
printf("Waiter: deleting B\n");
delete a;
printf("Waiter: B deleted\n");
usleep(100000);
printf("Waiter: done\n");
}
void Worker() {
A *a = reinterpret_cast<A*>(Q.Get());
printf("Worker: got A\n");
a->f();
mu.Lock();
flag_stopped = true;
mu.Unlock();
usleep(200000);
printf("Worker: done\n");
}
TEST(NegativeTests, BenignRaceInDtor) {
MyThreadArray t(Waiter, Worker);
t.Start();
t.Join();
}
} // namespace
namespace PositiveTests_HarmfulRaceInDtor { // {{{
// A variation of BenignRaceInDtor where the race is harmful.
// Race on vptr. Will run A::F() or B::F() depending on the timing.
class A {
public:
A() : done_(false) {
// W/o this annotation tsan may produce additional warnings in hybrid mode.
ANNOTATE_PURE_HAPPENS_BEFORE_MUTEX(&mu_);
}
virtual void F() {
printf ("A::F()\n");
}
void Done() {
MutexLock lock(&mu_);
done_ = true;
}
virtual ~A() {
while (true) {
{
MutexLock lock(&mu_);
if (done_) break;
}
usleep(10); // yield.
}
}
private:
Mutex mu_;
bool done_;
};
class B : public A {
public:
virtual void F() {
// TODO(kcc): enable this printf back once issue 57 is fixed.
// printf ("B::F()\n");
}
};
static A *a;
void Thread1() {
a->F();
a->Done();
sleep(1);
};
void Thread2() {
delete a;
}
TEST(PositiveTests, HarmfulRaceInDtorB) {
ANNOTATE_FLUSH_EXPECTED_RACES();
// Will print B::F()
a = new B;
ANNOTATE_EXPECT_RACE(a, "HarmfulRaceInDtor #1: expected race on a->vptr");
ANNOTATE_TRACE_MEMORY(a);
MyThreadArray t(Thread1, Thread2);
t.Start();
t.Join();
ANNOTATE_FLUSH_EXPECTED_RACES();
}
TEST(PositiveTests, HarmfulRaceInDtorA) {
ANNOTATE_FLUSH_EXPECTED_RACES();
// Will print A::F()
a = new B;
ANNOTATE_EXPECT_RACE(a, "HarmfulRaceInDtor #2: expected race on a->vptr");
ANNOTATE_TRACE_MEMORY(a);
MyThreadArray t(Thread2, Thread1);
t.Start();
t.Join();
ANNOTATE_FLUSH_EXPECTED_RACES();
}
} // namespace
namespace AnnotateIgnoreTests { // {{{1
int racey_write = 0;
void RaceyWriter() {
ANNOTATE_IGNORE_WRITES_BEGIN();
racey_write = 1;
ANNOTATE_IGNORE_WRITES_END();
}
TEST(NegativeTests, AnnotateIgnoreWritesTest) {
MyThread t(RaceyWriter);
t.Start();
racey_write = 1;
t.Join();
}
int racey_read = 0;
void RaceyReader1() {
ANNOTATE_IGNORE_READS_BEGIN();
CHECK(racey_read != 777);
ANNOTATE_IGNORE_READS_END();
}
void RaceyReader2() {
CHECK(ANNOTATE_UNPROTECTED_READ(racey_read) != 777);
}
TEST(NegativeTests, AnnotateIgnoreReadsTest) {
MyThreadArray t(RaceyReader1, RaceyReader2);
t.Start();
racey_read = 1;
t.Join();
}
int incorrectly_annotated_racey_write = 0;
void IncorrectlyAnnotatedRaceyWriter() {
ANNOTATE_IGNORE_READS_BEGIN();
incorrectly_annotated_racey_write = 1;
ANNOTATE_IGNORE_READS_END();
}
TEST(PositiveTests, AnnotateIgnoreReadsOnWriteTest) {
ANNOTATE_EXPECT_RACE(&incorrectly_annotated_racey_write, "expected race");
MyThread t(IncorrectlyAnnotatedRaceyWriter);
t.Start();
incorrectly_annotated_racey_write = 1;
t.Join();
ANNOTATE_FLUSH_EXPECTED_RACES();
}
int incorrectly_annotated_racey_read = 0;
void IncorrectlyAnnotatedRaceyReader() {
ANNOTATE_IGNORE_WRITES_BEGIN();
CHECK(incorrectly_annotated_racey_read != 777);
ANNOTATE_IGNORE_WRITES_END();
}
TEST(PositiveTests, AnnotateIgnoreWritesOnReadTest) {
ANNOTATE_EXPECT_RACE(&incorrectly_annotated_racey_read, "expected race");
MyThread t(IncorrectlyAnnotatedRaceyReader);
t.Start();
incorrectly_annotated_racey_read = 1;
t.Join();
ANNOTATE_FLUSH_EXPECTED_RACES();
}
} // namespace
// test89: Test for debug info. {{{1
namespace test89 {
// Simlpe races with different objects (stack, heap globals; scalars, structs).
// Also, if run with --trace-level=2 this test will show a sequence of
// CTOR and DTOR calls.
struct STRUCT {
int a, b, c;
};
struct A {
int a;
A() {
ANNOTATE_TRACE_MEMORY(&a);
a = 1;
}
virtual ~A() {
a = 4;
}
};
struct B : A {
B() { CHECK(a == 1); }
virtual ~B() { CHECK(a == 3); }
};
struct C : B {
C() { a = 2; }
virtual ~C() { a = 3; }
};
int GLOBAL = 0;
int *STACK = 0;
STRUCT GLOB_STRUCT;
STRUCT *STACK_STRUCT;
STRUCT *HEAP_STRUCT;
void Worker() {
GLOBAL = 1;
*STACK = 1;
GLOB_STRUCT.b = 1;
STACK_STRUCT->b = 1;
HEAP_STRUCT->b = 1;
}
void Run() {
int stack_var = 0;
STACK = &stack_var;
STRUCT stack_struct;
STACK_STRUCT = &stack_struct;
HEAP_STRUCT = new STRUCT;
printf("test89: negative\n");
MyThreadArray t(Worker, Worker);
t.Start();
t.Join();
delete HEAP_STRUCT;
A *a = new C;
printf("Using 'a->a': %d\n", a->a);
delete a;
}
REGISTER_TEST2(Run, 89, FEATURE|EXCLUDE_FROM_ALL)
} // namespace test89
// test90: FP. Test for a safely-published pointer (read-only). {{{1
namespace test90 {
// The Publisher creates an object and safely publishes it under a mutex.
// Readers access the object read-only.
// See also test91.
//
// Without annotations Helgrind will issue a false positive in Reader().
//
// Choices for annotations:
// -- ANNOTATE_CONDVAR_SIGNAL/ANNOTATE_CONDVAR_WAIT
// -- ANNOTATE_PURE_HAPPENS_BEFORE_MUTEX
// -- ANNOTATE_PUBLISH_MEMORY_RANGE.
int *GLOB = 0;
Mutex MU;
StealthNotification n1;
void Publisher() {
MU.Lock();
GLOB = (int*)malloc(128 * sizeof(int));
ANNOTATE_TRACE_MEMORY(&GLOB[42]);
GLOB[42] = 777;
if (!Tsan_PureHappensBefore())
ANNOTATE_EXPECT_RACE_FOR_TSAN(&GLOB[42], "test90. FP. This is a false positve");
MU.Unlock();
n1.signal();
usleep(200000);
}
void Reader() {
n1.wait();
while (true) {
MU.Lock();
int *p = &GLOB[42];
MU.Unlock();
if (p) {
CHECK(*p == 777); // Race is reported here.
break;
}
}
}
void Run() {
printf("test90: false positive (safely published pointer).\n");
MyThreadArray t(Publisher, Reader, Reader, Reader);
t.Start();
t.Join();
free(GLOB);
}
REGISTER_TEST(Run, 90)
} // namespace test90
// test91: FP. Test for a safely-published pointer (read-write). {{{1
namespace test91 {
// Similar to test90.
// The Publisher creates an object and safely publishes it under a mutex MU1.
// Accessors get the object under MU1 and access it (read/write) under MU2.
//
// Without annotations Helgrind will issue a false positive in Accessor().
//
int *GLOB = 0;
Mutex MU, MU1, MU2;
void Publisher() {
MU1.Lock();
GLOB = (int*)malloc(128 * sizeof(int));
GLOB[42] = 777;
if (!Tsan_PureHappensBefore())
ANNOTATE_EXPECT_RACE_FOR_TSAN(&GLOB[42], "test91. FP. This is a false positve");
MU1.Unlock();
}
void Accessor() {
usleep(10000);
while (true) {
MU1.Lock();
int *p = &GLOB[42];
MU1.Unlock();
if (p) {
MU2.Lock();
(*p)++; // Race is reported here.
CHECK(*p > 777);
MU2.Unlock();
break;
}
}
}
void Run() {
printf("test91: false positive (safely published pointer, read/write).\n");
MyThreadArray t(Publisher, Accessor, Accessor, Accessor);
t.Start();
t.Join();
free(GLOB);
}
REGISTER_TEST(Run, 91)
} // namespace test91
// test92: TN. Test for a safely-published pointer (read-write), annotated. {{{1
namespace test92 {
// Similar to test91, but annotated with ANNOTATE_PUBLISH_MEMORY_RANGE.
//
//
// Publisher: Accessors:
//
// 1. MU1.Lock()
// 2. Create GLOB.
// 3. ANNOTATE_PUBLISH_...(GLOB) -------\ .
// 4. MU1.Unlock() \ .
// \ a. MU1.Lock()
// \ b. Get GLOB
// \ c. MU1.Unlock()
// \--> d. Access GLOB
//
// A happens-before arc is created between ANNOTATE_PUBLISH_MEMORY_RANGE and
// accesses to GLOB.
struct ObjType {
int arr[10];
};
ObjType *GLOB = 0;
Mutex MU, MU1, MU2;
void Publisher() {
MU1.Lock();
GLOB = new ObjType;
for (int i = 0; i < 10; i++) {
GLOB->arr[i] = 777;
}
// This annotation should go right before the object is published.
ANNOTATE_PUBLISH_MEMORY_RANGE(GLOB, sizeof(*GLOB));
MU1.Unlock();
}
void Accessor(int index) {
while (true) {
MU1.Lock();
ObjType *p = GLOB;
MU1.Unlock();
if (p) {
MU2.Lock();
p->arr[index]++; // W/o the annotations the race will be reported here.
CHECK(p->arr[index] == 778);
MU2.Unlock();
break;
}
}
}
void Accessor0() { Accessor(0); }
void Accessor5() { Accessor(5); }
void Accessor9() { Accessor(9); }
void Run() {
printf("test92: safely published pointer, read/write, annotated.\n");
MyThreadArray t(Publisher, Accessor0, Accessor5, Accessor9);
t.Start();
t.Join();
printf("\t*GLOB=%d\n", GLOB->arr[0]);
}
REGISTER_TEST(Run, 92)
} // namespace test92
// test93: TP. Test for incorrect usage of ANNOTATE_PUBLISH_MEMORY_RANGE. {{{1
namespace test93 {
int GLOB = 0;
void Reader() {
CHECK(GLOB == 0);
}
void Publisher() {
usleep(10000);
// Incorrect, used after the memory has been accessed in another thread.
ANNOTATE_PUBLISH_MEMORY_RANGE(&GLOB, sizeof(GLOB));
}
void Run() {
printf("test93: positive, misuse of ANNOTATE_PUBLISH_MEMORY_RANGE\n");
MyThreadArray t(Reader, Publisher);
t.Start();
t.Join();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST2(Run, 93, FEATURE|EXCLUDE_FROM_ALL)
} // namespace test93
// test94: TP. Check do_cv_signal/fake segment logic {{{1
namespace test94 {
int GLOB;
int COND = 0;
int COND2 = 0;
Mutex MU, MU2;
CondVar CV, CV2;
StealthNotification n1, n2, n3;
void Thr1() {
n2.wait(); // Make sure the waiter blocks.
GLOB = 1; // WRITE
MU.Lock();
COND = 1;
CV.Signal();
MU.Unlock();
n1.signal();
}
void Thr2() {
// Make sure CV2.Signal() "happens after" CV.Signal()
n1.wait();
// Make sure the waiter blocks.
n3.wait();
MU2.Lock();
COND2 = 1;
CV2.Signal();
MU2.Unlock();
}
void Thr3() {
MU.Lock();
n2.signal();
while(COND != 1)
CV.Wait(&MU);
MU.Unlock();
}
void Thr4() {
MU2.Lock();
n3.signal();
while(COND2 != 1)
CV2.Wait(&MU2);
MU2.Unlock();
GLOB = 2; // READ: no HB-relation between CV.Signal and CV2.Wait !
}
void Run() {
ANNOTATE_EXPECT_RACE_FOR_TSAN(&GLOB, "test94: TP.");
printf("test94: TP. Check do_cv_signal/fake segment logic\n");
MyThreadArray mta(Thr1, Thr2, Thr3, Thr4);
mta.Start();
mta.Join();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST(Run, 94);
} // namespace test94
// test95: TP. Check do_cv_signal/fake segment logic {{{1
namespace test95 {
int GLOB = 0;
int COND = 0;
int COND2 = 0;
Mutex MU, MU2;
CondVar CV, CV2;
void Thr1() {
usleep(1000*1000); // Make sure CV2.Signal() "happens before" CV.Signal()
usleep(10000); // Make sure the waiter blocks.
GLOB = 1; // WRITE
MU.Lock();
COND = 1;
CV.Signal();
MU.Unlock();
}
void Thr2() {
usleep(10000); // Make sure the waiter blocks.
MU2.Lock();
COND2 = 1;
CV2.Signal();
MU2.Unlock();
}
void Thr3() {
MU.Lock();
while(COND != 1)
CV.Wait(&MU);
MU.Unlock();
}
void Thr4() {
MU2.Lock();
while(COND2 != 1)
CV2.Wait(&MU2);
MU2.Unlock();
GLOB = 2; // READ: no HB-relation between CV.Signal and CV2.Wait !
}
void Run() {
ANNOTATE_EXPECT_RACE_FOR_TSAN(&GLOB, "test95: TP.");
printf("test95: TP. Check do_cv_signal/fake segment logic\n");
MyThreadArray mta(Thr1, Thr2, Thr3, Thr4);
mta.Start();
mta.Join();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST(Run, 95);
} // namespace test95
// test96: TN. tricky LockSet behaviour {{{1
// 3 threads access the same memory with three different
// locksets: {A, B}, {B, C}, {C, A}.
// These locksets have empty intersection
namespace test96 {
int GLOB = 0;
Mutex A, B, C;
void Thread1() {
MutexLock a(&A);
MutexLock b(&B);
GLOB++;
}
void Thread2() {
MutexLock b(&B);
MutexLock c(&C);
GLOB++;
}
void Thread3() {
MutexLock a(&A);
MutexLock c(&C);
GLOB++;
}
void Run() {
printf("test96: FP. tricky LockSet behaviour\n");
ANNOTATE_TRACE_MEMORY(&GLOB);
MyThreadArray mta(Thread1, Thread2, Thread3);
mta.Start();
mta.Join();
CHECK(GLOB == 3);
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST(Run, 96);
} // namespace test96
namespace FalseNegativeOfFastModeTest { // {{{1
// This test shows false negative with --fast-mode=yes.
const int HG_CACHELINE_SIZE = 64;
StealthNotification n1, n2;
const int ARRAY_SIZE = HG_CACHELINE_SIZE * 4 / sizeof(int);
int array[ARRAY_SIZE];
int * GLOB = &array[ARRAY_SIZE/2];
/*
We use sizeof(array) == 4 * HG_CACHELINE_SIZE to be sure that GLOB points
to a memory inside a CacheLineZ which is inside array's memory range
*/
void Reader() {
n1.wait();
CHECK(0 != *GLOB);
n2.signal();
}
TEST(PositiveTests, FalseNegativeOfFastModeTest) {
MyThreadArray t(Reader);
ANNOTATE_TRACE_MEMORY(GLOB);
ANNOTATE_EXPECT_RACE_FOR_TSAN(GLOB, __FUNCTION__);
t.Start();
*GLOB = 0x12345;
n1.signal();
n2.wait();
t.Join();
}
} // namespace
// test99: TP. Unit test for a bug in LockWhen*. {{{1
namespace test99 {
bool GLOB = false;
Mutex mu;
static void Thread1() {
for (int i = 0; i < 100; i++) {
mu.LockWhenWithTimeout(Condition(&ArgIsTrue, &GLOB), 5);
GLOB = false;
mu.Unlock();
usleep(10000);
}
}
static void Thread2() {
for (int i = 0; i < 100; i++) {
mu.Lock();
mu.Unlock();
usleep(10000);
}
}
void Run() {
printf("test99: regression test for LockWhen*\n");
MyThreadArray t(Thread1, Thread2);
t.Start();
t.Join();
}
REGISTER_TEST(Run, 99);
} // namespace test99
// test100: Test for initialization bit. {{{1
namespace test100 {
int G1 = 0;
int G2 = 0;
int G3 = 0;
int G4 = 0;
void Creator() {
G1 = 1; CHECK(G1);
G2 = 1;
G3 = 1; CHECK(G3);
G4 = 1;
}
void Worker1() {
usleep(100000);
CHECK(G1);
CHECK(G2);
G3 = 3;
G4 = 3;
}
void Worker2() {
}
void Run() {
printf("test100: test for initialization bit. \n");
MyThreadArray t(Creator, Worker1, Worker2);
ANNOTATE_TRACE_MEMORY(&G1);
ANNOTATE_TRACE_MEMORY(&G2);
ANNOTATE_TRACE_MEMORY(&G3);
ANNOTATE_TRACE_MEMORY(&G4);
t.Start();
t.Join();
}
REGISTER_TEST2(Run, 100, FEATURE|EXCLUDE_FROM_ALL)
} // namespace test100
// test101: TN. Two signals and two waits. {{{1
namespace test101 {
Mutex MU;
CondVar CV;
int GLOB = 0;
int C1 = 0, C2 = 0;
void Signaller() {
usleep(100000);
MU.Lock();
C1 = 1;
CV.Signal();
printf("signal\n");
MU.Unlock();
GLOB = 1;
usleep(500000);
MU.Lock();
C2 = 1;
CV.Signal();
printf("signal\n");
MU.Unlock();
}
void Waiter() {
MU.Lock();
while(!C1)
CV.Wait(&MU);
printf("wait\n");
MU.Unlock();
MU.Lock();
while(!C2)
CV.Wait(&MU);
printf("wait\n");
MU.Unlock();
GLOB = 2;
}
void Run() {
printf("test101: negative\n");
MyThreadArray t(Waiter, Signaller);
t.Start();
t.Join();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST(Run, 101)
} // namespace test101
// test102: --fast-mode=yes vs. --initialization-bit=yes {{{1
namespace test102 {
const int HG_CACHELINE_SIZE = 64;
Mutex MU;
const int ARRAY_SIZE = HG_CACHELINE_SIZE * 4 / sizeof(int);
int array[ARRAY_SIZE + 1];
int * GLOB = &array[ARRAY_SIZE/2];
/*
We use sizeof(array) == 4 * HG_CACHELINE_SIZE to be sure that GLOB points
to a memory inside a CacheLineZ which is inside array's memory range
*/
StealthNotification n1, n2, n3;
void Reader() {
n1.wait();
CHECK(777 == GLOB[0]);
n2.signal();
n3.wait();
CHECK(777 == GLOB[1]);
}
void Run() {
MyThreadArray t(Reader);
ANNOTATE_EXPECT_RACE_FOR_TSAN(GLOB+0, "test102: TP. FN with --fast-mode=yes");
ANNOTATE_EXPECT_RACE_FOR_TSAN(GLOB+1, "test102: TP");
printf("test102: --fast-mode=yes vs. --initialization-bit=yes\n");
t.Start();
GLOB[0] = 777;
n1.signal();
n2.wait();
GLOB[1] = 777;
n3.signal();
t.Join();
}
REGISTER_TEST2(Run, 102, FEATURE)
} // namespace test102
// test103: Access different memory locations with different LockSets {{{1
namespace test103 {
const int N_MUTEXES = 6;
const int LOCKSET_INTERSECTION_SIZE = 3;
int data[1 << LOCKSET_INTERSECTION_SIZE] = {0};
Mutex MU[N_MUTEXES];
inline int LS_to_idx (int ls) {
return (ls >> (N_MUTEXES - LOCKSET_INTERSECTION_SIZE))
& ((1 << LOCKSET_INTERSECTION_SIZE) - 1);
}
void Worker() {
for (int ls = 0; ls < (1 << N_MUTEXES); ls++) {
if (LS_to_idx(ls) == 0)
continue;
for (int m = 0; m < N_MUTEXES; m++)
if (ls & (1 << m))
MU[m].Lock();
data[LS_to_idx(ls)]++;
for (int m = N_MUTEXES - 1; m >= 0; m--)
if (ls & (1 << m))
MU[m].Unlock();
}
}
void Run() {
printf("test103: Access different memory locations with different LockSets\n");
MyThreadArray t(Worker, Worker, Worker, Worker);
t.Start();
t.Join();
}
REGISTER_TEST2(Run, 103, FEATURE)
} // namespace test103
// test104: TP. Simple race (write vs write). Heap mem. {{{1
namespace test104 {
int *GLOB = NULL;
void Worker() {
GLOB[42] = 1;
}
void Parent() {
MyThread t(Worker);
t.Start();
usleep(100000);
GLOB[42] = 2;
t.Join();
}
void Run() {
GLOB = (int*)malloc(128 * sizeof(int));
GLOB[42] = 0;
ANNOTATE_EXPECT_RACE(&GLOB[42], "test104. TP.");
ANNOTATE_TRACE_MEMORY(&GLOB[42]);
printf("test104: positive\n");
Parent();
printf("\tGLOB=%d\n", GLOB[42]);
free(GLOB);
}
REGISTER_TEST(Run, 104);
} // namespace test104
// test105: Checks how stack grows. {{{1
namespace test105 {
int GLOB = 0;
void F1() {
int ar[32];
// ANNOTATE_TRACE_MEMORY(&ar[0]);
// ANNOTATE_TRACE_MEMORY(&ar[31]);
ar[0] = 1;
ar[31] = 1;
CHECK(ar[0] == 1);
}
void Worker() {
int ar[32];
// ANNOTATE_TRACE_MEMORY(&ar[0]);
// ANNOTATE_TRACE_MEMORY(&ar[31]);
ar[0] = 1;
ar[31] = 1;
CHECK(ar[0] == 1);
F1();
}
void Run() {
printf("test105: negative\n");
Worker();
MyThread t(Worker);
t.Start();
t.Join();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST(Run, 105)
} // namespace test105
// test107: Test for ANNOTATE_EXPECT_RACE {{{1
namespace test107 {
int GLOB = 0;
void Run() {
printf("test107: negative\n");
ANNOTATE_EXPECT_RACE(&GLOB, "No race in fact. Just checking the tool.");
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST2(Run, 107, FEATURE|EXCLUDE_FROM_ALL)
} // namespace test107
// test108: TN. initialization of static object. {{{1
namespace test108 {
// Here we have a function-level static object.
// Starting from gcc 4 this is therad safe,
// but is is not thread safe with many other compilers.
//
// Helgrind/ThreadSanitizer supports this kind of initialization by
// intercepting __cxa_guard_acquire/__cxa_guard_release
// and ignoring all accesses between them.
// pthread_once is supported in the same manner.
class Foo {
public:
Foo() {
ANNOTATE_TRACE_MEMORY(&a_);
a_ = 42;
}
void Check() const { CHECK(a_ == 42); }
private:
int a_;
};
const Foo *GetFoo() {
static const Foo *foo = new Foo();
return foo;
}
void Worker0() {
GetFoo();
}
void Worker() {
usleep(200000);
const Foo *foo = GetFoo();
foo->Check();
}
void Run() {
printf("test108: negative, initialization of static object\n");
MyThreadArray t(Worker0, Worker, Worker);
t.Start();
t.Join();
}
#ifdef __GNUC__
REGISTER_TEST2(Run, 108, FEATURE)
#endif
} // namespace test108
// test109: TN. Checking happens before between parent and child threads. {{{1
namespace test109 {
// Check that the detector correctly connects
// pthread_create with the new thread
// and
// thread exit with pthread_join
const int N = 32;
static int GLOB[N];
void Worker(void *a) {
usleep(10000);
// printf("--Worker : %ld %p\n", (int*)a - GLOB, (void*)pthread_self());
int *arg = (int*)a;
(*arg)++;
}
void Run() {
printf("test109: negative\n");
MyThread *t[N];
for (int i = 0; i < N; i++) {
t[i] = new MyThread(Worker, &GLOB[i]);
}
for (int i = 0; i < N; i++) {
ANNOTATE_TRACE_MEMORY(&GLOB[i]);
GLOB[i] = 1;
t[i]->Start();
// printf("--Started: %p\n", (void*)t[i]->tid());
}
for (int i = 0; i < N; i++) {
// printf("--Joining: %p\n", (void*)t[i]->tid());
t[i]->Join();
// printf("--Joined : %p\n", (void*)t[i]->tid());
GLOB[i]++;
}
for (int i = 0; i < N; i++) delete t[i];
printf("\tGLOB=%d\n", GLOB[13]);
}
REGISTER_TEST(Run, 109)
} // namespace test109
// test111: TN. Unit test for a bug related to stack handling. {{{1
namespace test111 {
char *GLOB = 0;
bool COND = false;
Mutex mu;
const int N = 3000;
void write_to_p(char *p, int val) {
for (int i = 0; i < N; i++)
p[i] = val;
}
void f1() {
char some_stack[N];
write_to_p(some_stack, 1);
mu.LockWhen(Condition(&ArgIsTrue, &COND));
mu.Unlock();
}
void f2() {
char some_stack[N];
char some_more_stack[N];
write_to_p(some_stack, 2);
write_to_p(some_more_stack, 2);
}
void f0() { f2(); }
void Worker1() {
f0();
f1();
f2();
}
void Worker2() {
usleep(100000);
mu.Lock();
COND = true;
mu.Unlock();
}
void Run() {
printf("test111: regression test\n");
MyThreadArray t(Worker1, Worker1, Worker2);
t.Start();
t.Join();
}
REGISTER_TEST2(Run, 111, FEATURE)
} // namespace test111
// test112: STAB. Test for ANNOTATE_PUBLISH_MEMORY_RANGE{{{1
namespace test112 {
char *GLOB = 0;
const int N = 64 * 5;
Mutex mu;
bool ready = false; // under mu
int beg, end; // under mu
Mutex mu1;
void Worker() {
bool is_ready = false;
int b, e;
while (!is_ready) {
mu.Lock();
is_ready = ready;
b = beg;
e = end;
mu.Unlock();
usleep(1000);
}
mu1.Lock();
for (int i = b; i < e; i++) {
GLOB[i]++;
}
mu1.Unlock();
}
void PublishRange(int b, int e) {
MyThreadArray t(Worker, Worker);
ready = false; // runs before other threads
t.Start();
ANNOTATE_NEW_MEMORY(GLOB + b, e - b);
ANNOTATE_TRACE_MEMORY(GLOB + b);
for (int j = b; j < e; j++) {
GLOB[j] = 0;
}
ANNOTATE_PUBLISH_MEMORY_RANGE(GLOB + b, e - b);
// hand off
mu.Lock();
ready = true;
beg = b;
end = e;
mu.Unlock();
t.Join();
}
void Run() {
printf("test112: stability (ANNOTATE_PUBLISH_MEMORY_RANGE)\n");
GLOB = new char [N];
PublishRange(0, 10);
PublishRange(3, 5);
PublishRange(12, 13);
PublishRange(10, 14);
PublishRange(15, 17);
PublishRange(16, 18);
// do few more random publishes.
for (int i = 0; i < 20; i++) {
const int begin = rand() % N;
const int size = (rand() % (N - begin)) + 1;
CHECK(size > 0);
CHECK(begin + size <= N);
PublishRange(begin, begin + size);
}
printf("GLOB = %d\n", (int)GLOB[0]);
}
REGISTER_TEST2(Run, 112, STABILITY)
} // namespace test112
// test113: PERF. A lot of lock/unlock calls. Many locks {{{1
namespace test113 {
const int kNumIter = 100000;
const int kNumLocks = 7;
Mutex MU[kNumLocks];
TEST (StressTests, ManyLocksUnlocks2) {
printf("test113: perf\n");
for (int i = 0; i < kNumIter; i++ ) {
for (int j = 0; j < kNumLocks; j++) {
if (i & (1 << j)) MU[j].Lock();
}
for (int j = kNumLocks - 1; j >= 0; j--) {
if (i & (1 << j)) MU[j].Unlock();
}
}
}
} // namespace test113
// test114: STAB. Recursive static initialization. {{{1
namespace test114 {
int Bar() {
static int bar = 1;
return bar;
}
int Foo() {
static int foo = Bar();
return foo;
}
void Worker() {
static int x = Foo();
CHECK(x == 1);
}
void Run() {
printf("test114: stab\n");
MyThreadArray t(Worker, Worker);
t.Start();
t.Join();
}
#ifdef __GNUC__
REGISTER_TEST(Run, 114)
#endif
} // namespace test114
// test116: TN. some operations with string<> objects. {{{1
namespace test116 {
void Worker() {
string A[10], B[10], C[10];
for (int i = 0; i < 1000; i++) {
for (int j = 0; j < 10; j++) {
string &a = A[j];
string &b = B[j];
string &c = C[j];
a = "sdl;fkjhasdflksj df";
b = "sdf sdf;ljsd ";
c = "'sfdf df";
c = b;
a = c;
b = a;
swap(a,b);
swap(b,c);
}
for (int j = 0; j < 10; j++) {
string &a = A[j];
string &b = B[j];
string &c = C[j];
a.clear();
b.clear();
c.clear();
}
}
}
void Run() {
printf("test116: negative (strings)\n");
MyThreadArray t(Worker, Worker, Worker);
t.Start();
t.Join();
}
REGISTER_TEST2(Run, 116, FEATURE|EXCLUDE_FROM_ALL)
} // namespace test116
// test117: TN. Many calls to function-scope static init. {{{1
namespace test117 {
const int N = 50;
int Foo() {
usleep(20000);
return 1;
}
void Worker(void *a) {
static int foo = Foo();
CHECK(foo == 1);
}
void Run() {
printf("test117: negative\n");
MyThread *t[N];
for (int i = 0; i < N; i++) {
t[i] = new MyThread(Worker);
}
for (int i = 0; i < N; i++) {
t[i]->Start();
}
for (int i = 0; i < N; i++) {
t[i]->Join();
}
for (int i = 0; i < N; i++) delete t[i];
}
#ifndef WIN32
// This is racey on Windows!
REGISTER_TEST(Run, 117)
#endif
} // namespace test117
// test118 PERF: One signal, multiple waits. {{{1
namespace test118 {
int GLOB = 0;
const int kNumIter = 2000000;
void Signaller() {
usleep(50000);
ANNOTATE_CONDVAR_SIGNAL(&GLOB);
}
void Waiter() {
for (int i = 0; i < kNumIter; i++) {
ANNOTATE_CONDVAR_WAIT(&GLOB);
if (i == kNumIter / 2)
usleep(100000);
}
}
TEST(StressTests, OneSignalManyWaits) {
printf("test118: perf\n");
MyThreadArray t(Signaller, Waiter, Signaller, Waiter);
t.Start();
t.Join();
printf("\tGLOB=%d\n", GLOB);
}
} // namespace test118
// test119: TP. Testing that malloc does not introduce any HB arc. {{{1
namespace test119 {
int GLOB = 0;
void Worker1() {
GLOB = 1;
free(malloc(123));
}
void Worker2() {
usleep(100000);
free(malloc(345));
GLOB = 2;
}
void Run() {
printf("test119: positive (checking if malloc creates HB arcs)\n");
if (!(Tsan_PureHappensBefore() && kMallocUsesMutex))
ANNOTATE_EXPECT_RACE_FOR_TSAN(&GLOB, "true race");
MyThreadArray t(Worker1, Worker2);
t.Start();
t.Join();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST(Run, 119)
} // namespace test119
// test120: TP. Thread1: write then read. Thread2: read. {{{1
namespace test120 {
int GLOB = 0;
void Thread1() {
GLOB = 1; // write
CHECK(GLOB); // read
}
void Thread2() {
usleep(100000);
CHECK(GLOB >= 0); // read
}
void Run() {
ANNOTATE_EXPECT_RACE_FOR_TSAN(&GLOB, "TP (T1: write then read, T2: read)");
printf("test120: positive\n");
MyThreadArray t(Thread1, Thread2);
GLOB = 1;
t.Start();
t.Join();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST(Run, 120)
} // namespace test120
namespace DoubleCheckedLocking { // {{{1
struct Foo {
uintptr_t padding1[16];
uintptr_t a;
uintptr_t padding2[16];
};
static Mutex mu;
static Foo *foo;
void InitMe() {
if (!foo) {
MutexLock lock(&mu);
if (!foo) {
ANNOTATE_EXPECT_RACE_FOR_TSAN(&foo, "Double-checked locking (ptr)");
foo = new Foo;
if (Tsan_PureHappensBefore()) {
// A pure h-b detector may or may not detect this.
ANNOTATE_BENIGN_RACE(&foo->a, "real race");
} else {
// ThreadSanitizer in full hybrid mode must detect it.
ANNOTATE_EXPECT_RACE_FOR_TSAN(&foo->a, "Double-checked locking (obj)");
}
foo->a = 42;
}
}
}
void UseMe() {
InitMe();
CHECK(foo);
if (foo->a != 42) {
printf("foo->a = %d (should be 42)\n", (int)foo->a);
}
}
void Worker1() { UseMe(); }
void Worker2() { UseMe(); }
void Worker3() { UseMe(); }
TEST(PositiveTests, DoubleCheckedLocking1) {
foo = NULL;
MyThreadArray t1(Worker1, Worker2, Worker3);
t1.Start();
t1.Join();
delete foo;
}
} // namespace DoubleCheckedLocking
namespace DoubleCheckedLocking2 { // {{{1
struct Foo {
uintptr_t padding1[16];
uintptr_t a;
uintptr_t padding2[16];
};
Foo *foo;
Mutex mu;
void InitMe() {
if (foo) return;
Foo *x = new Foo;
ANNOTATE_BENIGN_RACE(&x->a, "may or may not detect this race");
x->a = 42;
{
MutexLock lock(&mu);
if (!foo) {
foo = x;
x = NULL;
}
}
if (x) delete x;
}
void Worker() {
InitMe();
CHECK(foo);
CHECK(foo->a == 42);
}
TEST(PositiveTests, DoubleCheckedLocking2) {
foo = NULL;
ANNOTATE_EXPECT_RACE(&foo, "real race");
MyThreadArray t1(Worker, Worker, Worker, Worker);
t1.Start();
t1.Join();
delete foo;
}
} // namespace DoubleCheckedLocking2
namespace PositiveTests_DifferentSizeAccessTest { // {{{1
uint64_t arr[1000];
size_t arr_index = 0;
uint64_t *MEM;
size_t size[3];
size_t offset[3];
void GenericWrite(size_t s, size_t off) {
switch(s) {
case 8:
CHECK(off == 0);
((uint64_t*)MEM)[off] = 1;
break;
case 4:
CHECK(off < 2);
((uint32_t*)MEM)[off] = 1;
break;
case 2:
CHECK(off < 4);
((uint16_t*)MEM)[off] = 1;
break;
case 1:
CHECK(off < 8);
((uint8_t*)MEM)[off] = 1;
break;
default: CHECK(0); break;
}
}
void Thread1() { GenericWrite(size[0], offset[0]); }
void Thread2() { GenericWrite(size[1], offset[1]); }
bool TwoRangesIntersect(size_t beg1, size_t end1, size_t beg2, size_t end2) {
if (beg1 <= beg2 && end1 > beg2) return true;
if (beg2 <= beg1 && end2 > beg1) return true;
return false;
}
void RunTwoThreads(size_t size1, size_t offset1, size_t size2, size_t offset2) {
size[0] = size1;
size[1] = size2;
offset[0] = offset1;
offset[1] = offset2;
long beg1 = offset1 * size1;
long end1 = beg1 + size1;
long beg2 = offset2 * size2;
long end2 = beg2 + size2;
bool have_intersection = TwoRangesIntersect(beg1, end1, beg2, end2);
char descr[1024];
MEM = &arr[arr_index++];
sprintf(descr, "Testing: [%ld, %ld) vs [%ld, %ld] (%s intersection); p=%p",
beg1, end1, beg2, end2, have_intersection ? "have" : "no", MEM);
fprintf(stderr, "%s\n", descr);
char *racey_addr_beg = (char*)MEM + max(beg1, beg2);
char *racey_addr_end = (char*)MEM + min(end1, end2);
if (have_intersection) {
ANNOTATE_EXPECT_RACE(racey_addr_beg, descr);
if (racey_addr_end - racey_addr_beg >= 2) {
// We expect a race on the first racey byte, but we may also see some
// races in other bytes (e.g. if a 8-byte store is implemented via two
// 4-byte stores on a 32-bit arch). Ignore these extra races.
ANNOTATE_BENIGN_RACE_SIZED(racey_addr_beg+1, racey_addr_end - racey_addr_beg - 1,
"race");
}
}
MyThreadArray t1(Thread1, Thread2);
t1.Start();
t1.Join();
}
void TestTwoSizes(size_t size1, size_t offset1, size_t size2, size_t offset2) {
RunTwoThreads(size1, offset1, size2, offset2);
RunTwoThreads(size2, offset2, size1, offset1);
}
TEST(PositiveTests, DifferentSizeAccessTest) {
for(int size1_log = 3; size1_log >= 0; size1_log--) {
for (int size2_log = size1_log; size2_log >= 0; size2_log--) {
for (int off1 = 0; off1 < (1 << (3-size1_log)); off1++) {
for (int off2 = 0; off2 < (1 << (3-size2_log)); off2++) {
RunTwoThreads(1 << size1_log, off1, 1 << size2_log, off2);
}
}
}
}
}
const int kStressArrSize = 100;
char stress_arr[kStressArrSize];
void StressWorker() {
const int n = 100000;
char foo[kStressArrSize];
memset(foo, 0, sizeof(foo));
for (int i = 0; i < n; i++) {
memcpy(stress_arr + i % (kStressArrSize / 2), foo, i % (kStressArrSize / 3));
}
}
TEST(StressTests, DifferentSizeAccessStressTest) {
ANNOTATE_BENIGN_RACE_SIZED(stress_arr, sizeof(stress_arr), "race");
MyThreadArray t(StressWorker, StressWorker, StressWorker);
t.Start();
t.Join();
}
} // namespace
// test124: What happens if we delete an unlocked lock? {{{1
namespace test124 {
// This test does not worg with pthreads (you can't call
// pthread_mutex_destroy on a locked lock).
int GLOB = 0;
const int N = 1000;
void Worker() {
Mutex *a_large_local_array_of_mutexes;
a_large_local_array_of_mutexes = new Mutex[N];
for (int i = 0; i < N; i++) {
a_large_local_array_of_mutexes[i].Lock();
}
delete []a_large_local_array_of_mutexes;
GLOB = 1;
}
void Run() {
printf("test124: negative\n");
MyThreadArray t(Worker, Worker, Worker);
t.Start();
t.Join();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST2(Run, 124, FEATURE|EXCLUDE_FROM_ALL)
} // namespace test124
// test126 TN: test for BlockingCounter {{{1
namespace test126 {
BlockingCounter *blocking_counter;
int GLOB = 0;
void Worker() {
CHECK(blocking_counter);
CHECK(GLOB == 0);
blocking_counter->DecrementCount();
}
void Run() {
printf("test126: negative\n");
MyThreadArray t(Worker, Worker, Worker);
blocking_counter = new BlockingCounter(3);
t.Start();
blocking_counter->Wait();
GLOB = 1;
t.Join();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST(Run, 126)
} // namespace test126
// test127. Bad code: unlocking a mutex locked by another thread. {{{1
namespace test127 {
Mutex mu;
void Thread1() {
mu.Lock();
usleep(1); // avoid tail call elimination
}
void Thread2() {
usleep(100000);
mu.Unlock();
usleep(1); // avoid tail call elimination
}
TEST(LockTests, UnlockingALockHeldByAnotherThread) {
MyThreadArray t(Thread1, Thread2);
t.Start();
t.Join();
}
} // namespace test127
// test128. Suppressed code in concurrent accesses {{{1
// Please use --suppressions=unittest.supp flag when running this test.
namespace test128 {
Mutex mu;
int GLOB = 0;
void Worker() {
usleep(100000);
mu.Lock();
GLOB++;
mu.Unlock();
}
void ThisFunctionShouldBeSuppressed() {
GLOB++;
}
void Run() {
printf("test128: Suppressed code in concurrent accesses.\n");
MyThreadArray t(Worker, ThisFunctionShouldBeSuppressed);
t.Start();
t.Join();
}
REGISTER_TEST2(Run, 128, FEATURE | EXCLUDE_FROM_ALL)
} // namespace test128
// test129: TN. Synchronization via ReaderLockWhen(). {{{1
namespace test129 {
int GLOB = 0;
Mutex MU;
bool WeirdCondition(int* param) {
*param = GLOB; // a write into Waiter's memory
return GLOB > 0;
}
void Waiter() {
int param = 0;
MU.ReaderLockWhen(Condition(WeirdCondition, &param));
MU.ReaderUnlock();
CHECK(GLOB > 0);
CHECK(param > 0);
}
void Waker() {
usleep(100000); // Make sure the waiter blocks.
MU.Lock();
GLOB++;
MU.Unlock(); // calls ANNOTATE_CONDVAR_SIGNAL;
}
void Run() {
printf("test129: Synchronization via ReaderLockWhen()\n");
MyThread mt(Waiter, NULL, "Waiter Thread");
mt.Start();
Waker();
mt.Join();
printf("\tGLOB=%d\n", GLOB);
}
REGISTER_TEST2(Run, 129, FEATURE);
} // namespace test129
namespace NegativeTests_PerThreadTest { // {{{1
#ifdef TLS
// This test verifies that the race detector handles
// thread-local storage (TLS) correctly.
// As of 09-03-30 ThreadSanitizer has a bug:
// - Thread1 starts
// - Thread1 touches per_thread_global
// - Thread1 ends
// - Thread2 starts (and there is no happens-before relation between it and
// Thread1)
// - Thread2 touches per_thread_global
// It may happen so that Thread2 will have per_thread_global in the same address
// as Thread1. Since there is no happens-before relation between threads,
// ThreadSanitizer reports a race.
//
// test131 does the same for stack.
static TLS int per_thread_global[10] = {0};
void RealWorker() { // Touch per_thread_global.
per_thread_global[1]++;
per_thread_global[9]++;
errno++;
}
void Worker() { // Spawn few threads that touch per_thread_global.
MyThreadArray t(RealWorker, RealWorker);
t.Start();
t.Join();
}
void Worker0() { usleep(0); Worker(); }
void Worker1() { usleep(100000); Worker(); }
void Worker2() { usleep(200000); Worker(); }
void Worker3() { usleep(300000); Worker(); }
#ifdef WIN32
TEST(NegativeTests, DISABLED_PerThreadTest) { // issue #23
#else
TEST(NegativeTests, PerThreadTest) {
#endif
MyThreadArray t1(Worker0, Worker1, Worker2, Worker3);
t1.Start();
t1.Join();
}
#endif // TLS
} // namespace test130
namespace NegativeTests_StackReuseTest { // {{{1
// Same as PerThreadTest, but for stack.
void RealWorker() { // Touch stack.
int stack_var = 0;
stack_var++;
}
void Worker() { // Spawn few threads that touch stack.
MyThreadArray t(RealWorker, RealWorker);
t.Start();
t.Join();
}
void Worker0() { usleep(0); Worker(); }
void Worker1() { usleep(100000); Worker(); }
void Worker2() { usleep(200000); Worker(); }
void Worker3() { usleep(300000); Worker(); }
TEST(NegativeTests, StackReuseTest) {
MyThreadArray t(Worker0, Worker1, Worker2, Worker3);
t.Start();
t.Join();
}
TEST(NegativeTests, StackReuseWithFlushTest) {
MyThreadArray t1(Worker0, Worker1, Worker2, Worker3);
MyThreadArray t2(Worker0, Worker1, Worker2, Worker3);
t1.Start();
ANNOTATE_FLUSH_STATE();
usleep(400000);
t2.Start();
t2.Join();
t1.Join();
}
} // namespace test131
// test132: TP. Simple race (write vs write). Works in fast-mode. {{{1
namespace test132 {
int GLOB = 0;
void Worker() { GLOB = 1; }
void Run1() {
ANNOTATE_EXPECT_RACE_FOR_TSAN(&GLOB, "test132");
printf("test132: positive; &GLOB=%p\n", &GLOB);
ANNOTATE_TRACE_MEMORY(&GLOB);
GLOB = 7;
MyThreadArray t(Worker, Worker);
t.Start();
t.Join();
}
void Run() {
Run1();
}
REGISTER_TEST(Run, 132);
} // namespace test132
// test133: TP. Simple race (write vs write). Works in fast mode. {{{1
namespace test133 {
// Same as test132, but everything is run from a separate thread spawned from
// the main thread.
int GLOB = 0;
void Worker() { GLOB = 1; }
void Run1() {
ANNOTATE_EXPECT_RACE_FOR_TSAN(&GLOB, "test133");
printf("test133: positive; &GLOB=%p\n", &GLOB);
ANNOTATE_TRACE_MEMORY(&GLOB);
GLOB = 7;
MyThreadArray t(Worker, Worker);
t.Start();
t.Join();
}
void Run() {
MyThread t(Run1);
t.Start();
t.Join();
}
REGISTER_TEST(Run, 133);
} // namespace test133
// test134 TN. Swap. Variant of test79. {{{1
namespace test134 {
#if 0
typedef __gnu_cxx::hash_map<int, int> map_t;
#else
typedef std::map<int, int> map_t;
#endif
map_t map;
Mutex mu;
// Here we use swap to pass map between threads.
// The synchronization is correct, but w/o the annotation
// any hybrid detector will complain.
// Swap is very unfriendly to the lock-set (and hybrid) race detectors.
// Since tmp is destructed outside the mutex, we need to have a happens-before
// arc between any prior access to map and here.
// Since the internals of tmp are created ouside the mutex and are passed to
// other thread, we need to have a h-b arc between here and any future access.
// These arcs can be created by HAPPENS_{BEFORE,AFTER} annotations, but it is
// much simpler to apply pure-happens-before mode to the mutex mu.
void Swapper() {
map_t tmp;
MutexLock lock(&mu);
ANNOTATE_HAPPENS_AFTER(&map);
// We swap the new empty map 'tmp' with 'map'.
map.swap(tmp);
ANNOTATE_HAPPENS_BEFORE(&map);
// tmp (which is the old version of map) is destroyed here.
}
void Worker() {
MutexLock lock(&mu);
ANNOTATE_HAPPENS_AFTER(&map);
map[1]++;
ANNOTATE_HAPPENS_BEFORE(&map);
}
void Run() {
printf("test134: negative (swap)\n");
// ********************** Shorter way: ***********************
// ANNOTATE_PURE_HAPPENS_BEFORE_MUTEX(&mu);
MyThreadArray t(Worker, Worker, Swapper, Worker, Worker);
t.Start();
t.Join();
}
REGISTER_TEST(Run, 134)
} // namespace test134
// test137 TP. Races on stack variables. {{{1
namespace test137 {
int GLOB = 0;
ProducerConsumerQueue q(10);
void Worker() {
int stack;
int *tmp = (int*)q.Get();
(*tmp)++;
int *racey = &stack;
q.Put(racey);
(*racey)++;
usleep(150000);
// We may miss the races if we sleep less due to die_memory events...
}
void Run() {
int tmp = 0;
printf("test137: TP. Races on stack variables.\n");
q.Put(&tmp);
MyThreadArray t(Worker, Worker, Worker, Worker);
t.Start();
t.Join();
q.Get();
}
REGISTER_TEST2(Run, 137, FEATURE | EXCLUDE_FROM_ALL)
} // namespace test137
namespace ThreadPoolFNTests { // {{{1
// When using thread pools, two concurrent callbacks might be scheduled
// onto the same executor thread. As a result, unnecessary happens-before
// relation may be introduced between callbacks.
// If we set the number of executor threads to 1, any known data
// race detector will be silent.
// However, the a similar situation may happen with any number of
// executor threads (with some probability).
void Worker(int *var) {
usleep(100000);
*var = 42;
}
TEST(ThreadPoolFNTests, OneProducerOneConsumer) {
int RACEY = 0;
printf("FN. Two closures hit the same thread in ThreadPool.\n");
ThreadPool tp(1);
tp.StartWorkers();
tp.Add(NewCallback(Worker, &RACEY));
tp.Add(NewCallback(Worker, &RACEY));
}
void PutWorkerOn(ThreadPool *tp, int *var) {
usleep(100000);
tp->Add(NewCallback(Worker, var));
usleep(100000);
}
TEST(ThreadPoolFNTests, TwoProducersOneConsumer) {
int RACEY = 0;
printf("FN. Two closures hit the same thread in ThreadPool.\n");
ThreadPool consumers_tp(1);
consumers_tp.StartWorkers();
ThreadPool producers_tp(2);
producers_tp.StartWorkers();
producers_tp.Add(NewCallback(PutWorkerOn, &consumers_tp, &RACEY));
producers_tp.Add(NewCallback(PutWorkerOn, &consumers_tp, &RACEY));
}
} // namespace ThreadPoolFNTests
// test139: FN. A true race hidden by reference counting annotation. {{{1
namespace test139 {
int GLOB = 0;
RefCountedClass *obj;
void Worker1() {
GLOB++; // First access.
obj->Unref();
}
void Worker2() {
usleep(100000);
obj->Unref();
GLOB++; // Second access.
}
void Run() {
printf("test139: FN. A true race hidden by reference counting annotation.\n");
obj = new RefCountedClass;
obj->AnnotateUnref();
obj->Ref();
obj->Ref();
MyThreadArray mt(Worker1, Worker2);
mt.Start();
mt.Join();
}
REGISTER_TEST2(Run, 139, FEATURE)
} // namespace test139
// Simple FIFO queue annotated with PCQ annotations. {{{1
class FifoMessageQueue {
public:
FifoMessageQueue() { ANNOTATE_PCQ_CREATE(this); }
~FifoMessageQueue() { ANNOTATE_PCQ_DESTROY(this); }
// Send a message. 'message' should be positive.
void Put(int message) {
CHECK(message);
MutexLock lock(&mu_);
ANNOTATE_PCQ_PUT(this);
q_.push(message);
}
// Return the message from the queue and pop it
// or return 0 if there are no messages.
int Get() {
MutexLock lock(&mu_);
if (q_.empty()) return 0;
int res = q_.front();
q_.pop();
ANNOTATE_PCQ_GET(this);
return res;
}
private:
Mutex mu_;
queue<int> q_;
};
// test142: TN. Check PCQ_* annotations. {{{1
namespace test142 {
// Putter writes to array[i] and sends a message 'i'.
// Getters receive messages and read array[message].
// PCQ_* annotations calm down the hybrid detectors.
const int N = 1000;
int array[N+1];
FifoMessageQueue q;
void Putter() {
for (int i = 1; i <= N; i++) {
array[i] = i*i;
q.Put(i);
usleep(1000);
}
}
void Getter() {
int non_zero_received = 0;
for (int i = 1; i <= N; i++) {
int res = q.Get();
if (res > 0) {
CHECK(array[res] = res * res);
non_zero_received++;
}
usleep(1000);
}
#ifndef WIN32
#ifdef OS_darwin
printf("T=%p: non_zero_received=%d\n",
(void*)pthread_self(), non_zero_received);
#else
printf("T=%d: non_zero_received=%d\n",
(int)pthread_self(), non_zero_received);
#endif
#endif
}
void Run() {
printf("test142: tests PCQ annotations\n");
MyThreadArray t(Putter, Getter, Getter);
t.Start();
t.Join();
}
REGISTER_TEST(Run, 142)
} // namespace test142
// test143: TP. Check PCQ_* annotations. {{{1
namespace test143 {
// True positive.
// We have a race on GLOB between Putter and one of the Getters.
// Pure h-b will not see it.
// If FifoMessageQueue was annotated using HAPPENS_BEFORE/AFTER, the race would
// be missed too.
// PCQ_* annotations do not hide this race.
int GLOB = 0;
StealthNotification n;
FifoMessageQueue q;
void Putter() {
GLOB = 1;
q.Put(1);
n.signal();
}
void Getter() {
n.wait();
q.Get();
CHECK(GLOB == 1); // Race here
}
void Run() {
q.Put(1);
if (!Tsan_PureHappensBefore()) {
ANNOTATE_EXPECT_RACE_FOR_TSAN(&GLOB, "true races");
}
printf("test143: tests PCQ annotations (true positive)\n");
MyThreadArray t(Putter, Getter, Getter);
t.Start();
t.Join();
}
REGISTER_TEST(Run, 143);
} // namespace test143
// test144: Unit-test for a bug in fast-mode {{{1
namespace test144 {
struct Foo {
int a, b;
} ALIGNED(64);
struct Foo GLOB;
int &RACEY = GLOB.a;
void Worker() {
RACEY++;
}
void Run() {
printf("test144: fast-mode bug\n");
ANNOTATE_TRACE_MEMORY(&RACEY);
ANNOTATE_EXPECT_RACE_FOR_TSAN(&RACEY, "Real race");
// This line resets GLOB's creator_tid (bug).
ANNOTATE_NEW_MEMORY(&GLOB.b, sizeof(GLOB.b));
MyThreadArray t(Worker, Worker);
t.Start();
t.Join();
}
REGISTER_TEST(Run, 144);
} // namespace test144
// test145: Unit-test for a bug in fast-mode {{{1
namespace test145 {
// A variation of test144 for dynamic memory.
struct Foo {
int a, b;
} ALIGNED(64);
struct Foo *GLOB;
int *RACEY = NULL;
void Worker() {
(*RACEY)++;
}
void Run() {
printf("test145: fast-mode bug\n");
GLOB = new Foo;
RACEY = &(GLOB->a);
ANNOTATE_TRACE_MEMORY(RACEY);
ANNOTATE_EXPECT_RACE_FOR_TSAN(RACEY, "Real race");
// This line resets GLOB's creator_tid (bug).
ANNOTATE_NEW_MEMORY(&(GLOB->b), sizeof(GLOB->b));
MyThreadArray t(Worker, Worker);
t.Start();
t.Join();
delete GLOB;
}
REGISTER_TEST(Run, 145);
} // namespace test145
// test147: allocating 1.5G of mem in one chunk. {{{1
namespace test147 {
void Run() {
printf("test147: malloc 1.5G\n");
free(malloc((1 << 30) + (1 << 29)));
}
REGISTER_TEST(Run, 147)
} // namespace test147
// test148: FN. 3 threads, h-b hides race between T1 and T3. {{{1
namespace test148 {
int GLOB = 0;
int COND = 0;
Mutex mu;
CondVar cv;
void Signaller() {
usleep(1000000);
GLOB = 1;
mu.Lock();
COND = 1;
cv.Signal();
mu.Unlock();
}
void Waiter() {
mu.Lock();
while (COND == 0)
cv.Wait(&mu);
ANNOTATE_CONDVAR_LOCK_WAIT(&cv, &mu);
GLOB = 2;
mu.Unlock();
}
void Racer() {
usleep(2000000);
mu.Lock();
GLOB = 3;
mu.Unlock();
}
void Run() {
printf("test148: FN. 3 threads, h-b hides race between T1 and T3.\n");
MyThreadArray mta(Signaller, Waiter, Racer);
mta.Start();
mta.Join();
}
REGISTER_TEST(Run, 148)
} // namespace test148
// test149: allocate and memset lots of of mem in several chunks. {{{1
namespace test149 {
void Run() {
int kChunkSize = 1 << 26;
printf("test149: malloc 8x%dM\n", kChunkSize / (1 << 20));
void *mem[8];
for (int i = 0; i < 8; i++) {
mem[i] = malloc(kChunkSize);
memset(mem[i], 0, kChunkSize);
printf("+");
}
for (int i = 0; i < 8; i++) {
free(mem[i]);
printf("-");
}
printf(" Done\n");
}
REGISTER_TEST2(Run, 149, EXCLUDE_FROM_ALL) // TODO(kcc): enable it back
} // namespace test149
// test150: race which is detected after one of the thread has joined. {{{1
namespace test150 {
int GLOB = 0;
StealthNotification n;
void Writer1() { GLOB++; }
void Writer2() {
n.wait();
GLOB++;
}
TEST(PositiveTests, RaceDetectedAfterJoin) {
ANNOTATE_EXPECT_RACE_FOR_TSAN(&GLOB, "real race");
MyThread t1(Writer1);
MyThread t2(Writer2);
t1.Start();
t2.Start();
t1.Join();
n.signal();
t2.Join();
printf("\tGLOB=%d\n", GLOB);
}
} // namespace test150
// test151: stress for the size of vector time clock. {{{1
namespace test151 {
int kNumThreads = 100;
int kNumSegments = 5000000;
void Void() { }
void Run() {
printf("test151: stress\n");
printf("Creating %d threads\n", kNumThreads);
for (int i = 0; i < kNumThreads; i++) {
MyThread t(Void);
t.Start();
t.Join();
}
printf("Creating %d segments\n", kNumSegments);
for (int i = 0; i < kNumSegments; i++) {
if (i % (kNumSegments / 50) == 0)
printf(".");
ANNOTATE_HAPPENS_BEFORE(NULL);
}
printf(" done\n");
}
REGISTER_TEST2(Run, 151, PERFORMANCE | EXCLUDE_FROM_ALL) // TODO(kcc): enable
} // namespace test151
// test152: atexit -> exit creates a h-b arc. {{{1
namespace test152 {
int GLOB = 0;
MyThread *t;
void AtExitCallback() {
GLOB++;
}
void AtExitThread() {
GLOB++;
atexit(AtExitCallback);
}
TEST(NegativeTests, AtExitTest) {
t = new MyThread(AtExitThread);
t->Start(); // We don't join it.
}
} // namespace test152
// test153: test for vanilla pthread_spinlock_t {{{1
namespace test153 {
#ifndef NO_SPINLOCK
// pthread_spinlock_t is tricky because pthread_spin_unlock and
// pthread_spin_init are the same symbol.
int GLOB = 0;
pthread_spinlock_t lock;
void Worker1() {
pthread_spin_lock(&lock);
GLOB++;
pthread_spin_unlock(&lock);
}
void Worker2() {
while (pthread_spin_trylock(&lock) != 0) { }
GLOB++;
pthread_spin_unlock(&lock);
}
void Run() {
printf("test153: pthread_spin_t\n");
for (int i = 0; i < 3; i++) {
// test few times on the same lock to check how init/destroy are handled.
pthread_spin_init(&lock, 0);
MyThreadArray t(Worker1, Worker1, Worker2, Worker2);
t.Start();
t.Join();
pthread_spin_destroy(&lock);
}
}
REGISTER_TEST(Run, 153)
#endif // NO_SPINLOCK
} // namespace test153
// test154: long test with lots of races. {{{1
namespace test154 {
const int kNumIters = 100000;
const int kArraySize = 100000;
int *arr;
void RaceyAccess(int *a) {
(*a)++;
}
void RaceyLoop() {
for (int j = 0; j < kArraySize; j++) {
RaceyAccess(&arr[j]);
}
}
void Worker() {
for (int i = 0; i < kNumIters; i++) {
usleep(1);
printf(".");
if ((i % 40) == 39)
printf("\n");
RaceyLoop();
}
}
void Run() {
arr = new int[kArraySize];
printf("test154: positive; long test with lots of races\n");
MyThreadArray t(Worker, Worker);
t.Start();
t.Join();
delete arr;
}
REGISTER_TEST2(Run, 154, EXCLUDE_FROM_ALL)
} // namespace test154
namespace PositiveTests_RaceInMemcpy { // {{{1
char *GLOB;
void DoMemcpy() {
memcpy(GLOB, GLOB + 1, 1);
}
void DoMemmove() {
memmove(GLOB, GLOB + 1, 1);
}
void Write0() {
GLOB[0] = 'z';
}
void DoStrlen() {
CHECK(strlen(GLOB) == 3);
}
void DoStrcpy() {
CHECK(strcpy(GLOB, "zzz") == GLOB);
}
void DoStrchr() {
CHECK(strchr(GLOB, 'o') == (GLOB + 1));
}
void DoMemchr() {
CHECK(memchr(GLOB, 'o', 4) == (GLOB + 1));
}
void DoStrrchr() {
CHECK(strrchr(GLOB, '!') == NULL);
}
void DoStrcmp() {
CHECK(strcmp(GLOB, "xxx") != 0);
}
void DoStrncmp() {
CHECK(strncmp(GLOB, "xxx", 3) != 0);
}
void RunThreads(void (*f1)(void), void (*f2)(void), char *mem) {
GLOB = mem;
strcpy(GLOB, "foo");
ANNOTATE_EXPECT_RACE_FOR_TSAN(GLOB, "expected race");
MyThreadArray t(f1, f2);
t.Start();
t.Join();
}
TEST(PositiveTests, RaceInMemcpy) {
static char mem[4];
RunThreads(DoMemcpy, DoMemcpy, mem);
}
TEST(PositiveTests, RaceInMemmove) {
static char mem[4];
RunThreads(DoMemmove, DoMemmove, mem);
}
TEST(PositiveTests, RaceInStrlen1) {
static char mem[4];
RunThreads(DoStrlen, Write0, mem);
}
TEST(PositiveTests, RaceInStrlen2) {
static char mem[4];
RunThreads(Write0, DoStrlen, mem);
}
TEST(PositiveTests, RaceInStrcpy) {
static char mem[4];
RunThreads(Write0, DoStrcpy, mem);
}
TEST(PositiveTests, RaceInStrchr) {
static char mem[4];
RunThreads(Write0, DoStrchr, mem);
}
TEST(PositiveTests, RaceInMemchr) {
static char mem[4];
RunThreads(Write0, DoMemchr, mem);
}
TEST(PositiveTests, RaceInStrrchr) {
static char mem[4];
RunThreads(Write0, DoStrrchr, mem);
}
TEST(PositiveTests, RaceInStrcmp) {
static char mem[4];
RunThreads(Write0, DoStrcmp, mem);
}
TEST(PositiveTests, RaceInStrncmp) {
static char mem[4];
RunThreads(Write0, DoStrncmp, mem);
}
} // namespace
// test157: TN. Test for stack traces (using ANNOTATE_NO_OP). {{{1
namespace test157 {
void func3() {
ANNOTATE_NO_OP((void*)__LINE__);
}
void func2() {
func3();
}
void func1() {
func2();
}
void Worker1() {
func1();
ANNOTATE_NO_OP((void*)__LINE__);
}
void Worker2() {
func2();
ANNOTATE_NO_OP((void*)__LINE__);
}
void Worker3() {
func3();
ANNOTATE_NO_OP((void*)__LINE__);
}
void Run() {
ANNOTATE_NO_OP((void*)__LINE__);
printf("test157: negative\n");
ANNOTATE_NO_OP((void*)__LINE__);
MyThreadArray t(Worker1, Worker2, Worker3);
ANNOTATE_NO_OP((void*)__LINE__);
t.Start();
ANNOTATE_NO_OP((void*)__LINE__);
t.Join();
ANNOTATE_NO_OP((void*)__LINE__);
}
REGISTER_TEST(Run, 157);
} // namespace test157
namespace MemoryTypes { // {{{1
void WriteChar(void *param) {
*(char*)param = 1;
usleep(500000); // let other threads hit this before exiting.
}
void RaceOnMemory(void (*callback)(void *), char *mem) {
ANNOTATE_FLUSH_EXPECTED_RACES();
ANNOTATE_EXPECT_RACE(mem, "race");
MyThread t1(callback, mem),
t2(callback, mem);
t1.Start();
t2.Start();
t1.Join();
t2.Join();
CHECK(*mem == 1);
ANNOTATE_FLUSH_EXPECTED_RACES();
}
void RaceOnLocalStack(void (*callback)(void *)) {
char object_on_stack = 0;
// We may have had races on the main stack before -- forget about them.
ANNOTATE_NEW_MEMORY(&object_on_stack, 1);
RaceOnMemory(callback, &object_on_stack);
}
// create a new function to make reports different.
void WriteChar1(void *param) { WriteChar(param); }
TEST(MemoryTypes, RaceOnMainThreadStack) {
RaceOnLocalStack(WriteChar1);
}
void WriteChar2(void *param) { WriteChar(param); }
TEST(MemoryTypes, RaceOnNonMainThreadStack) {
MyThread t((void (*)(void*))(RaceOnLocalStack), (void*)WriteChar2);
t.Start();
t.Join();
}
void WriteChar3(void *param) { WriteChar(param); }
TEST(MemoryTypes, RaceOnMallocedMemory) {
char *mem = (char*)malloc(100);
RaceOnMemory(WriteChar3, mem+42);
free(mem);
}
void WriteChar4(void *param) { WriteChar(param); }
TEST(MemoryTypes, RaceOnCallocedMemory) {
char *mem = (char*)calloc(30, 4);
RaceOnMemory(WriteChar4, mem+42);
free(mem);
}
void WriteChar5(void *param) { WriteChar(param); }
TEST(MemoryTypes, RaceOnMemoryFromNew) {
char *mem = new char;
RaceOnMemory(WriteChar5, mem);
delete mem;
}
void WriteChar6(void *param) { WriteChar(param); }
TEST(MemoryTypes, RaceOnMemoryFromNewA) {
char *mem = new char [100];
RaceOnMemory(WriteChar6, mem+42);
delete [] mem;
}
void WriteChar7(void *param) { WriteChar(param); }
TEST(MemoryTypes, RaceOnMemoryFromNewNoThrow) {
char *mem = new (std::nothrow) char;
RaceOnMemory(WriteChar7, mem);
operator delete (mem, std::nothrow);
}
void WriteChar8(void *param) { WriteChar(param); }
TEST(MemoryTypes, RaceOnMemoryFromNewNoThrowA) {
char *mem = new (std::nothrow) char [100];
RaceOnMemory(WriteChar8, mem+42);
operator delete [] (mem, std::nothrow);
}
void AllocateAndDeallocateUsingVariousAllocs() {
for (int i = 0; i < 10000; i++) {
char *p;
switch (i % 5) {
case 0:
p = (char*)malloc(10);
free(p);
break;
case 1:
p = new char;
delete p;
break;
case 2:
p = new char [10];
delete [] p;
case 3:
p = new (std::nothrow) char;
operator delete (p, std::nothrow);
break;
case 4:
p = new (std::nothrow) char[10];
operator delete [](p, std::nothrow);
break;
}
}
}
TEST(MemoryTypes, VariousAllocs) {
void (*f)(void) = AllocateAndDeallocateUsingVariousAllocs;
MyThreadArray t(f, f, f, f);
t.Start();
t.Join();
}
void ReallocThread() {
void *ptr = NULL;
for (int i = 8; i < 128; i++) {
int size = (1 << (i / 8)) - 1;
ptr = realloc(ptr, size);
ANNOTATE_TRACE_MEMORY(ptr);
memset(ptr, 42, size);
}
free(ptr);
}
TEST(MemoryTypes, Reallocs) {
MyThreadArray t(ReallocThread, ReallocThread, ReallocThread, ReallocThread);
t.Start();
t.Join();
}
} // namespace
namespace StressTests_ThreadTree { //{{{1
int GLOB = 0;
// Worker(N) will do 2^N increments of GLOB, each increment in a separate thread
void Worker(int depth) {
CHECK(depth >= 0);
if (depth > 0) {
MyThread t1((MyThread::worker_t)Worker, (void*)(intptr_t)(depth - 1));
MyThread t2((MyThread::worker_t)Worker, (void*)(intptr_t)(depth - 1));
t1.Start();
t2.Start();
t1.Join();
t2.Join();
} else {
GLOB++; // Race here
}
}
TEST(StressTests, ThreadTree3) {
ANNOTATE_EXPECT_RACE(&GLOB, "StressTests.ThreadTree3 race");
ANNOTATE_TRACE_MEMORY(&GLOB);
Worker(3);
}
TEST(StressTests, DISABLED_ThreadTree7) {
ANNOTATE_EXPECT_RACE(&GLOB, "StressTests.ThreadTree7 race");
ANNOTATE_TRACE_MEMORY(&GLOB);
Worker(7);
}
} // namespace test313
namespace StressTests_StartAndJoinManyThreads { //{{{1
void Worker() {
}
// Too slow. Need to run it separately.
TEST(StressTests, StartAndJoinManyThreads) {
ANNOTATE_FLUSH_STATE();
for (int i = 0; i < 1100; i++) {
if ((i % 100) == 0)
printf(".");
MyThread t1(Worker);
MyThread t2(Worker);
t1.Start();
t2.Start();
t1.Join();
t2.Join();
}
printf("\n");
}
} // namespace
namespace StressTests_ManyAccesses { // {{{1
#ifndef NO_BARRIER
const int kArrayLen = 128; // Small size, so that everything fits into cache.
const int kNumIter = 1024 * 1024 * 2;
int thread_id;
int *array = NULL;
Barrier *barrier;
void IncrementMe(int *x) {
(*x)++;
}
void NoRaceWorker() {
int id = AtomicIncrement(&thread_id, 1);
barrier->Block();
int *ptr = array + id * (kArrayLen + 64); // pad to avoid false sharing.
for (int it = 0; it < kNumIter; it++) {
for (int i = 0; i < kArrayLen; i++) {
IncrementMe(ptr + i);
}
}
}
void RunThreads(int n_threads, void (*f)(void)) {
thread_id = -1;
barrier = new Barrier(n_threads);
// Allocate a lot so that operator new uses mmap, unless forced to use brk.
array = new int[(kArrayLen + 64) * n_threads + (1 << 22)];
printf("ptr = %p\n", array);
MyThread **t = new MyThread*[n_threads];
for (int i = 0; i < n_threads; i++) t[i] = new MyThread(NoRaceWorker);
for (int i = 0; i < n_threads; i++) t[i]->Start();
for (int i = 0; i < n_threads; i++) t[i]->Join();
for (int i = 0; i < n_threads; i++) delete t[i];
delete [] t;
delete [] array;
}
// Just one thread.
TEST(StressTests, DISABLED_ManyAccessesNoRace1Test) {
RunThreads(1, NoRaceWorker);
}
// 2 threads accessing different memory.
TEST(StressTests, DISABLED_ManyAccessesNoRace2Test) {
RunThreads(2, NoRaceWorker);
}
// 4 threads accessing different memory.
TEST(StressTests, DISABLED_ManyAccessesNoRace4Test) {
RunThreads(4, NoRaceWorker);
}
// 8 threads accessing different memory.
TEST(StressTests, DISABLED_ManyAccessesNoRace8Test) {
RunThreads(8, NoRaceWorker);
}
// 16 threads accessing different memory.
TEST(StressTests, DISABLED_ManyAccessesNoRace16Test) {
RunThreads(16, NoRaceWorker);
}
#endif // NO_BARRIER
} // namespace
namespace NegativeTests_EnableRaceDetectionTest { // {{{1
const size_t size = 10000;
const size_t n_iter = 1000;
int GLOB[size];
void Worker() {
for (size_t i = 0; i < n_iter; i++) {
for (size_t j = 0; j < size; j++) {
GLOB[j]++;
}
}
}
TEST(NegativeTests, EnableRaceDetectionTest) {
ANNOTATE_ENABLE_RACE_DETECTION(0);
MyThreadArray t(Worker, Worker, Worker, Worker);
t.Start();
t.Join();
ANNOTATE_ENABLE_RACE_DETECTION(1);
}
}
namespace PositiveTests_MopVsFree { // {{{1
int *p;
const int kIdx = 77;
StealthNotification n;
void Read() {
CHECK(p[kIdx] == 777);
n.signal();
}
void Free() {
n.wait();
free(p);
}
TEST(PositiveTests, ReadVsFree) {
p = (int*)malloc(100 * sizeof(int));
p[kIdx] = 777;
ANNOTATE_EXPECT_RACE(&p[kIdx], "race: read vs free");
MyThreadArray t(Read, Free);
t.Start();
t.Join();
}
} // namespace
namespace ManySmallObjectsTest { // {{{1
void Worker() {
const int N = 1 << 21;
struct T {
int a, b, c, d;
T() : a(1), b(2), c(3), d(4) { }
};
T **a = new T*[N];
for (int i = 0; i < N; i++) {
if ((i % (N / 16)) == 0)
printf("+");
a[i] = new T;
CHECK(a[i]->a == 1);
}
printf("\n");
for (int i = 0; i < N; i++) {
if ((i % (N / 16)) == 0)
printf("-");
delete a[i];
}
printf("\n");
delete [] a;
}
TEST(StressTests, DISABLED_ManySmallObjectsOneThreadTest) {
Worker();
}
TEST(StressTests, DISABLED_ManySmallObjectsTwoThreadsTest) {
MyThreadArray t(Worker, Worker);
t.Start();
t.Join();
}
} // namespace
namespace RepPrefixedInstructionsTest { //{{{1
#if defined (__GNUC__) && (defined(ARCH_x86) || defined(ARCH_amd64))
void rep_clr_1(uint8_t *s, long n)
{
intptr_t d0, d1;
__asm__ __volatile__ (
"rep ; stosb"
: "=&c" (d0), "=&D" (d1)
: "a" (0), "1" (s), "0" (n)
: "memory");
}
uint8_t mem1[1000];
void Clr1_0_10() { rep_clr_1(mem1+ 0, 10); }
void Clr1_10_10() { rep_clr_1(mem1+10, 10); }
void Clr1_10_0() { rep_clr_1(mem1+10, 0); }
void Clr1_25_1() { rep_clr_1(mem1+25, 1); }
void Clr1_25_0() { rep_clr_1(mem1+25, 0); }
void Clr1_50_30() { rep_clr_1(mem1+50, 30); }
void Clr1_60_0() { rep_clr_1(mem1+60, 0); }
void Clr1_60_1() { rep_clr_1(mem1+60, 1); }
void Clr1_70_10() { rep_clr_1(mem1+70, 10); }
void RunThreads(void (*f1)(void), void (*f2)(void)) {
MyThreadArray t(f1, f2);
t.Start();
t.Join();
}
TEST(NegativeTests, RepSanityTest) {
memset(mem1, 0xff, sizeof(mem1));
rep_clr_1(mem1, 0);
CHECK(mem1[0] != 0);
rep_clr_1(mem1, 1);
CHECK(mem1[0] == 0);
CHECK(mem1[1] != 0);
rep_clr_1(mem1, 5);
CHECK(mem1[4] == 0);
CHECK(mem1[5] != 0);
}
TEST(NegativeTests, RepNegativeTest) {
memset(mem1, 0xff, sizeof(mem1));
RunThreads(Clr1_0_10, Clr1_10_10);
RunThreads(Clr1_10_0, Clr1_10_10);
RunThreads(Clr1_25_0, Clr1_25_1);
RunThreads(Clr1_50_30, Clr1_60_0);
}
TEST(PositiveTests, RepPositive1Test) {
memset(mem1, 0xff, sizeof(mem1));
ANNOTATE_EXPECT_RACE(mem1+10, "real race");
for (int i = 11; i < 20; i++) ANNOTATE_BENIGN_RACE(mem1 + i, "");
RunThreads(Clr1_10_10, Clr1_10_10);
}
TEST(PositiveTests, RepPositive2Test) {
memset(mem1, 0xff, sizeof(mem1));
ANNOTATE_EXPECT_RACE(mem1+25, "real race");
RunThreads(Clr1_25_1, Clr1_25_1);
}
TEST(PositiveTests, RepPositive3Test) {
memset(mem1, 0xff, sizeof(mem1));
ANNOTATE_EXPECT_RACE(mem1+60, "real race");
RunThreads(Clr1_50_30, Clr1_60_1);
}
TEST(PositiveTests, RepPositive4Test) {
memset(mem1, 0xff, sizeof(mem1));
ANNOTATE_EXPECT_RACE(mem1+70, "real race");
for (int i = 71; i < 80; i++) ANNOTATE_BENIGN_RACE(mem1 + i, "");
RunThreads(Clr1_50_30, Clr1_70_10);
}
#endif // __GNUC__ ...
} // namespace
// test400: Demo of a simple false positive. {{{1
namespace test400 {
static Mutex mu;
static vector<int> *vec; // GUARDED_BY(mu);
void InitAllBeforeStartingThreads() {
vec = new vector<int>;
vec->push_back(1);
vec->push_back(2);
}
void Thread1() {
MutexLock lock(&mu);
vec->pop_back();
}
void Thread2() {
MutexLock lock(&mu);
vec->pop_back();
}
//---- Sub-optimal code ---------
size_t NumberOfElementsLeft() {
MutexLock lock(&mu);
return vec->size();
}
void WaitForAllThreadsToFinish_InefficientAndTsanUnfriendly() {
while(NumberOfElementsLeft()) {
; // sleep or print or do nothing.
}
// It is now safe to access vec w/o lock.
// But a hybrid detector (like ThreadSanitizer) can't see it.
// Solutions:
// 1. Use pure happens-before detector (e.g. "tsan --pure-happens-before")
// 2. Call ANNOTATE_PURE_HAPPENS_BEFORE_MUTEX(&mu)
// in InitAllBeforeStartingThreads()
// 3. (preferred) Use WaitForAllThreadsToFinish_Good() (see below).
CHECK(vec->empty());
delete vec;
}
//----- Better code -----------
bool NoElementsLeft(vector<int> *v) {
return v->empty();
}
void WaitForAllThreadsToFinish_Good() {
mu.LockWhen(Condition(NoElementsLeft, vec));
mu.Unlock();
// It is now safe to access vec w/o lock.
CHECK(vec->empty());
delete vec;
}
void Run() {
MyThreadArray t(Thread1, Thread2);
InitAllBeforeStartingThreads();
t.Start();
WaitForAllThreadsToFinish_InefficientAndTsanUnfriendly();
// WaitForAllThreadsToFinish_Good();
t.Join();
}
REGISTER_TEST2(Run, 400, RACE_DEMO)
} // namespace test400
// test401: Demo of false positive caused by reference counting. {{{1
namespace test401 {
// A simplified example of reference counting.
// DecRef() does ref count increment in a way unfriendly to race detectors.
// DecRefAnnotated() does the same in a friendly way.
static vector<int> *vec;
static int ref_count;
void InitAllBeforeStartingThreads(int number_of_threads) {
vec = new vector<int>;
vec->push_back(1);
ref_count = number_of_threads;
}
// Correct, but unfriendly to race detectors.
int DecRef() {
return AtomicIncrement(&ref_count, -1);
}
// Correct and friendly to race detectors.
int DecRefAnnotated() {
ANNOTATE_HAPPENS_BEFORE(&ref_count);
int res = AtomicIncrement(&ref_count, -1);
if (res == 0) {
ANNOTATE_HAPPENS_AFTER(&ref_count);
}
return res;
}
void ThreadWorker() {
CHECK(ref_count > 0);
CHECK(vec->size() == 1);
if (DecRef() == 0) { // Use DecRefAnnotated() instead!
// No one uses vec now ==> delete it.
delete vec; // A false race may be reported here.
vec = NULL;
}
}
void Run() {
MyThreadArray t(ThreadWorker, ThreadWorker, ThreadWorker);
InitAllBeforeStartingThreads(3 /*number of threads*/);
t.Start();
t.Join();
CHECK(vec == 0);
}
REGISTER_TEST2(Run, 401, RACE_DEMO)
} // namespace test401
// test502: produce lots of segments without cross-thread relations {{{1
namespace test502 {
/*
* This test produces ~1Gb of memory usage when run with the following options:
*
* --tool=helgrind
* --trace-after-race=0
* --num-callers=2
* --more-context=no
*/
Mutex MU;
int GLOB = 0;
void TP() {
for (int i = 0; i < 750000; i++) {
MU.Lock();
GLOB++;
MU.Unlock();
}
}
void Run() {
MyThreadArray t(TP, TP);
printf("test502: produce lots of segments without cross-thread relations\n");
t.Start();
t.Join();
}
REGISTER_TEST2(Run, 502, MEMORY_USAGE | PRINT_STATS | EXCLUDE_FROM_ALL
| PERFORMANCE)
} // namespace test502
// test503: produce lots of segments with simple HB-relations {{{1
// HB cache-miss rate is ~55%
namespace test503 {
// |- | | | | |
// | \| | | | |
// | |- | | | |
// | | \| | | |
// | | |- | | |
// | | | \| | |
// | | | |- | |
// | | | | \| |
// | | | | |- |
// | | | | | \|
// | | | | | |----
//->| | | | | |
// |- | | | | |
// | \| | | | |
// ...
const int N_threads = 32;
const int ARRAY_SIZE = 128;
int GLOB[ARRAY_SIZE];
ProducerConsumerQueue *Q[N_threads];
int GLOB_limit = 100000;
int count = -1;
void Worker(){
int myId = AtomicIncrement(&count, 1);
ProducerConsumerQueue &myQ = *Q[myId], &nextQ = *Q[(myId+1) % N_threads];
// this code produces a new SS with each new segment
while (myQ.Get() != NULL) {
for (int i = 0; i < ARRAY_SIZE; i++)
GLOB[i]++;
if (myId == 0 && GLOB[0] > GLOB_limit) {
// Stop all threads
for (int i = 0; i < N_threads; i++)
Q[i]->Put(NULL);
} else
nextQ.Put(GLOB);
}
}
void Run() {
printf("test503: produce lots of segments with simple HB-relations\n");
for (int i = 0; i < N_threads; i++)
Q[i] = new ProducerConsumerQueue(1);
Q[0]->Put(GLOB);
{
ThreadPool pool(N_threads);
pool.StartWorkers();
for (int i = 0; i < N_threads; i++) {
pool.Add(NewCallback(Worker));
}
} // all folks are joined here.
for (int i = 0; i < N_threads; i++)
delete Q[i];
}
REGISTER_TEST2(Run, 503, MEMORY_USAGE | PRINT_STATS
| PERFORMANCE | EXCLUDE_FROM_ALL)
} // namespace test503
// test504: force massive cache fetch-wback (50% misses, mostly CacheLineZ) {{{1
namespace test504 {
#if !defined(WINE) and !defined(ANDROID) // Valgrind+wine hate large static objects
const int N_THREADS = 2,
HG_CACHELINE_COUNT = 1 << 16,
HG_CACHELINE_SIZE = 1 << 6,
HG_CACHE_SIZE = HG_CACHELINE_COUNT * HG_CACHELINE_SIZE;
// int gives us ~4x speed of the byte test
// 4x array size gives us
// total multiplier of 16x over the cachesize
// so we can neglect the cached-at-the-end memory
const int ARRAY_SIZE = 4 * HG_CACHE_SIZE,
ITERATIONS = 30;
int array[ARRAY_SIZE];
int count = 0;
Mutex count_mu;
void Worker() {
count_mu.Lock();
int myId = ++count;
count_mu.Unlock();
// all threads write to different memory locations,
// so no synchronization mechanisms are needed
int lower_bound = ARRAY_SIZE * (myId-1) / N_THREADS,
upper_bound = ARRAY_SIZE * ( myId ) / N_THREADS;
for (int j = 0; j < ITERATIONS; j++)
for (int i = lower_bound; i < upper_bound;
i += HG_CACHELINE_SIZE / sizeof(array[0])) {
array[i] = i; // each array-write generates a cache miss
}
}
void Run() {
printf("test504: force massive CacheLineZ fetch-wback\n");
MyThreadArray t(Worker, Worker);
t.Start();
t.Join();
}
REGISTER_TEST2(Run, 504, PERFORMANCE | PRINT_STATS | EXCLUDE_FROM_ALL)
#endif // WINE
} // namespace test504
// test505: force massive cache fetch-wback (60% misses) {{{1
// modification of test504 - more threads, byte accesses and lots of mutexes
// so it produces lots of CacheLineF misses (30-50% of CacheLineZ misses)
namespace test505 {
#if !defined(WINE) and !defined(ANDROID) // Valgrind+wine hate large static objects
const int N_THREADS = 2,
HG_CACHELINE_COUNT = 1 << 16,
HG_CACHELINE_SIZE = 1 << 6,
HG_CACHE_SIZE = HG_CACHELINE_COUNT * HG_CACHELINE_SIZE;
const int ARRAY_SIZE = 4 * HG_CACHE_SIZE,
ITERATIONS = 3;
int64_t array[ARRAY_SIZE];
int count = 0;
Mutex count_mu;
void Worker() {
const int N_MUTEXES = 5;
Mutex mu[N_MUTEXES];
count_mu.Lock();
int myId = ++count;
count_mu.Unlock();
// all threads write to different memory locations,
// so no synchronization mechanisms are needed
int lower_bound = ARRAY_SIZE * (myId-1) / N_THREADS,
upper_bound = ARRAY_SIZE * ( myId ) / N_THREADS;
for (int j = 0; j < ITERATIONS; j++)
for (int mutex_id = 0; mutex_id < N_MUTEXES; mutex_id++) {
Mutex *m = & mu[mutex_id];
m->Lock();
for (int i = lower_bound + mutex_id, cnt = 0;
i < upper_bound;
i += HG_CACHELINE_SIZE / sizeof(array[0]), cnt++) {
array[i] = i; // each array-write generates a cache miss
}
m->Unlock();
}
}
void Run() {
printf("test505: force massive CacheLineF fetch-wback\n");
MyThreadArray t(Worker, Worker);
t.Start();
t.Join();
}
REGISTER_TEST2(Run, 505, PERFORMANCE | PRINT_STATS | EXCLUDE_FROM_ALL)
#endif // WINE
} // namespace test505
// test506: massive HB's using Barriers {{{1
// HB cache miss is ~40%
// segments consume 10x more memory than SSs
// modification of test39
namespace test506 {
#ifndef NO_BARRIER
// Same as test17 but uses Barrier class (pthread_barrier_t).
int GLOB = 0;
const int N_threads = 64,
ITERATIONS = 1000;
Barrier *barrier[ITERATIONS];
Mutex MU;
void Worker() {
for (int i = 0; i < ITERATIONS; i++) {
MU.Lock();
GLOB++;
MU.Unlock();
barrier[i]->Block();
}
}
void Run() {
printf("test506: massive HB's using Barriers\n");
for (int i = 0; i < ITERATIONS; i++) {
barrier[i] = new Barrier(N_threads);
}
{
ThreadPool pool(N_threads);
pool.StartWorkers();
for (int i = 0; i < N_threads; i++) {
pool.Add(NewCallback(Worker));
}
} // all folks are joined here.
CHECK(GLOB == N_threads * ITERATIONS);
for (int i = 0; i < ITERATIONS; i++) {
delete barrier[i];
}
}
REGISTER_TEST2(Run, 506, PERFORMANCE | PRINT_STATS | EXCLUDE_FROM_ALL);
#endif // NO_BARRIER
} // namespace test506
// test507: vgHelgrind_initIterAtFM/stackClear benchmark {{{1
// vgHelgrind_initIterAtFM/stackClear consume ~8.5%/5.5% CPU
namespace test507 {
const int N_THREADS = 1,
BUFFER_SIZE = 1,
ITERATIONS = 1 << 20;
void Foo() {
struct T {
char temp;
T() {
ANNOTATE_RWLOCK_CREATE(&temp);
}
~T() {
ANNOTATE_RWLOCK_DESTROY(&temp);
}
} s[BUFFER_SIZE];
s->temp = '\0';
}
void Worker() {
for (int j = 0; j < ITERATIONS; j++) {
Foo();
}
}
void Run() {
printf("test507: vgHelgrind_initIterAtFM/stackClear benchmark\n");
{
ThreadPool pool(N_THREADS);
pool.StartWorkers();
for (int i = 0; i < N_THREADS; i++) {
pool.Add(NewCallback(Worker));
}
} // all folks are joined here.
}
REGISTER_TEST2(Run, 507, EXCLUDE_FROM_ALL);
} // namespace test507
// test508: cmp_WordVecs_for_FM benchmark {{{1
// 50+% of CPU consumption by cmp_WordVecs_for_FM
namespace test508 {
const int N_THREADS = 1,
BUFFER_SIZE = 1 << 10,
ITERATIONS = 1 << 9;
void Foo() {
struct T {
char temp;
T() {
ANNOTATE_RWLOCK_CREATE(&temp);
}
~T() {
ANNOTATE_RWLOCK_DESTROY(&temp);
}
} s[BUFFER_SIZE];
s->temp = '\0';
}
void Worker() {
for (int j = 0; j < ITERATIONS; j++) {
Foo();
}
}
void Run() {
printf("test508: cmp_WordVecs_for_FM benchmark\n");
{
ThreadPool pool(N_THREADS);
pool.StartWorkers();
for (int i = 0; i < N_THREADS; i++) {
pool.Add(NewCallback(Worker));
}
} // all folks are joined here.
}
REGISTER_TEST2(Run, 508, EXCLUDE_FROM_ALL);
} // namespace test508
// test509: avl_find_node benchmark {{{1
// 10+% of CPU consumption by avl_find_node
namespace test509 {
const int N_THREADS = 16,
ITERATIONS = 1 << 8;
void Worker() {
std::vector<Mutex*> mu_list;
for (int i = 0; i < ITERATIONS; i++) {
Mutex * mu = new Mutex();
mu_list.push_back(mu);
mu->Lock();
}
for (int i = ITERATIONS - 1; i >= 0; i--) {
Mutex * mu = mu_list[i];
mu->Unlock();
delete mu;
}
}
void Run() {
printf("test509: avl_find_node benchmark\n");
{
ThreadPool pool(N_THREADS);
pool.StartWorkers();
for (int i = 0; i < N_THREADS; i++) {
pool.Add(NewCallback(Worker));
}
} // all folks are joined here.
}
REGISTER_TEST2(Run, 509, EXCLUDE_FROM_ALL);
} // namespace test509
// test510: SS-recycle test {{{1
// this tests shows the case where only ~1% of SS are recycled
namespace test510 {
const int N_THREADS = 16,
ITERATIONS = 1 << 10;
int GLOB = 0;
void Worker() {
usleep(100000);
for (int i = 0; i < ITERATIONS; i++) {
ANNOTATE_CONDVAR_SIGNAL((void*)0xDeadBeef);
GLOB++;
usleep(10);
}
}
void Run() {
//ANNOTATE_BENIGN_RACE(&GLOB, "Test");
printf("test510: SS-recycle test\n");
{
ThreadPool pool(N_THREADS);
pool.StartWorkers();
for (int i = 0; i < N_THREADS; i++) {
pool.Add(NewCallback(Worker));
}
} // all folks are joined here.
}
REGISTER_TEST2(Run, 510, MEMORY_USAGE | PRINT_STATS | EXCLUDE_FROM_ALL);
} // namespace test510
// test511: Segment refcounting test ('1' refcounting) {{{1
namespace test511 {
int GLOB = 0;
void Run () {
for (int i = 0; i < 300; i++) {
ANNOTATE_CONDVAR_SIGNAL(&GLOB);
usleep(1000);
GLOB++;
ANNOTATE_CONDVAR_WAIT(&GLOB);
}
}
REGISTER_TEST2(Run, 511, MEMORY_USAGE | PRINT_STATS | EXCLUDE_FROM_ALL);
} // namespace test511
// test512: Access the same memory with big intersecting LockSets {{{1
namespace test512 {
const int N_MUTEXES = 128;
const int DATA_SIZE = 1024;
Mutex mu[N_MUTEXES];
int GLOB[DATA_SIZE];
void TP() {
Mutex thread_mu;
thread_mu.Lock();
for (int j = 0; j < 10; j++) {
for (int m = 0; m < N_MUTEXES; m++)
mu[m].Lock();
for (int i = 0; i < 3000; i++) {
ANNOTATE_CONDVAR_SIGNAL(&GLOB); // Force new segment
for (int k = 0; k < DATA_SIZE; k++)
GLOB[k] = 42;
}
for (int m = 0; m < N_MUTEXES; m++)
mu[m].Unlock();
}
thread_mu.Unlock();
}
void Run() {
MyThreadArray t(TP, TP);
printf("test512: Access the same memory with big intersecting LockSets.\n");
t.Start();
t.Join();
}
REGISTER_TEST2(Run, 512, EXCLUDE_FROM_ALL | PERFORMANCE)
} // namespace test512
// test513: --fast-mode benchmark {{{1
namespace test513 {
const int N_THREADS = 2,
HG_CACHELINE_SIZE = 1 << 6,
ARRAY_SIZE = HG_CACHELINE_SIZE * 512,
MUTEX_ID_BITS = 8,
MUTEX_ID_MASK = (1 << MUTEX_ID_BITS) - 1;
// Each thread has its own cacheline and tackles with it intensively
const int ITERATIONS = 1024;
int array[N_THREADS][ARRAY_SIZE];
int count = 0;
Mutex count_mu;
Mutex mutex_arr[N_THREADS][MUTEX_ID_BITS];
void Worker() {
count_mu.Lock();
int myId = count++;
count_mu.Unlock();
// all threads write to different memory locations
for (int j = 0; j < ITERATIONS; j++) {
int mutex_mask = j & MUTEX_ID_BITS;
for (int m = 0; m < MUTEX_ID_BITS; m++)
if (mutex_mask & (1 << m))
mutex_arr[myId][m].Lock();
for (int i = 0; i < ARRAY_SIZE; i++) {
array[myId][i] = i;
}
for (int m = 0; m < MUTEX_ID_BITS; m++)
if (mutex_mask & (1 << m))
mutex_arr[myId][m].Unlock();
}
}
void Run() {
printf("test513: --fast-mode benchmark\n");
{
ThreadPool pool(N_THREADS);
pool.StartWorkers();
for (int i = 0; i < N_THREADS; i++) {
pool.Add(NewCallback(Worker));
}
} // all folks are joined here.
}
REGISTER_TEST2(Run, 513, PERFORMANCE | PRINT_STATS | EXCLUDE_FROM_ALL)
} // namespace test513
namespace ThreadChainTest { // {{{1 Reg test for thread creation
void Thread1() { }
void Thread2() {
MyThread t(Thread1);
t.Start();
t.Join();
}
void Thread3() {
MyThread t(Thread2);
t.Start();
t.Join();
}
void Thread4() {
MyThread t(Thread3);
t.Start();
t.Join();
}
TEST(RegTests, ThreadChainTest) {
Thread4();
}
} // namespace
#ifndef ANDROID // GTest does not support ASSERT_DEBUG_DEATH.
namespace SimpleDeathTest { // {{{1 Make sure that the tool handles death tests correctly
#ifdef WIN32
TEST(DeathTests, DISABLED_SimpleDeathTest) {
#else
TEST(DeathTests, SimpleDeathTest) {
#endif
ASSERT_DEBUG_DEATH(CHECK(false), "");
}
} // namespace
#endif
namespace IgnoreTests { // {{{1 Test how the tool works with indirect calls to fun_r functions
int GLOB = 0;
void (*f)() = NULL;
void NotIgnoredRacey() {
GLOB++;
}
void FunRFunction() {
NotIgnoredRacey();
usleep(1); // avoid tail call elimination
}
void DoDirectCall() {
FunRFunction();
usleep(1); // avoid tail call elimination
}
void DoIndirectCall() {
(*f)();
usleep(1); // avoid tail call elimination
}
TEST(IgnoreTests, DirectCallToFunR) {
MyThreadArray mta(DoDirectCall, DoDirectCall);
mta.Start();
mta.Join();
}
TEST(IgnoreTests, IndirectCallToFunR) {
f = FunRFunction;
MyThreadArray mta(DoIndirectCall, DoIndirectCall);
mta.Start();
mta.Join();
}
} // namespace
namespace MutexNotPhbTests {
int GLOB = 0;
Mutex mu;
StealthNotification n;
void SignalThread() {
GLOB = 1;
mu.Lock();
mu.Unlock();
n.signal();
}
void WaitThread() {
n.wait();
mu.Lock();
mu.Unlock();
GLOB = 2;
}
TEST(MutexNotPhbTests, MutexNotPhbTest) {
ANNOTATE_NOT_HAPPENS_BEFORE_MUTEX(&mu);
ANNOTATE_EXPECT_RACE(&GLOB, "MutexNotPhbTest. TP.");
MyThreadArray mta(SignalThread, WaitThread);
mta.Start();
mta.Join();
}
} // namespace
namespace RaceVerifierTests_Simple {
int GLOB = 0;
void Worker1() {
GLOB = 1;
}
void Worker2() {
GLOB = 2;
}
TEST(RaceVerifierTests, Simple) {
ANNOTATE_EXPECT_RACE(&GLOB, "SimpleRace.");
MyThreadArray t(Worker1, Worker2);
t.Start();
t.Join();
}
} // namespace
namespace RaceVerifierTests_Unverifiable {
StealthNotification n;
int GLOB = 0;
void Worker1() {
if (!GLOB)
GLOB = 1;
n.signal();
}
void Worker2() {
n.wait();
GLOB = 2;
}
TEST(RaceVerifierTests, Unverifiable) {
ANNOTATE_EXPECT_RACE(&GLOB, "SimpleRace. UNVERIFIABLE.");
MyThreadArray t(Worker1, Worker2);
t.Start();
t.Join();
}
} // namespace
namespace RaceVerifierTests_ManyRacesInOneTrace {
StealthNotification n;
int array[2];
void Worker1() {
array[0] = 1;
array[1] = 2;
}
void Worker2() {
array[1] = array[0];
}
TEST(RaceVerifierTests, ManyRacesInOneTrace) {
ANNOTATE_EXPECT_RACE(array + 0, "RaceVerifierTests_ManyRacesInOneTrace: race 1.");
ANNOTATE_EXPECT_RACE(array + 1, "RaceVerifierTests_ManyRacesInOneTrace: race 2.");
MyThreadArray t(Worker1, Worker2);
t.Start();
t.Join();
}
} // namespace
namespace PrintfTests_Simple {
void Worker1() {
// This one is a printf() => vfprintf()
fprintf(stderr, "Hello from a thread: %d\n", 2);
// This one is a puts()
fprintf(stderr, "Hello from a thread\n");
fprintf(stdout, "Hello from a thread: %d\n", 2);
fprintf(stdout, "Hello from a thread\n");
}
TEST(PrintfTests, DISABLED_Simple) {
MyThreadArray t(Worker1, Worker1);
t.Start();
t.Join();
}
} // namespace
namespace PrintfTests_RaceOnFwriteArgument {
char s[] = "abracadabra\n";
void Worker1() {
fwrite(s, 1, sizeof(s) - 1, stdout);
}
void Worker2() {
s[3] = 'z';
}
TEST(PrintfTests, RaceOnFwriteArgument) {
ANNOTATE_TRACE_MEMORY(s + 3);
ANNOTATE_EXPECT_RACE(s + 3, "PrintfTests_RaceOnFwriteArgument.");
MyThreadArray t(Worker1, Worker2);
t.Start();
t.Join();
}
} // namespace
namespace PrintfTests_RaceOnPutsArgument {
char s[] = "abracadabra";
void Worker1() {
puts(s);
}
void Worker2() {
s[3] = 'z';
}
TEST(PrintfTests, RaceOnPutsArgument) {
ANNOTATE_TRACE_MEMORY(s + 3);
ANNOTATE_EXPECT_RACE(s + 3, "PrintfTests_RaceOnPutsArgument.");
MyThreadArray t(Worker1, Worker2);
t.Start();
t.Join();
}
} // namespace
namespace PrintfTests_RaceOnPrintfArgument {
volatile char s[] = "abracadabra";
volatile char s2[] = "abracadabra";
void Worker1() {
fprintf(stdout, "printing a string: %s\n", s);
fprintf(stderr, "printing a string: %s\n", s2);
}
void Worker2() {
s[3] = 'z';
s2[3] = 'z';
}
TEST(PrintfTests, DISABLED_RaceOnPrintfArgument) {
ANNOTATE_EXPECT_RACE(s + 3, "PrintfTests_RaceOnPrintfArgument (stdout).");
ANNOTATE_EXPECT_RACE(s2 + 3, "PrintfTests_RaceOnPrintfArgument (stderr).");
MyThreadArray t(Worker1, Worker2);
t.Start();
t.Join();
}
} // namespace
// Apparently, %n is not supported in windows
#ifndef WIN32
namespace PrintfTests_RaceOnOutputArgument {
volatile char s[] = "abracadabra";
volatile int a = 0;
void Worker1() {
fprintf(stdout, "printing a string: %s%n\n", s, &a);
}
void Worker2() {
fprintf(stdout, "the other thread have already printed %d characters\n", a);
}
TEST(PrintfTests, DISABLED_RaceOnOutputArgument) {
ANNOTATE_EXPECT_RACE(&a, "PrintfTests_RaceOnOutputArgument:int.");
MyThreadArray t(Worker1, Worker2);
t.Start();
t.Join();
}
} // namespace
#endif
namespace PrintfTests_Fflush {
volatile char s[] = "abracadabra";
volatile int a = 0;
void Worker1() {
fflush(NULL);
}
void Worker2() {
fflush(NULL);
}
TEST(PrintfTests, DISABLED_Fflush) {
MyThreadArray t(Worker1, Worker2);
t.Start();
t.Join();
}
} // namespace
namespace BenignRaceTest { // {{{1
const int kArrayLen = 97;
char X[kArrayLen];
char *P;
int counter;
void Worker() {
(*P)++;
ANNOTATE_HAPPENS_BEFORE(P);
AtomicIncrement(&counter, -1);
}
TEST(NegativeTests, BenignRaceTest) {
ThreadPool pool1(1);
ThreadPool pool2(1);
ThreadPool pool3(1);
pool1.StartWorkers();
pool2.StartWorkers();
pool3.StartWorkers();
ANNOTATE_BENIGN_RACE(&counter, "");
const int kNIter = 1000;
for (int i = 0; i < kNIter; i++) {
counter = 3;
long len = (i % (kArrayLen / 3)) + 1;
long beg = i % (kArrayLen - len);
long end = beg + len;
CHECK(beg < kArrayLen);
CHECK(end <= kArrayLen);
bool is_expected = i % 2;
long pos = i % len;
P = X + beg + pos;
CHECK(P < X + kArrayLen);
// printf("[%d] b=%ld e=%ld p=%ld is_expected=%d\n",
// i, beg, end, pos, is_expected);
ANNOTATE_NEW_MEMORY(X, kArrayLen);
if (is_expected) {
ANNOTATE_EXPECT_RACE(P, "expected race in BenignRaceTest");
} else {
ANNOTATE_BENIGN_RACE_SIZED(X + beg, len, "");
}
if ((i % (kNIter / 10)) == 0) {
ANNOTATE_FLUSH_STATE();
}
pool1.Add(NewCallback(Worker));
pool2.Add(NewCallback(Worker));
pool3.Add(NewCallback(Worker));
while(AtomicIncrement(&counter, 0) != 0)
usleep(1000);
ANNOTATE_HAPPENS_AFTER(P);
ANNOTATE_FLUSH_EXPECTED_RACES();
}
}
}
namespace StressTests_FlushStateTest { // {{{1
// Stress test for FlushState which happens in parallel with some work.
const int N = 1000;
int array[N];
void Flusher() {
for (int i = 0; i < 10; i++) {
usleep(1000);
ANNOTATE_FLUSH_STATE();
}
}
void Write1(int i) { array[i]++; }
void Write2(int i) { array[i]--; }
int Read1(int i) { volatile int z = array[i]; return z; }
int Read2(int i) { volatile int z = array[i]; return z; }
void Worker() {
for (int iter = 0; iter < 10; iter++) {
usleep(1000);
for (int i = 0; i < N; i++) {
Write1(i);
Write2(i);
Read1(i);
Read2(i);
}
}
}
TEST(StressTests, FlushStateTest) {
MyThreadArray t(Flusher, Worker, Worker, Worker);
t.Start();
t.Join();
}
} // namespace
// End {{{1
// vim:shiftwidth=2:softtabstop=2:expandtab:foldmethod=marker