Skip to content

Commit

Permalink
rename classes to lowerCamelCase
Browse files Browse the repository at this point in the history 
git-svn-id: svn+ssh://svn.corp.yahoo.com/yahoo/yrl/labs/pnuts/code/logstore@3785 8dad8b1f-cf64-0410-95b6-bcf113ffbcfe
  • Loading branch information
sears committed Feb 23, 2012
1 parent 7b2809a commit 9b1df5b
Show file tree
Hide file tree
Showing 51 changed files with 638 additions and 643 deletions.
130 changes: 65 additions & 65 deletions blsm.cpp
View file

Large diffs are not rendered by default.

94 changes: 45 additions & 49 deletions blsm.h
View file
Expand Up @@ -25,15 +25,11 @@


#include "diskTreeComponent.h" #include "diskTreeComponent.h"
#include "memTreeComponent.h" #include "memTreeComponent.h"

#include "tuplemerger.h" #include "tuplemerger.h"

#include "mergeManager.h" #include "mergeManager.h"
#include "mergeStats.h" #include "mergeStats.h"


class logtable_mergedata; class bLSM {

class blsm {
public: public:


class iterator; class iterator;
Expand All @@ -49,36 +45,36 @@ class blsm {
// 6GB ~= 100B * 500 GB / (datapage_size * 4KB) // 6GB ~= 100B * 500 GB / (datapage_size * 4KB)
// (100B * 500GB) / (6GB * 4KB) = 2.035 // (100B * 500GB) / (6GB * 4KB) = 2.035
// RCS: Set this to 1 so that we do (on average) one seek per b-tree read. // RCS: Set this to 1 so that we do (on average) one seek per b-tree read.
blsm(int log_mode = 0, pageid_t max_c0_size = 100 * 1024 * 1024, pageid_t internal_region_size = 1000, pageid_t datapage_region_size = 10000, pageid_t datapage_size = 1); bLSM(int log_mode = 0, pageid_t max_c0_size = 100 * 1024 * 1024, pageid_t internal_region_size = 1000, pageid_t datapage_region_size = 10000, pageid_t datapage_size = 1);


~blsm(); ~bLSM();


double * R() { return &r_val; } double * R() { return &r_val; }


//user access functions //user access functions
datatuple * findTuple(int xid, const datatuple::key_t key, size_t keySize); dataTuple * findTuple(int xid, const dataTuple::key_t key, size_t keySize);


datatuple * findTuple_first(int xid, datatuple::key_t key, size_t keySize); dataTuple * findTuple_first(int xid, dataTuple::key_t key, size_t keySize);


private: private:
datatuple * insertTupleHelper(datatuple *tuple); dataTuple * insertTupleHelper(dataTuple *tuple);
public: public:
void insertManyTuples(struct datatuple **tuples, int tuple_count); void insertManyTuples(struct dataTuple **tuples, int tuple_count);
void insertTuple(struct datatuple *tuple); void insertTuple(struct dataTuple *tuple);
/** This test and set has strange semantics on two fronts: /** This test and set has strange semantics on two fronts:
* *
* 1) It is not atomic with respect to non-testAndSet operations (which is fine in theory, since they have no barrier semantics, and we don't have a use case to support the extra overhead) * 1) It is not atomic with respect to non-testAndSet operations (which is fine in theory, since they have no barrier semantics, and we don't have a use case to support the extra overhead)
* 2) If tuple2 is not null, it looks at tuple2's key instead of tuple's key. This means you can atomically set the value of one key based on the value of another (if you want to...) * 2) If tuple2 is not null, it looks at tuple2's key instead of tuple's key. This means you can atomically set the value of one key based on the value of another (if you want to...)
*/ */
bool testAndSetTuple(struct datatuple *tuple, struct datatuple *tuple2); bool testAndSetTuple(struct dataTuple *tuple, struct dataTuple *tuple2);


//other class functions //other class functions
recordid allocTable(int xid); recordid allocTable(int xid);
void openTable(int xid, recordid rid); void openTable(int xid, recordid rid);
void flushTable(); void flushTable();


void replayLog(); void replayLog();
void logUpdate(datatuple * tup); void logUpdate(dataTuple * tup);


static void init_stasis(); static void init_stasis();
static void deinit_stasis(); static void deinit_stasis();
Expand Down Expand Up @@ -115,7 +111,7 @@ class blsm {


void update_persistent_header(int xid, lsn_t log_trunc = INVALID_LSN); void update_persistent_header(int xid, lsn_t log_trunc = INVALID_LSN);


inline tuplemerger * gettuplemerger(){return tmerger;} inline tupleMerger * gettuplemerger(){return tmerger;}


public: public:


Expand Down Expand Up @@ -183,14 +179,14 @@ class blsm {
pageid_t datapage_region_size; // " pageid_t datapage_region_size; // "
pageid_t datapage_size; // " pageid_t datapage_size; // "
private: private:
tuplemerger *tmerger; tupleMerger *tmerger;


std::vector<iterator *> its; std::vector<iterator *> its;


public: public:
bool shutting_down_; bool shutting_down_;


bool mightBeOnDisk(datatuple * t) { bool mightBeOnDisk(dataTuple * t) {
if(tree_c1) { if(tree_c1) {
if(!tree_c1->bloom_filter) { DEBUG("no c1 bloom filter\n"); return true; } if(!tree_c1->bloom_filter) { DEBUG("no c1 bloom filter\n"); return true; }
if(bloom_filter_lookup(tree_c1->bloom_filter, (const char*)t->strippedkey(), t->strippedkeylen())) { DEBUG("in c1\n"); return true; } if(bloom_filter_lookup(tree_c1->bloom_filter, (const char*)t->strippedkey(), t->strippedkeylen())) { DEBUG("in c1\n"); return true; }
Expand All @@ -202,7 +198,7 @@ class blsm {
return mightBeAfterMemMerge(t); return mightBeAfterMemMerge(t);
} }


bool mightBeAfterMemMerge(datatuple * t) { bool mightBeAfterMemMerge(dataTuple * t) {


if(tree_c1_mergeable) { if(tree_c1_mergeable) {
if(!tree_c1_mergeable->bloom_filter) { DEBUG("no c1m bloom filter\n"); return true; } if(!tree_c1_mergeable->bloom_filter) { DEBUG("no c1m bloom filter\n"); return true; }
Expand All @@ -220,11 +216,11 @@ class blsm {
template<class ITRA, class ITRN> template<class ITRA, class ITRN>
class mergeManyIterator { class mergeManyIterator {
public: public:
explicit mergeManyIterator(ITRA* a, ITRN** iters, int num_iters, datatuple*(*merge)(const datatuple*,const datatuple*), int (*cmp)(const datatuple*,const datatuple*)) : explicit mergeManyIterator(ITRA* a, ITRN** iters, int num_iters, dataTuple*(*merge)(const dataTuple*,const dataTuple*), int (*cmp)(const dataTuple*,const dataTuple*)) :
num_iters_(num_iters+1), num_iters_(num_iters+1),
first_iter_(a), first_iter_(a),
iters_((ITRN**)malloc(sizeof(*iters_) * num_iters)), // exactly the number passed in iters_((ITRN**)malloc(sizeof(*iters_) * num_iters)), // exactly the number passed in
current_((datatuple**)malloc(sizeof(*current_) * (num_iters_))), // one more than was passed in current_((dataTuple**)malloc(sizeof(*current_) * (num_iters_))), // one more than was passed in
last_iter_(-1), last_iter_(-1),
cmp_(cmp), cmp_(cmp),
merge_(merge), merge_(merge),
Expand All @@ -240,7 +236,7 @@ class blsm {
delete(first_iter_); delete(first_iter_);
for(int i = 0; i < num_iters_; i++) { for(int i = 0; i < num_iters_; i++) {
if(i != last_iter_) { if(i != last_iter_) {
if(current_[i]) datatuple::freetuple(current_[i]); if(current_[i]) dataTuple::freetuple(current_[i]);
} }
} }
for(int i = 1; i < num_iters_; i++) { for(int i = 1; i < num_iters_; i++) {
Expand All @@ -250,12 +246,12 @@ class blsm {
free(iters_); free(iters_);
free(dups); free(dups);
} }
datatuple * peek() { dataTuple * peek() {
datatuple * ret = next_callerFrees(); dataTuple * ret = next_callerFrees();
last_iter_ = -1; // don't advance iterator on next peek() or getnext() call. last_iter_ = -1; // don't advance iterator on next peek() or getnext() call.
return ret; return ret;
} }
datatuple * next_callerFrees() { dataTuple * next_callerFrees() {
int num_dups = 0; int num_dups = 0;
if(last_iter_ != -1) { if(last_iter_ != -1) {
// get the value after the one we just returned to the user // get the value after the one we just returned to the user
Expand Down Expand Up @@ -287,7 +283,7 @@ class blsm {
} }
} }
} }
datatuple * ret; dataTuple * ret;
if(!merge_) { if(!merge_) {
ret = current_[min]; ret = current_[min];
} else { } else {
Expand All @@ -296,7 +292,7 @@ class blsm {
} }
// advance the iterators that match the tuple we're returning. // advance the iterators that match the tuple we're returning.
for(int i = 0; i < num_dups; i++) { for(int i = 0; i < num_dups; i++) {
datatuple::freetuple(current_[dups[i]]); // should never be null dataTuple::freetuple(current_[dups[i]]); // should never be null
current_[dups[i]] = iters_[dups[i]-1]->next_callerFrees(); current_[dups[i]] = iters_[dups[i]-1]->next_callerFrees();
} }
last_iter_ = min; // mark the min iter to be advance at the next invocation of next(). This saves us a copy in the non-merging case. last_iter_ = min; // mark the min iter to be advance at the next invocation of next(). This saves us a copy in the non-merging case.
Expand All @@ -307,12 +303,12 @@ class blsm {
int num_iters_; int num_iters_;
ITRA * first_iter_; ITRA * first_iter_;
ITRN ** iters_; ITRN ** iters_;
datatuple ** current_; dataTuple ** current_;
int last_iter_; int last_iter_;




int (*cmp_)(const datatuple*,const datatuple*); int (*cmp_)(const dataTuple*,const dataTuple*);
datatuple*(*merge_)(const datatuple*,const datatuple*); dataTuple*(*merge_)(const dataTuple*,const dataTuple*);


// temporary variables initiaized once for effiency // temporary variables initiaized once for effiency
int * dups; int * dups;
Expand All @@ -322,7 +318,7 @@ class blsm {


class iterator { class iterator {
public: public:
explicit iterator(blsm* ltable) explicit iterator(bLSM* ltable)
: ltable(ltable), : ltable(ltable),
epoch(ltable->get_epoch()), epoch(ltable->get_epoch()),
merge_it_(NULL), merge_it_(NULL),
Expand All @@ -338,7 +334,7 @@ class blsm {
// rwlc_unlock(ltable->header_mut); // rwlc_unlock(ltable->header_mut);
} }


explicit iterator(blsm* ltable,datatuple *key) explicit iterator(bLSM* ltable,dataTuple *key)
: ltable(ltable), : ltable(ltable),
epoch(ltable->get_epoch()), epoch(ltable->get_epoch()),
merge_it_(NULL), merge_it_(NULL),
Expand All @@ -361,16 +357,16 @@ class blsm {
ltable->forgetIterator(this); ltable->forgetIterator(this);
invalidate(); invalidate();
pthread_mutex_unlock(&ltable->rb_mut); pthread_mutex_unlock(&ltable->rb_mut);
if(last_returned) datatuple::freetuple(last_returned); if(last_returned) dataTuple::freetuple(last_returned);
rwlc_unlock(ltable->header_mut); rwlc_unlock(ltable->header_mut);
} }
private: private:
datatuple * getnextHelper() { dataTuple * getnextHelper() {
// rwlc_readlock(ltable->header_mut); // rwlc_readlock(ltable->header_mut);
revalidate(); revalidate();
datatuple * tmp = merge_it_->next_callerFrees(); dataTuple * tmp = merge_it_->next_callerFrees();
if(last_returned && tmp) { if(last_returned && tmp) {
int res = datatuple::compare(last_returned->strippedkey(), last_returned->strippedkeylen(), tmp->strippedkey(), tmp->strippedkeylen()); int res = dataTuple::compare(last_returned->strippedkey(), last_returned->strippedkeylen(), tmp->strippedkey(), tmp->strippedkeylen());
if(res >= 0) { if(res >= 0) {
int al = last_returned->strippedkeylen(); int al = last_returned->strippedkeylen();
char * a =(char*)malloc(al + 1); char * a =(char*)malloc(al + 1);
Expand All @@ -387,21 +383,21 @@ class blsm {


} }
if(last_returned) { if(last_returned) {
datatuple::freetuple(last_returned); dataTuple::freetuple(last_returned);
} }
last_returned = tmp; last_returned = tmp;
// rwlc_unlock(ltable->header_mut); // rwlc_unlock(ltable->header_mut);
return last_returned; return last_returned;
} }
public: public:
datatuple * getnextIncludingTombstones() { dataTuple * getnextIncludingTombstones() {
datatuple * ret = getnextHelper(); dataTuple * ret = getnextHelper();
ret = ret ? ret->create_copy() : NULL; ret = ret ? ret->create_copy() : NULL;
return ret; return ret;
} }


datatuple * getnext() { dataTuple * getnext() {
datatuple * ret; dataTuple * ret;
while((ret = getnextHelper()) && ret->isDelete()) { } // getNextHelper handles its own memory. while((ret = getnextHelper()) && ret->isDelete()) { } // getNextHelper handles its own memory.
ret = ret ? ret->create_copy() : NULL; // XXX hate making copy! Caller should not manage our memory. ret = ret ? ret->create_copy() : NULL; // XXX hate making copy! Caller should not manage our memory.
return ret; return ret;
Expand All @@ -427,7 +423,7 @@ class blsm {
static const int C1 = 0; static const int C1 = 0;
static const int C1_MERGEABLE = 1; static const int C1_MERGEABLE = 1;
static const int C2 = 2; static const int C2 = 2;
blsm * ltable; bLSM * ltable;
uint64_t epoch; uint64_t epoch;
typedef mergeManyIterator< typedef mergeManyIterator<
memTreeComponent::batchedRevalidatingIterator, memTreeComponent::batchedRevalidatingIterator,
Expand All @@ -438,8 +434,8 @@ class blsm {


merge_it_t* merge_it_; merge_it_t* merge_it_;


datatuple * last_returned; dataTuple * last_returned;
datatuple * key; dataTuple * key;
bool valid; bool valid;
int reval_count; int reval_count;
static const int reval_period = 100; static const int reval_period = 100;
Expand All @@ -465,7 +461,7 @@ class blsm {
diskTreeComponent::iterator * disk_it[4]; diskTreeComponent::iterator * disk_it[4];
epoch = ltable->get_epoch(); epoch = ltable->get_epoch();


datatuple *t; dataTuple *t;
if(last_returned) { if(last_returned) {
t = last_returned; t = last_returned;
} else if(key) { } else if(key) {
Expand All @@ -490,13 +486,13 @@ class blsm {
disk_it[3] = ltable->get_tree_c2()->open_iterator(t); disk_it[3] = ltable->get_tree_c2()->open_iterator(t);


inner_merge_it_t * inner_merge_it = inner_merge_it_t * inner_merge_it =
new inner_merge_it_t(c0_it, c0_mergeable_it, 1, NULL, datatuple::compare_obj); new inner_merge_it_t(c0_it, c0_mergeable_it, 1, NULL, dataTuple::compare_obj);
merge_it_ = new merge_it_t(inner_merge_it, disk_it, 4, NULL, datatuple::compare_obj); // XXX Hardcodes comparator, and does not handle merges merge_it_ = new merge_it_t(inner_merge_it, disk_it, 4, NULL, dataTuple::compare_obj); // XXX Hardcodes comparator, and does not handle merges
if(last_returned) { if(last_returned) {
datatuple * junk = merge_it_->peek(); dataTuple * junk = merge_it_->peek();
if(junk && !datatuple::compare(junk->strippedkey(), junk->strippedkeylen(), last_returned->strippedkey(), last_returned->strippedkeylen())) { if(junk && !dataTuple::compare(junk->strippedkey(), junk->strippedkeylen(), last_returned->strippedkey(), last_returned->strippedkeylen())) {
// we already returned junk // we already returned junk
datatuple::freetuple(merge_it_->next_callerFrees()); dataTuple::freetuple(merge_it_->next_callerFrees());
} }
} }
valid = true; valid = true;
Expand Down

0 comments on commit 9b1df5b

Please sign in to comment.