tqcq/leveldb
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Fix EnvTest.RunMany to allow parallel execution

Browse Source 
As allowed by the documentation for Env::Schedule(), ChromiumEnv may
execute functions on multiple threads and guarantees no sequencing.
EnvTest.RunMany assumed that functions ran in order, is the case for the
stock PosixEnv and WindowsEnv implementations. This change updates the
test to not assume sequential execution.
This commit is contained in:
Reilly Grant 2023-03-28 16:16:53 -07:00
parent bfae97ff7d
commit df68d9578c
1 changed files with 16 additions and 11 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
util/env_test.cc
View File

@ -96,40 +96,45 @@ TEST_F(EnvTest, RunMany) {
struct RunState { struct RunState {
port::Mutex mu; port::Mutex mu;
port::CondVar cvar{&mu}; port::CondVar cvar{&mu};
int last_id = 0; int run_count = 0;
}; };
struct Callback { struct Callback {
RunState* state_; // Pointer to shared state. RunState* const state_; // Pointer to shared state.
const int id_; // Order# for the execution of this callback. bool run = false;
Callback(RunState* s, int id) : state_(s), id_(id) {} Callback(RunState* s) : state_(s) {}
static void Run(void* arg) { static void Run(void* arg) {
Callback* callback = reinterpret_cast<Callback*>(arg); Callback* callback = reinterpret_cast<Callback*>(arg);
RunState* state = callback->state_; RunState* state = callback->state_;
MutexLock l(&state->mu); MutexLock l(&state->mu);
ASSERT_EQ(state->last_id, callback->id_ - 1); state->run_count++;
state->last_id = callback->id_; callback->run = true;
state->cvar.Signal(); state->cvar.Signal();
} }
}; };
RunState state; RunState state;
Callback callback1(&state, 1); Callback callback1(&state);
Callback callback2(&state, 2); Callback callback2(&state);
Callback callback3(&state, 3); Callback callback3(&state);
Callback callback4(&state, 4); Callback callback4(&state);
env_->Schedule(&Callback::Run, &callback1); env_->Schedule(&Callback::Run, &callback1);
env_->Schedule(&Callback::Run, &callback2); env_->Schedule(&Callback::Run, &callback2);
env_->Schedule(&Callback::Run, &callback3); env_->Schedule(&Callback::Run, &callback3);
env_->Schedule(&Callback::Run, &callback4); env_->Schedule(&Callback::Run, &callback4);
MutexLock l(&state.mu); MutexLock l(&state.mu);
while (state.last_id != 4) { while (state.run_count != 4) {
state.cvar.Wait(); state.cvar.Wait();
} }
ASSERT_TRUE(callback1.run);
ASSERT_TRUE(callback2.run);
ASSERT_TRUE(callback3.run);
ASSERT_TRUE(callback4.run);
} }
struct State { struct State {