Make all external symbols in pma.o start with toku_. Addresses #8

git-svn-id: file:///svn/tokudb@677 c7de825b-a66e-492c-adef-691d508d4ae1

newbrt/brt-serialize.c

@@ -152,8 +152,8 @@ void toku_seralize_brtnode_to(int fd, DISKOFF off, DISKOFF size, BRTNODE node) {
 	    assert(check_local_fingerprint==node->local_fingerprint);
 	}
     } else {
-	//printf(" n_entries=%d\n", pma_n_entries(node->u.l.buffer));
-	wbuf_int(&w, pma_n_entries(node->u.l.buffer));
+	//printf(" n_entries=%d\n", toku_pma_n_entries(node->u.l.buffer));
+	wbuf_int(&w, toku_pma_n_entries(node->u.l.buffer));
 	PMA_ITERATE(node->u.l.buffer, key, keylen, data, datalen,
 		    (wbuf_bytes(&w, key, keylen),
 		     wbuf_bytes(&w, data, datalen)));
@@ -341,13 +341,13 @@ int toku_deserialize_brtnode_from (int fd, DISKOFF off, BRTNODE *brtnode, int fl
     } else {
 	int n_in_buf = rbuf_int(&rc);
 	result->u.l.n_bytes_in_buffer = 0;
-	r=pma_create(&result->u.l.buffer, bt_compare, nodesize);
+	r=toku_pma_create(&result->u.l.buffer, bt_compare, nodesize);
 	if (r!=0) {
-	    if (0) { died_21: pma_free(&result->u.l.buffer); }
+	    if (0) { died_21: toku_pma_free(&result->u.l.buffer); }
 	    goto died1;
 	}
-        pma_set_dup_mode(result->u.l.buffer, flags);
-        if (flags & TOKU_DB_DUPSORT) pma_set_dup_compare(result->u.l.buffer, dup_compare);
+        toku_pma_set_dup_mode(result->u.l.buffer, flags);
+        if (flags & TOKU_DB_DUPSORT) toku_pma_set_dup_compare(result->u.l.buffer, dup_compare);
 	//printf("%s:%d r PMA= %p\n", __FILE__, __LINE__, result->u.l.buffer); 
 #define BRT_USE_PMA_BULK_INSERT 1
 #if BRT_USE_PMA_BULK_INSERT
@@ -366,7 +366,7 @@ int toku_deserialize_brtnode_from (int fd, DISKOFF off, BRTNODE *brtnode, int fl
         }
         if (n_in_buf > 0) {
 	    u_int32_t actual_sum = 0;
-            r = pma_bulk_insert(result->u.l.buffer, keys, vals, n_in_buf, result->rand4fingerprint, &actual_sum);
+            r = toku_pma_bulk_insert(result->u.l.buffer, keys, vals, n_in_buf, result->rand4fingerprint, &actual_sum);
             if (r!=0) goto died_21;
 	    if (actual_sum!=result->local_fingerprint) {
 		//fprintf(stderr, "%s:%d Corrupted checksum stored=%08x rand=%08x actual=%08x height=%d n_keys=%d\n", __FILE__, __LINE__, result->rand4fingerprint, result->local_fingerprint, actual_sum, result->height, n_in_buf);
@@ -386,7 +386,7 @@ int toku_deserialize_brtnode_from (int fd, DISKOFF off, BRTNODE *brtnode, int fl
 	    rbuf_bytes(&rc, &val, &vallen);
 	    {
 		DBT k,v;
-		r = pma_insert(result->u.l.buffer, fill_dbt(&k, key, keylen), fill_dbt(&v, val, vallen), 0);
+		r = toku_pma_insert(result->u.l.buffer, fill_dbt(&k, key, keylen), fill_dbt(&v, val, vallen), 0);
 		if (r!=0) goto died_21;
 	    }
 	    result->u.l.n_bytes_in_buffer += keylen + vallen + KEY_VALUE_OVERHEAD;

newbrt/brt-test.c

@@ -606,7 +606,7 @@ static void  test_read_what_was_written (void) {
     printf(" ok\n");
 }
 
-extern void pma_show_stats (void);
+extern void toku_pma_show_stats (void);
 
 /* Test c_get(DB_LAST) on an empty tree */
 void test_cursor_last_empty(void) {
@@ -2249,7 +2249,7 @@ static void brt_blackbox_test (void) {
     test4(2048, 1<<15, 1);
     printf("test3 fast\n");
 
-    pma_show_stats();
+    toku_pma_show_stats();
 
     test3(1<<15, 1024, 1);
     test4(1<<15, 1024, 1);

newbrt/brt-verify.c

@@ -27,7 +27,7 @@ static void verify_local_fingerprint (BRTNODE node) {
 			      }));
 	assert(fp==node->local_fingerprint);
     } else {
-	pma_verify_fingerprint(node->u.l.buffer, node->rand4fingerprint, node->local_fingerprint);
+	toku_pma_verify_fingerprint(node->u.l.buffer, node->rand4fingerprint, node->local_fingerprint);
     }
 }
 

newbrt/mdict.c

@@ -13,7 +13,7 @@ int mdict_create (MDICT* mdict) {
     int r;
     MALLOC(result);
     if (result==0) return -1;
-    r = pma_create(&result->pma);
+    r = toku_pma_create(&result->pma);
     if (r==0) {
 	*mdict = result;
     }
@@ -21,12 +21,12 @@ int mdict_create (MDICT* mdict) {
 }
 	
 void mdict_free (MDICT m) {
-    pma_free(m->pma);
+    toku_pma_free(m->pma);
     my_free(m);
 }
 
 int  mdict_n_entries (MDICT m) {
-    return pma_n_entries(m->pma);
+    return toku_pma_n_entries(m->pma);
 }
     
 
@@ -34,28 +34,28 @@ int  mdict_n_entries (MDICT m) {
 /* The values returned should not be modified. */
 /* May damage the cursor. */
 int mdict_insert (MDICT m, bytevec key, ITEMLEN keylen, bytevec data, ITEMLEN datalen) {
-    return pma_insert(m->pma, key, keylen, data, datalen);
+    return toku_pma_insert(m->pma, key, keylen, data, datalen);
 }
 /* This returns an error if the key is NOT present. */
 int mdict_replace (MDICT, bytevec key, ITEMLEN keylen, bytevec data, ITEMLEN datalen);
 /* This returns an error if the key is NOT present. */
 int mdict_delete (MDICT m, bytevec key, ITEMLEN keylen) {
-    return pma_delete(m->pma, key, keylen);
+    return toku_pma_delete(m->pma, key, keylen);
 }
 
 /* Exposes internals of the MDICT by returning a pointer to the guts.
  * Don't modify the returned data.  Don't free it. */
 int mdict_lookup (MDICT m, bytevec key, ITEMLEN keylen, bytevec*data, ITEMLEN *datalen) {
-    return pma_lookup(m->pma, key, keylen, data, datalen);
+    return toku_pma_lookup(m->pma, key, keylen, data, datalen);
 }
 
 
 int mdict_random_pick(MDICT m, bytevec *key, ITEMLEN *keylen, bytevec *data, ITEMLEN *datalen) {
-    return pma_random_pick(m->pma, key, keylen, data, datalen);
+    return toku_pma_random_pick(m->pma, key, keylen, data, datalen);
 }
 
 void mdict_iterate (MDICT m, void(*f)(bytevec,ITEMLEN,bytevec,ITEMLEN, void*), void*v) {
-    pma_iterate(m->pma, f, v);
+    toku_pma_iterate(m->pma, f, v);
 }
 
 

newbrt/mdict.h

@@ -14,14 +14,14 @@ int toku_keycompare (bytevec key1, ITEMLEN key1len, bytevec key2, ITEMLEN key2le
 #define MDICT PMA
 #define MDICT_OK PMA_OK
 #define MDICT_NOTFOUND PMA_NOTFOUND
-#define mdict_free pma_free
-#define mdict_n_entries pma_n_entries
+#define mdict_free toku_pma_free
+#define mdict_n_entries toku_pma_n_entries
 #define MDICT_ITERATE PMA_ITERATE
-#define mdict_insert pma_insert
+#define mdict_insert toku_pma_insert
 #define mdict_create pma_create
 #define mdict_delete pma_delete
-#define mdict_lookup pma_lookup
-#define mdict_random_pick pma_random_pick
+#define mdict_lookup toku_pma_lookup
+#define mdict_random_pick toku_pma_random_pick
 #define mdict_iterate pma_iterate
 
 #elif defined(USEHASH)

newbrt/pma-internal.h

@@ -30,13 +30,13 @@ struct pma {
     struct mempool kvspace;
 };
 
-int pmainternal_count_region (struct kv_pair *pairs[], int lo, int hi);
-void pmainternal_calculate_parameters (PMA pma);
-int pmainternal_smooth_region (struct kv_pair *pairs[], int n, int idx, int base, PMA pma);
-int pmainternal_printpairs (struct kv_pair *pairs[], int N);
-int pmainternal_make_space_at (PMA pma, int idx);
-int pmainternal_find (PMA pma, DBT *, DB*); // The DB is so the comparison fuction can be called.
-void print_pma (PMA pma); /* useful for debugging, so keep the name short. I.e., not pmainternal_print_pma() */
+int toku_pmainternal_count_region (struct kv_pair *pairs[], int lo, int hi);
+void toku_pmainternal_calculate_parameters (PMA pma);
+int toku_pmainternal_smooth_region (struct kv_pair *pairs[], int n, int idx, int base, PMA pma);
+int toku_pmainternal_printpairs (struct kv_pair *pairs[], int N);
+int toku_pmainternal_make_space_at (PMA pma, int idx);
+int toku_pmainternal_find (PMA pma, DBT *, DB*); // The DB is so the comparison fuction can be called.
+void toku_print_pma (PMA pma); /* useful for debugging, so keep the name short. I.e., not pmainternal_print_pma() */
 
 /* density thresholds */
 #define PMA_LDT_HIGH  0.25

newbrt/pma.h

@@ -19,39 +19,39 @@ typedef struct pma_cursor *PMA_CURSOR;
    return a value < 0, = 0, > 0 if a < b, a == b, a > b respectively */
 typedef int (*pma_compare_fun_t)(DB *, const DBT *a, const DBT *b);
 
-int pma_create(PMA *, pma_compare_fun_t compare_fun, int maxsize);
+int toku_pma_create(PMA *, pma_compare_fun_t compare_fun, int maxsize);
 
-int pma_set_compare(PMA pma, pma_compare_fun_t compare_fun);
+int toku_pma_set_compare(PMA pma, pma_compare_fun_t compare_fun);
 
 /* set the duplicate mode 
    0 -> no duplications, TOKU_DB_DUP, TOKU_DB_DUPSORT */
-int pma_set_dup_mode(PMA pma, int mode);
+int toku_pma_set_dup_mode(PMA pma, int mode);
 
 /* set the duplicate compare function */
-int pma_set_dup_compare(PMA pma, pma_compare_fun_t dup_compare_fun);
+int toku_pma_set_dup_compare(PMA pma, pma_compare_fun_t dup_compare_fun);
 
 /* verify the integrity of a pma */
-void pma_verify(PMA pma, DB *db);
+void toku_pma_verify(PMA pma, DB *db);
 
 /* returns 0 if OK.
  * You must have freed all the cursors, otherwise returns nonzero and does nothing. */
-int pma_free (PMA *);
+int toku_pma_free (PMA *);
 
-int  pma_n_entries (PMA);
+int  toku_pma_n_entries (PMA);
 
 /* Returns an error if the key is already present. */
 /* The values returned should not be modified.by the caller. */
 /* Any cursors should be updated. */
 /* Duplicates the key and keylen. */
-//enum pma_errors pma_insert (PMA, bytevec key, ITEMLEN keylen, bytevec data, ITEMLEN datalen);
+//enum pma_errors toku_pma_insert (PMA, bytevec key, ITEMLEN keylen, bytevec data, ITEMLEN datalen);
 // The DB pointer is there so that the comparison function can be called.
-enum pma_errors pma_insert (PMA, DBT*, DBT*, DB*, TOKUTXN txn, DISKOFF, u_int32_t /*random for fingerprint */, u_int32_t */*fingerprint*/);
+enum pma_errors toku_pma_insert (PMA, DBT*, DBT*, DB*, TOKUTXN txn, DISKOFF, u_int32_t /*random for fingerprint */, u_int32_t */*fingerprint*/);
 /* This returns an error if the key is NOT present. */
 int pma_replace (PMA, bytevec key, ITEMLEN keylen, bytevec data, ITEMLEN datalen);
 /* This returns an error if the key is NOT present. */
-int pma_delete (PMA, DBT *, DB*, u_int32_t /*random for fingerprint*/, u_int32_t */*fingerprint*/, u_int32_t *deleted_size);
+int toku_pma_delete (PMA, DBT *, DB*, u_int32_t /*random for fingerprint*/, u_int32_t */*fingerprint*/, u_int32_t *deleted_size);
 
-int pma_insert_or_replace (PMA pma, DBT *k, DBT *v,
+int toku_pma_insert_or_replace (PMA pma, DBT *k, DBT *v,
 			   int *replaced_v_size, /* If it is a replacement, set to the size of the old value, otherwise set to -1. */
 			   DB *db, TOKUTXN txn, DISKOFF,
 			   u_int32_t /*random for fingerprint*/, u_int32_t */*fingerprint*/);
@@ -59,7 +59,7 @@ int pma_insert_or_replace (PMA pma, DBT *k, DBT *v,
 
 /* Exposes internals of the PMA by returning a pointer to the guts.
  * Don't modify the returned data.  Don't free it. */
-enum pma_errors pma_lookup (PMA, DBT*, DBT*, DB*);
+enum pma_errors toku_pma_lookup (PMA, DBT*, DBT*, DB*);
 
 /*
  * The kv pairs in the original pma are split into 2 equal sized sets
@@ -71,7 +71,7 @@ enum pma_errors pma_lookup (PMA, DBT*, DBT*, DB*);
  * leftpma - the pma assigned keys <= pivot key
  * rightpma - the pma assigned keys > pivot key
  */
-int pma_split(PMA origpma,  unsigned int *origpma_size, DBT *splitk, DB *db,
+int toku_pma_split(PMA origpma,  unsigned int *origpma_size, DBT *splitk, DB *db,
 	      PMA leftpma,  unsigned int *leftpma_size,  u_int32_t leftrand4sum,  u_int32_t *leftfingerprint,
 	      PMA rightpma, unsigned int *rightpma_size, u_int32_t rightrand4sum, u_int32_t *rightfingerprint);
 
@@ -86,56 +86,56 @@ int pma_split(PMA origpma,  unsigned int *origpma_size, DBT *splitk, DB *db,
  * vals - an array of values
  * n_newpairs - the number of key value pairs
  */
-int pma_bulk_insert(PMA pma, DBT *keys, DBT *vals, int n_newpairs, u_int32_t rand4sem, u_int32_t *fingerprint);
+int toku_pma_bulk_insert(PMA pma, DBT *keys, DBT *vals, int n_newpairs, u_int32_t rand4sem, u_int32_t *fingerprint);
 
 /* Move the cursor to the beginning or the end or to a key */
-int pma_cursor (PMA, PMA_CURSOR *);
-int pma_cursor_free (PMA_CURSOR*);
+int toku_pma_cursor (PMA, PMA_CURSOR *);
+int toku_pma_cursor_free (PMA_CURSOR*);
 
 /* get the pma that a pma cursor is bound to */
-int pma_cursor_get_pma(PMA_CURSOR c, PMA *pma);
-int pma_cursor_set_position_last (PMA_CURSOR c);
-int pma_cursor_set_position_first (PMA_CURSOR c);
-int pma_cursor_set_position_next (PMA_CURSOR c); /* Requires the cursor is init'd.  Returns DB_NOTFOUND if we fall off the end. */
-int pma_cursor_set_position_prev (PMA_CURSOR c);
+int toku_pma_cursor_get_pma(PMA_CURSOR c, PMA *pma);
+int toku_pma_cursor_set_position_last (PMA_CURSOR c);
+int toku_pma_cursor_set_position_first (PMA_CURSOR c);
+int toku_pma_cursor_set_position_next (PMA_CURSOR c); /* Requires the cursor is init'd.  Returns DB_NOTFOUND if we fall off the end. */
+int toku_pma_cursor_set_position_prev (PMA_CURSOR c);
 
 /* get the key and data under the cursor */
-int pma_cursor_get_current(PMA_CURSOR c, DBT *key, DBT *val);
+int toku_pma_cursor_get_current(PMA_CURSOR c, DBT *key, DBT *val);
 
 /* set the cursor to the matching key and value pair */
-int pma_cursor_set_both(PMA_CURSOR c, DBT *key, DBT *val, DB *db);
+int toku_pma_cursor_set_both(PMA_CURSOR c, DBT *key, DBT *val, DB *db);
 
 /* move the cursor to the kv pair matching the key */
-int pma_cursor_set_key(PMA_CURSOR c, DBT *key, DB *db);
+int toku_pma_cursor_set_key(PMA_CURSOR c, DBT *key, DB *db);
 
 /* set the cursor to the smallest key in the pma >= key */
-int pma_cursor_set_range(PMA_CURSOR c, DBT *key, DB *db);
+int toku_pma_cursor_set_range(PMA_CURSOR c, DBT *key, DB *db);
 
 /* delete the key value pair under the cursor, return the size of the pair */
-int pma_cursor_delete_under(PMA_CURSOR c, int *kvsize);
+int toku_pma_cursor_delete_under(PMA_CURSOR c, int *kvsize);
 
-int pma_random_pick(PMA, bytevec *key, ITEMLEN *keylen, bytevec *data, ITEMLEN *datalen);
+int toku_pma_random_pick(PMA, bytevec *key, ITEMLEN *keylen, bytevec *data, ITEMLEN *datalen);
 
-int pma_index_limit(PMA);
-int pmanode_valid(PMA,int);
-bytevec pmanode_key(PMA,int);
-ITEMLEN pmanode_keylen(PMA,int);
-bytevec pmanode_val(PMA,int);
-ITEMLEN pmanode_vallen(PMA,int);
+int toku_pma_index_limit(PMA);
+int toku_pmanode_valid(PMA,int);
+bytevec toku_pmanode_key(PMA,int);
+ITEMLEN toku_pmanode_keylen(PMA,int);
+bytevec toku_pmanode_val(PMA,int);
+ITEMLEN toku_pmanode_vallen(PMA,int);
 
-void pma_iterate (PMA, void(*)(bytevec,ITEMLEN,bytevec,ITEMLEN, void*), void*);
+void toku_pma_iterate (PMA, void(*)(bytevec,ITEMLEN,bytevec,ITEMLEN, void*), void*);
 
 #define PMA_ITERATE(table,keyvar,keylenvar,datavar,datalenvar,body) ({ \
   int __i;                                                             \
-  for (__i=0; __i<pma_index_limit(table); __i++) {		       \
-    if (pmanode_valid(table,__i)) {                                    \
-      bytevec keyvar = pmanode_key(table,__i);                         \
-      ITEMLEN keylenvar = pmanode_keylen(table,__i);                   \
-      bytevec datavar = pmanode_val(table, __i);                       \
-      ITEMLEN datalenvar = pmanode_vallen(table, __i);                 \
+  for (__i=0; __i<toku_pma_index_limit(table); __i++) {		       \
+    if (toku_pmanode_valid(table,__i)) {                                    \
+      bytevec keyvar = toku_pmanode_key(table,__i);                         \
+      ITEMLEN keylenvar = toku_pmanode_keylen(table,__i);                   \
+      bytevec datavar = toku_pmanode_val(table, __i);                       \
+      ITEMLEN datalenvar = toku_pmanode_vallen(table, __i);                 \
       body;                                                            \
 } } })
 
-void pma_verify_fingerprint (PMA pma, u_int32_t rand4fingerprint, u_int32_t fingerprint);
+void toku_pma_verify_fingerprint (PMA pma, u_int32_t rand4fingerprint, u_int32_t fingerprint);
 
 #endif