leveldb::anonymous_namespace{db_test.cc} Namespace Reference

Classes
class	AtomicCounter
struct	MTState
struct	MTThread

Typedefs
typedef std::map< std::string, std::string >	KVMap

Functions
void	DelayMilliseconds (int millis)
static void	MTThreadBody (void *arg)

Variables
static const int	kNumThreads = 4
static const int	kTestSeconds = 10
static const int	kNumKeys = 1000

---

Class Documentation

leveldb::anonymous_namespace{db_test.cc}::MTState

struct leveldb::anonymous_namespace{db_test.cc}::MTState

Definition at line 1765 of file db_test.cc.

Collaboration diagram for leveldb::anonymous_namespace{db_test.cc}::MTState:

Class Members
AtomicPointer	counter[kNumThreads]
AtomicPointer	stop
DBTest *	test
AtomicPointer	thread_done[kNumThreads]

leveldb::anonymous_namespace{db_test.cc}::MTThread

struct leveldb::anonymous_namespace{db_test.cc}::MTThread

Definition at line 1772 of file db_test.cc.

Collaboration diagram for leveldb::anonymous_namespace{db_test.cc}::MTThread:

Class Members
int	id
MTState *	state

Typedef Documentation

KVMap

typedef std::map<std::string, std::string> leveldb::anonymous_namespace{db_test.cc}::KVMap

Definition at line 1857 of file db_test.cc.

Function Documentation

DelayMilliseconds()

void leveldb::anonymous_namespace{db_test.cc}::DelayMilliseconds

(

int

millis

)

Definition at line 52 of file db_test.cc.

                                   {
  Env::Default()->SleepForMicroseconds(millis * 1000);
}

Here is the call graph for this function:

Here is the caller graph for this function:

MTThreadBody()

static void leveldb::anonymous_namespace{db_test.cc}::MTThreadBody ( void *  arg )

static

Definition at line 1777 of file db_test.cc.

                                    {
  MTThread* t = reinterpret_cast<MTThread*>(arg);
  int id = t->id;
  DB* db = t->state->test->db_;
  uintptr_t counter = 0;
  fprintf(stderr, "... starting thread %d\n", id);
  Random rnd(1000 + id);
  std::string value;
  char valbuf[1500];
  while (t->state->stop.Acquire_Load() == NULL) {
    t->state->counter[id].Release_Store(reinterpret_cast<void*>(counter));

    int key = rnd.Uniform(kNumKeys);
    char keybuf[20];
    snprintf(keybuf, sizeof(keybuf), "%016d", key);

    if (rnd.OneIn(2)) {
      // Write values of the form <key, my id, counter>.
      // We add some padding for force compactions.
      snprintf(valbuf, sizeof(valbuf), "%d.%d.%-1000d",
               key, id, static_cast<int>(counter));
      ASSERT_OK(db->Put(WriteOptions(), Slice(keybuf), Slice(valbuf)));
    } else {
      // Read a value and verify that it matches the pattern written above.
      Status s = db->Get(ReadOptions(), Slice(keybuf), &value);
      if (s.IsNotFound()) {
        // Key has not yet been written
      } else {
        // Check that the writer thread counter is >= the counter in the value
        ASSERT_OK(s);
        int k, w, c;
        ASSERT_EQ(3, sscanf(value.c_str(), "%d.%d.%d", &k, &w, &c)) << value;
        ASSERT_EQ(k, key);
        ASSERT_GE(w, 0);
        ASSERT_LT(w, kNumThreads);
        ASSERT_LE(static_cast<uintptr_t>(c), reinterpret_cast<uintptr_t>(
            t->state->counter[w].Acquire_Load()));
      }
    }
    counter++;
  }
  t->state->thread_done[id].Release_Store(t);
  fprintf(stderr, "... stopping thread %d after %d ops\n", id, int(counter));
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

kNumKeys

const int leveldb::anonymous_namespace{db_test.cc}::kNumKeys = 1000

static

Definition at line 1763 of file db_test.cc.

kNumThreads

const int leveldb::anonymous_namespace{db_test.cc}::kNumThreads = 4

static

Definition at line 1761 of file db_test.cc.

kTestSeconds

const int leveldb::anonymous_namespace{db_test.cc}::kTestSeconds = 10

static

Definition at line 1762 of file db_test.cc.