You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
146 lines
4.0 KiB
146 lines
4.0 KiB
// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file. See the AUTHORS file for names of contributors.
|
|
|
|
#include "leveldb/env.h"
|
|
|
|
#include "port/port.h"
|
|
#include "util/testharness.h"
|
|
#include "util/env_posix_test_helper.h"
|
|
|
|
namespace leveldb {
|
|
|
|
static const int kDelayMicros = 100000;
|
|
static const int kReadOnlyFileLimit = 4;
|
|
static const int kMMapLimit = 4;
|
|
|
|
class EnvPosixTest {
|
|
private:
|
|
port::Mutex mu_;
|
|
std::string events_;
|
|
|
|
public:
|
|
Env* env_;
|
|
EnvPosixTest() : env_(Env::Default()) { }
|
|
|
|
static void SetFileLimits(int read_only_file_limit, int mmap_limit) {
|
|
EnvPosixTestHelper::SetReadOnlyFDLimit(read_only_file_limit);
|
|
EnvPosixTestHelper::SetReadOnlyMMapLimit(mmap_limit);
|
|
}
|
|
};
|
|
|
|
static void SetBool(void* ptr) {
|
|
reinterpret_cast<port::AtomicPointer*>(ptr)->NoBarrier_Store(ptr);
|
|
}
|
|
|
|
TEST(EnvPosixTest, RunImmediately) {
|
|
port::AtomicPointer called (NULL);
|
|
env_->Schedule(&SetBool, &called);
|
|
Env::Default()->SleepForMicroseconds(kDelayMicros);
|
|
ASSERT_TRUE(called.NoBarrier_Load() != NULL);
|
|
}
|
|
|
|
TEST(EnvPosixTest, RunMany) {
|
|
port::AtomicPointer last_id (NULL);
|
|
|
|
struct CB {
|
|
port::AtomicPointer* last_id_ptr; // Pointer to shared slot
|
|
uintptr_t id; // Order# for the execution of this callback
|
|
|
|
CB(port::AtomicPointer* p, int i) : last_id_ptr(p), id(i) { }
|
|
|
|
static void Run(void* v) {
|
|
CB* cb = reinterpret_cast<CB*>(v);
|
|
void* cur = cb->last_id_ptr->NoBarrier_Load();
|
|
ASSERT_EQ(cb->id-1, reinterpret_cast<uintptr_t>(cur));
|
|
cb->last_id_ptr->Release_Store(reinterpret_cast<void*>(cb->id));
|
|
}
|
|
};
|
|
|
|
// Schedule in different order than start time
|
|
CB cb1(&last_id, 1);
|
|
CB cb2(&last_id, 2);
|
|
CB cb3(&last_id, 3);
|
|
CB cb4(&last_id, 4);
|
|
env_->Schedule(&CB::Run, &cb1);
|
|
env_->Schedule(&CB::Run, &cb2);
|
|
env_->Schedule(&CB::Run, &cb3);
|
|
env_->Schedule(&CB::Run, &cb4);
|
|
|
|
Env::Default()->SleepForMicroseconds(kDelayMicros);
|
|
void* cur = last_id.Acquire_Load();
|
|
ASSERT_EQ(4, reinterpret_cast<uintptr_t>(cur));
|
|
}
|
|
|
|
struct State {
|
|
port::Mutex mu;
|
|
int val;
|
|
int num_running;
|
|
};
|
|
|
|
static void ThreadBody(void* arg) {
|
|
State* s = reinterpret_cast<State*>(arg);
|
|
s->mu.Lock();
|
|
s->val += 1;
|
|
s->num_running -= 1;
|
|
s->mu.Unlock();
|
|
}
|
|
|
|
TEST(EnvPosixTest, StartThread) {
|
|
State state;
|
|
state.val = 0;
|
|
state.num_running = 3;
|
|
for (int i = 0; i < 3; i++) {
|
|
env_->StartThread(&ThreadBody, &state);
|
|
}
|
|
while (true) {
|
|
state.mu.Lock();
|
|
int num = state.num_running;
|
|
state.mu.Unlock();
|
|
if (num == 0) {
|
|
break;
|
|
}
|
|
Env::Default()->SleepForMicroseconds(kDelayMicros);
|
|
}
|
|
ASSERT_EQ(state.val, 3);
|
|
}
|
|
|
|
TEST(EnvPosixTest, TestOpenOnRead) {
|
|
// Write some test data to a single file that will be opened |n| times.
|
|
std::string test_dir;
|
|
ASSERT_OK(Env::Default()->GetTestDirectory(&test_dir));
|
|
std::string test_file = test_dir + "/open_on_read.txt";
|
|
|
|
FILE* f = fopen(test_file.c_str(), "w");
|
|
ASSERT_TRUE(f != NULL);
|
|
const char kFileData[] = "abcdefghijklmnopqrstuvwxyz";
|
|
fputs(kFileData, f);
|
|
fclose(f);
|
|
|
|
// Open test file some number above the sum of the two limits to force
|
|
// open-on-read behavior of POSIX Env leveldb::RandomAccessFile.
|
|
const int kNumFiles = kReadOnlyFileLimit + kMMapLimit + 5;
|
|
leveldb::RandomAccessFile* files[kNumFiles] = {0};
|
|
for (int i = 0; i < kNumFiles; i++) {
|
|
ASSERT_OK(Env::Default()->NewRandomAccessFile(test_file, &files[i]));
|
|
}
|
|
char scratch;
|
|
Slice read_result;
|
|
for (int i = 0; i < kNumFiles; i++) {
|
|
ASSERT_OK(files[i]->Read(i, 1, &read_result, &scratch));
|
|
ASSERT_EQ(kFileData[i], read_result[0]);
|
|
}
|
|
for (int i = 0; i < kNumFiles; i++) {
|
|
delete files[i];
|
|
}
|
|
ASSERT_OK(Env::Default()->DeleteFile(test_file));
|
|
}
|
|
|
|
} // namespace leveldb
|
|
|
|
int main(int argc, char** argv) {
|
|
// All tests currently run with the same read-only file limits.
|
|
leveldb::EnvPosixTest::SetFileLimits(leveldb::kReadOnlyFileLimit,
|
|
leveldb::kMMapLimit);
|
|
return leveldb::test::RunAllTests();
|
|
}
|