slow start on isam-d

diff --git a/isamc/isamd-p.h b/isamc/isamd-p.h
index 81d1530..bffb923 100644 (file)
--- a/isamc/isamd-p.h
+++ b/isamc/isamd-p.h
@@ -3,7 +3,7 @@
  * See the file LICENSE for details.
  * Heikki Levanto
  *
- *
+ * log at the end
  */
 
 #include <bfile.h>
@@ -25,7 +25,7 @@ typedef struct ISAMD_file_s {
     BFile bf;
     int head_is_dirty;
     
-    int no_writes;
+    int no_writes;  /* statistics, to be used properly... */
     int no_reads;
     int no_skip_writes;
     int no_allocated;
@@ -39,7 +39,7 @@ typedef struct ISAMD_file_s {
     int no_next;
     int no_prev;
 
-    char *alloc_buf;
+    char *alloc_buf;    /* free-list handling (?) */
     int alloc_entries_num;
     int alloc_entries_max;
 
@@ -50,25 +50,25 @@ typedef struct ISAMD_file_s {
 struct ISAMD_s {
     int no_files;
     int max_cat;
-  //  char *merge_buf;
-    char *startblock; /* start of the chain, update lastptr and numKeys here */
-    char *lastblock;  /* end of the chain, append here */
+    //char *startblock; /* start of the chain, update lastptr and numKeys here */
+    //char *lastblock;  /* end of the chain, append here */
+    //                  /* ??? */
     ISAMD_M method;
     ISAMD_file files;
 }; 
 
 struct ISAMD_PP_s {
-    char *buf;
-    ISAMD_BLOCK_SIZE offset;
-    ISAMD_BLOCK_SIZE size;
+    char *buf;   /* buffer for read/write operations */
+    ISAMD_BLOCK_SIZE offset; /* position for next read/write */
+    ISAMD_BLOCK_SIZE size;   /* size of actual pointer data */
     int cat;  /* category of this block */
     int pos;  /* block number of this block */
     int next; /* number of the next block */
+    int diffs; /* either block or offset (in head) of start of diffs */
     ISAMD is;
     void *decodeClientData;
-    int deleteFlag;
+    //int deleteFlag;
     int numKeys;
-    ISAMD_BLOCK_SIZE lastblock;  /* last block in chain */
 };
 
 #define ISAMD_BLOCK_OFFSET_N (sizeof(int) +  \
@@ -92,8 +92,8 @@ int isamd_write_block (ISAMD is, int cat, int pos, char *src);
 
 /*
  * $Log: isamd-p.h,v $
- * Revision 1.2  1999-07-14 13:21:34  heikki
- * Added isam-d files. Compiles (almost) clean. Doesn't work at all
+ * Revision 1.3  1999-07-14 15:05:30  heikki
+ * slow start on isam-d
  *
  * Revision 1.1  1999/07/14 12:34:43  heikki
  * Copied from isamh, starting to change things...

diff --git a/isamc/isamd.c b/isamc/isamd.c
index 5134f4b..f454c22 100644 (file)
--- a/isamc/isamd.c
+++ b/isamc/isamd.c
@@ -23,42 +23,43 @@
 
 #include "../index/index.h" /* for dump */
 
-static void flush_block (ISAMH is, int cat);
-static void release_fc (ISAMH is, int cat);
-static void init_fc (ISAMH is, int cat);
+static void flush_block (ISAMD is, int cat);
+static void release_fc (ISAMD is, int cat);
+static void init_fc (ISAMD is, int cat);
 
-#define ISAMH_FREELIST_CHUNK 1
+#define ISAMD_FREELIST_CHUNK 1
 
 #define SMALL_TEST 1
 
-ISAMH_M isamd_getmethod (void)
+ISAMD_M isamd_getmethod (ISAMD_M me)
 {
-    static struct ISAMH_filecat_s def_cat[] = {
+    static struct ISAMD_filecat_s def_cat[] = {
 #if SMALL_TEST
 /*        blocksz,   max keys before switching size */
-  /*      {    32,  40 }, */
-       {   128,   0 },
+        {    32,   40 },
+       {   128,    0 },
 #else
         {    24,   40 },
         {  2048, 2048 },
-        { 16384,    0  },
+        { 16384,    0 },
 
 #endif 
-#ifdef OLDVALUES
+
+/* old values from isamc, long time ago...
         {    24,   40 },
        {   128,  256 },
         {   512, 1024 },
         {  2048, 4096 },
         {  8192,16384 },
         { 32768,   0  },
+*/
 
-#endif
 /* assume about 2 bytes per pointer, when compressed. The head uses */
 /* 16 bytes, and other blocks use 8 for header info... If you want 3 */
 /* blocks of 32 bytes, say max 16+24+24 = 64 keys */
 
     };
-    ISAMH_M m = (ISAMH_M) xmalloc (sizeof(*m));
+    ISAMD_M m = (ISAMD_M) xmalloc (sizeof(*m));
     m->filecat = def_cat;
 
     m->code_start = NULL;
@@ -77,60 +78,40 @@ ISAMH_M isamd_getmethod (void)
 
 
 
-ISAMH isamd_open (BFiles bfs, const char *name, int writeflag, ISAMH_M method)
+ISAMD isamd_open (BFiles bfs, const char *name, int writeflag, ISAMD_M method)
 {
-    ISAMH is;
-    ISAMH_filecat filecat;
+    ISAMD is;
+    ISAMD_filecat filecat;
     int i = 0;
-    int max_buf_size = 0;
 
-    is = (ISAMH) xmalloc (sizeof(*is));
+    is = (ISAMD) xmalloc (sizeof(*is));
 
-    is->method = (ISAMH_M) xmalloc (sizeof(*is->method));
+    is->method = (ISAMD_M) xmalloc (sizeof(*is->method));
     memcpy (is->method, method, sizeof(*method));
     filecat = is->method->filecat;
     assert (filecat);
 
     /* determine number of block categories */
     if (is->method->debug)
-        logf (LOG_LOG, "isc: bsize  maxkeys");
+        logf (LOG_LOG, "isamd: bsize  maxkeys");
     do
     {
         if (is->method->debug)
-            logf (LOG_LOG, "isc:%6d %6d",
+            logf (LOG_LOG, "isamd:%6d %6d",
                   filecat[i].bsize, filecat[i].mblocks);
-        if (max_buf_size < filecat[i].bsize)
-            max_buf_size = filecat[i].bsize;
     } while (filecat[i++].mblocks);
     is->no_files = i;
     is->max_cat = --i;
-#ifdef SKIPTHIS
-    /* max_buf_size is the larget buffer to be used during merge */
-    max_buf_size = (1 + max_buf_size / filecat[i].bsize) * filecat[i].bsize;
-    if (max_buf_size < (1+is->method->max_blocks_mem) * filecat[i].bsize)
-        max_buf_size = (1+is->method->max_blocks_mem) * filecat[i].bsize;
-#endif
 
-    if (is->method->debug)
-        logf (LOG_LOG, "isc: max_buf_size %d", max_buf_size);
-    
     assert (is->no_files > 0);
-    is->files = (ISAMH_file) xmalloc (sizeof(*is->files)*is->no_files);
+    is->files = (ISAMD_file) xmalloc (sizeof(*is->files)*is->no_files);
     if (writeflag)
     {
-#ifdef SKIPTHIS
-        is->merge_buf = (char *) xmalloc (max_buf_size+256);
-       memset (is->merge_buf, 0, max_buf_size+256);
-#else
-        is->startblock = (char *) xmalloc (max_buf_size+256);
-       memset (is->startblock, 0, max_buf_size+256);
-        is->lastblock = (char *) xmalloc (max_buf_size+256);
-       memset (is->lastblock, 0, max_buf_size+256);
-       /* The spare 256 bytes should not be needed! */
-#endif
+      /* TODO - what ever needs to be done here... */
     }
     else
-        is->startblock = is->lastblock = NULL;
+    {
+    }
 
     for (i = 0; i<is->no_files; i++)
     {
@@ -140,7 +121,7 @@ ISAMH isamd_open (BFiles bfs, const char *name, int writeflag, ISAMH_M method)
         is->files[i].bf = bf_open (bfs, fname, is->method->filecat[i].bsize,
                                    writeflag);
         is->files[i].head_is_dirty = 0;
-        if (!bf_read (is->files[i].bf, 0, 0, sizeof(ISAMH_head),
+        if (!bf_read (is->files[i].bf, 0, 0, sizeof(ISAMD_head),
                      &is->files[i].head))
         {
             is->files[i].head.lastblock = 1;
@@ -151,7 +132,7 @@ ISAMH isamd_open (BFiles bfs, const char *name, int writeflag, ISAMH_M method)
            is->method->filecat[i].bsize / sizeof(int) - 1;
        is->files[i].alloc_buf = (char *)
            xmalloc (is->method->filecat[i].bsize);
-        is->files[i].no_writes = 0;
+        is->files[i].no_writes = 0; /* clear statistics */
         is->files[i].no_reads = 0;
         is->files[i].no_skip_writes = 0;
         is->files[i].no_allocated = 0;
@@ -169,30 +150,30 @@ ISAMH isamd_open (BFiles bfs, const char *name, int writeflag, ISAMH_M method)
     return is;
 }
 
-int isamd_block_used (ISAMH is, int type)
+int isamd_block_used (ISAMD is, int type)
 {
     if (type < 0 || type >= is->no_files)
        return -1;
     return is->files[type].head.lastblock-1;
 }
 
-int isamd_block_size (ISAMH is, int type)
+int isamd_block_size (ISAMD is, int type)
 {
-    ISAMH_filecat filecat = is->method->filecat;
+    ISAMD_filecat filecat = is->method->filecat;
     if (type < 0 || type >= is->no_files)
        return -1;
     return filecat[type].bsize;
 }
 
-int isamd_close (ISAMH is)
+int isamd_close (ISAMD is)
 {
     int i;
 
     if (is->method->debug)
     {
-       logf (LOG_LOG, "isc:    next    forw   mid-f    prev   backw   mid-b");
+       logf (LOG_LOG, "isamd:    next    forw   mid-f    prev   backw   mid-b");
        for (i = 0; i<is->no_files; i++)
-           logf (LOG_LOG, "isc:%8d%8d%8.1f%8d%8d%8.1f",
+           logf (LOG_LOG, "isamd:%8d%8d%8.1f%8d%8d%8.1f",
                  is->files[i].no_next,
                  is->files[i].no_forward,
                  is->files[i].no_forward ?
@@ -205,16 +186,16 @@ int isamd_close (ISAMH is)
                  : 0.0);
     }
     if (is->method->debug)
-        logf (LOG_LOG, "isc:  writes   reads skipped   alloc released  remap");
+        logf (LOG_LOG, "isamd:  writes   reads skipped   alloc released  remap");
     for (i = 0; i<is->no_files; i++)
     {
         release_fc (is, i);
         assert (is->files[i].bf);
         if (is->files[i].head_is_dirty)
-            bf_write (is->files[i].bf, 0, 0, sizeof(ISAMH_head),
+            bf_write (is->files[i].bf, 0, 0, sizeof(ISAMD_head),
                  &is->files[i].head);
         if (is->method->debug)
-            logf (LOG_LOG, "isc:%8d%8d%8d%8d%8d%8d",
+            logf (LOG_LOG, "isamd:%8d%8d%8d%8d%8d%8d",
                   is->files[i].no_writes,
                   is->files[i].no_reads,
                   is->files[i].no_skip_writes,
@@ -226,42 +207,41 @@ int isamd_close (ISAMH is)
         bf_close (is->files[i].bf);
     }
     xfree (is->files);
-    xfree (is->startblock);
-    xfree (is->lastblock);
     xfree (is->method);
     xfree (is);
     return 0;
 }
 
-int isamd_read_block (ISAMH is, int cat, int pos, char *dst)
+int isamd_read_block (ISAMD is, int cat, int pos, char *dst)
 {
     ++(is->files[cat].no_reads);
     return bf_read (is->files[cat].bf, pos, 0, 0, dst);
 }
 
-int isamd_write_block (ISAMH is, int cat, int pos, char *src)
+int isamd_write_block (ISAMD is, int cat, int pos, char *src)
 {
     ++(is->files[cat].no_writes);
     if (is->method->debug > 2)
-        logf (LOG_LOG, "isc: write_block %d %d", cat, pos);
+        logf (LOG_LOG, "isamd: write_block %d %d", cat, pos);
     return bf_write (is->files[cat].bf, pos, 0, 0, src);
 }
 
-int isamd_write_dblock (ISAMH is, int cat, int pos, char *src,
+int isamd_write_dblock (ISAMD is, int cat, int pos, char *src,
                       int nextpos, int offset)
 {
-    ISAMH_BLOCK_SIZE size = offset + ISAMH_BLOCK_OFFSET_N;
+    ISAMD_BLOCK_SIZE size = offset + ISAMD_BLOCK_OFFSET_N;
     if (is->method->debug > 2)
-        logf (LOG_LOG, "isc: write_dblock. size=%d nextpos=%d",
+        logf (LOG_LOG, "isamd: write_dblock. size=%d nextpos=%d",
               (int) size, nextpos);
-    src -= ISAMH_BLOCK_OFFSET_N;
+    src -= ISAMD_BLOCK_OFFSET_N;
+    assert( ISAMD_BLOCK_OFFSET_N == sizeof(int)+sizeof(int) );
     memcpy (src, &nextpos, sizeof(int));
     memcpy (src + sizeof(int), &size, sizeof(size));
     return isamd_write_block (is, cat, pos, src);
 }
 
-#if ISAMH_FREELIST_CHUNK
-static void flush_block (ISAMH is, int cat)
+#if ISAMD_FREELIST_CHUNK
+static void flush_block (ISAMD is, int cat)
 {
     char *abuf = is->files[cat].alloc_buf;
     int block = is->files[cat].head.freelist;
@@ -274,7 +254,7 @@ static void flush_block (ISAMH is, int cat)
     xfree (abuf);
 }
 
-static int alloc_block (ISAMH is, int cat)
+static int alloc_block (ISAMD is, int cat)
 {
     int block = is->files[cat].head.freelist;
     char *abuf = is->files[cat].alloc_buf;
@@ -320,7 +300,7 @@ static int alloc_block (ISAMH is, int cat)
     return block;
 }
 
-static void release_block (ISAMH is, int cat, int pos)
+static void release_block (ISAMD is, int cat, int pos)
 {
     char *abuf = is->files[cat].alloc_buf;
     int block = is->files[cat].head.freelist;
@@ -357,13 +337,13 @@ static void release_block (ISAMH is, int cat, int pos)
     is->files[cat].alloc_entries_num++;
 }
 #else
-static void flush_block (ISAMH is, int cat)
+static void flush_block (ISAMD is, int cat)
 {
     char *abuf = is->files[cat].alloc_buf;
     xfree (abuf);
 }
 
-static int alloc_block (ISAMH is, int cat)
+static int alloc_block (ISAMD is, int cat)
 {
     int block;
     char buf[sizeof(int)];
@@ -380,7 +360,7 @@ static int alloc_block (ISAMH is, int cat)
     return block;
 }
 
-static void release_block (ISAMH is, int cat, int pos)
+static void release_block (ISAMD is, int cat, int pos)
 {
     char buf[sizeof(int)];
    
@@ -392,7 +372,7 @@ static void release_block (ISAMH is, int cat, int pos)
 }
 #endif
 
-int isamd_alloc_block (ISAMH is, int cat)
+int isamd_alloc_block (ISAMD is, int cat)
 {
     int block = 0;
 
@@ -410,14 +390,14 @@ int isamd_alloc_block (ISAMH is, int cat)
     if (!block)
         block = alloc_block (is, cat);
     if (is->method->debug > 3)
-        logf (LOG_LOG, "isc: alloc_block in cat %d: %d", cat, block);
+        logf (LOG_LOG, "isamd: alloc_block in cat %d: %d", cat, block);
     return block;
 }
 
-void isamd_release_block (ISAMH is, int cat, int pos)
+void isamd_release_block (ISAMD is, int cat, int pos)
 {
     if (is->method->debug > 3)
-        logf (LOG_LOG, "isc: release_block in cat %d: %d", cat, pos);
+        logf (LOG_LOG, "isamd: release_block in cat %d: %d", cat, pos);
     if (is->files[cat].fc_list)
     {
         int j;
@@ -431,7 +411,7 @@ void isamd_release_block (ISAMH is, int cat, int pos)
     release_block (is, cat, pos);
 }
 
-static void init_fc (ISAMH is, int cat)
+static void init_fc (ISAMD is, int cat)
 {
     int j = 100;
         
@@ -442,7 +422,7 @@ static void init_fc (ISAMH is, int cat)
         is->files[cat].fc_list[j] = 0;
 }
 
-static void release_fc (ISAMH is, int cat)
+static void release_fc (ISAMD is, int cat)
 {
     int b, j = is->files[cat].fc_max;
 
@@ -454,18 +434,18 @@ static void release_fc (ISAMH is, int cat)
         }
 }
 
-void isamd_pp_close (ISAMH_PP pp)
+void isamd_pp_close (ISAMD_PP pp)
 {
-    ISAMH is = pp->is;
+    ISAMD is = pp->is;
 
-    (*is->method->code_stop)(ISAMH_DECODE, pp->decodeClientData);
+    (*is->method->code_stop)(ISAMD_DECODE, pp->decodeClientData);
     xfree (pp->buf);
     xfree (pp);
 }
 
-ISAMH_PP isamd_pp_open (ISAMH is, ISAMH_P ipos)
+ISAMD_PP isamd_pp_open (ISAMD is, ISAMD_P ipos)
 {
-    ISAMH_PP pp = (ISAMH_PP) xmalloc (sizeof(*pp));
+    ISAMD_PP pp = (ISAMD_PP) xmalloc (sizeof(*pp));
     char *src;
    
     pp->cat = isamd_type(ipos);
@@ -477,10 +457,10 @@ ISAMH_PP isamd_pp_open (ISAMH is, ISAMH_P ipos)
     pp->size = 0;
     pp->offset = 0;
     pp->is = is;
-    pp->decodeClientData = (*is->method->code_start)(ISAMH_DECODE);
-    pp->deleteFlag = 0;
+    pp->decodeClientData = (*is->method->code_start)(ISAMD_DECODE);
+    //pp->deleteFlag = 0;
     pp->numKeys = 0;
-    pp->lastblock=0;
+    pp->diffs=0;
     
     if (pp->pos)
     {
@@ -492,11 +472,11 @@ ISAMH_PP isamd_pp_open (ISAMH is, ISAMH_P ipos)
         src += sizeof(pp->size);
         memcpy (&pp->numKeys, src, sizeof(pp->numKeys));
         src += sizeof(pp->numKeys);
-        memcpy (&pp->lastblock, src, sizeof(pp->lastblock));
-        src += sizeof(pp->lastblock);
+        memcpy (&pp->diffs, src, sizeof(pp->diffs));
+        src += sizeof(pp->diffs);
         assert (pp->next != pp->pos);
         pp->offset = src - pp->buf; 
-        assert (pp->offset == ISAMH_BLOCK_OFFSET_1);
+        assert (pp->offset == ISAMD_BLOCK_OFFSET_1);
         if (is->method->debug > 2)
             logf (LOG_LOG, "isamd_pp_open sz=%d c=%d p=%d n=%d",
                  pp->size, pp->cat, pp->pos, isamd_block(pp->next));
@@ -506,7 +486,7 @@ ISAMH_PP isamd_pp_open (ISAMH is, ISAMH_P ipos)
 
 
 
-void isamd_buildfirstblock(ISAMH_PP pp){
+void isamd_buildfirstblock(ISAMD_PP pp){
   char *dst=pp->buf;
   assert(pp->buf);
   assert(pp->next != pp->pos); 
@@ -516,19 +496,18 @@ void isamd_buildfirstblock(ISAMH_PP pp){
   dst += sizeof(pp->size);
   memcpy(dst, &pp->numKeys, sizeof(pp->numKeys));
   dst += sizeof(pp->numKeys);
-  memcpy(dst, &pp->lastblock, sizeof(pp->lastblock));
-  dst += sizeof(pp->lastblock);  
-  assert (dst - pp->buf  == ISAMH_BLOCK_OFFSET_1);
+  memcpy(dst, &pp->diffs, sizeof(pp->diffs));
+  dst += sizeof(pp->diffs);  
+  assert (dst - pp->buf  == ISAMD_BLOCK_OFFSET_1);
   if (pp->is->method->debug > 2)
-     logf (LOG_LOG, "isamd: first: sz=%d  p=%d/%d>%d/%d>%d/%d nk=%d",
+     logf (LOG_LOG, "isamd: first: sz=%d  p=%d/%d>%d/%d nk=%d d=%d",
            pp->size, 
-           pp->pos, pp->cat, 
-           isamd_block(pp->next), isamd_type(pp->next),
-           isamd_block(pp->lastblock), isamd_type(pp->lastblock),
-           pp->numKeys);
+           pp->cat, pp->pos, 
+           isamd_type(pp->next), isamd_block(pp->next),
+           pp->numKeys, pp->diffs);
 }
 
-void isamd_buildlaterblock(ISAMH_PP pp){
+void isamd_buildlaterblock(ISAMD_PP pp){
   char *dst=pp->buf;
   assert(pp->buf);
   assert(pp->next != isamd_addr(pp->pos,pp->cat)); 
@@ -536,7 +515,7 @@ void isamd_buildlaterblock(ISAMH_PP pp){
   dst += sizeof(pp->next);
   memcpy(dst, &pp->size,sizeof(pp->size));
   dst += sizeof(pp->size);
-  assert (dst - pp->buf  == ISAMH_BLOCK_OFFSET_N);
+  assert (dst - pp->buf  == ISAMD_BLOCK_OFFSET_N);
   if (pp->is->method->debug > 2)
      logf (LOG_LOG, "isamd: l8r: sz=%d  p=%d/%d>%d/%d",
            pp->size, 
@@ -547,7 +526,7 @@ void isamd_buildlaterblock(ISAMH_PP pp){
 
 
 /* returns non-zero if item could be read; 0 otherwise */
-int isamd_pp_read (ISAMH_PP pp, void *buf)
+int isamd_pp_read (ISAMD_PP pp, void *buf)
 {
     return isamd_read_item (pp, (char **) &buf);
 }
@@ -557,9 +536,9 @@ int isamd_pp_read (ISAMH_PP pp, void *buf)
      0 if end-of-file
      1 if item could be read ok and NO boundary
      2 if item could be read ok and boundary */
-int isamd_read_item (ISAMH_PP pp, char **dst)
+int isamd_read_item (ISAMD_PP pp, char **dst)
 {
-    ISAMH is = pp->is;
+    ISAMD is = pp->is;
     char *src = pp->buf + pp->offset;
     int newcat;
 
@@ -606,24 +585,24 @@ int isamd_read_item (ISAMH_PP pp, char **dst)
         memcpy (&pp->size, src, sizeof(pp->size));
         src += sizeof(pp->size);
         /* assume block is non-empty */
-        assert (src - pp->buf == ISAMH_BLOCK_OFFSET_N);
+        assert (src - pp->buf == ISAMD_BLOCK_OFFSET_N);
         assert (pp->next != isamd_addr(pp->pos,pp->cat));
-        if (pp->deleteFlag)
-            isamd_release_block (is, pp->cat, pp->pos);
+        //if (pp->deleteFlag)
+        //    isamd_release_block (is, pp->cat, pp->pos);
         (*is->method->code_reset)(pp->decodeClientData);
-        (*is->method->code_item)(ISAMH_DECODE, pp->decodeClientData, dst, &src);
+        (*is->method->code_item)(ISAMD_DECODE, pp->decodeClientData, dst, &src);
         pp->offset = src - pp->buf; 
         if (is->method->debug > 2)
-            logf (LOG_LOG, "isc: read_block size=%d %d %d next=%d",
+            logf (LOG_LOG, "isamd: read_block size=%d %d %d next=%d",
                  pp->size, pp->cat, pp->pos, pp->next);
         return 2;
     }
-    (*is->method->code_item)(ISAMH_DECODE, pp->decodeClientData, dst, &src);
+    (*is->method->code_item)(ISAMD_DECODE, pp->decodeClientData, dst, &src);
     pp->offset = src - pp->buf; 
     return 1;
 }
 
-int isamd_pp_num (ISAMH_PP pp)
+int isamd_pp_num (ISAMD_PP pp)
 {
     return pp->numKeys;
 }
@@ -643,10 +622,10 @@ static char *hexdump(unsigned char *p, int len, char *buff) {
 }
 
 
-void isamd_pp_dump (ISAMH is, ISAMH_P ipos)
+void isamd_pp_dump (ISAMD is, ISAMD_P ipos)
 {
-  ISAMH_PP pp;
-  ISAMH_P oldaddr=0;
+  ISAMD_PP pp;
+  ISAMD_P oldaddr=0;
   struct it_key key;
   int i,n;
   int occur =0;
@@ -656,11 +635,9 @@ void isamd_pp_dump (ISAMH is, ISAMH_P ipos)
   logf(LOG_LOG,"dumping isamd block %d (%d:%d)",
                   (int)ipos, isamd_type(ipos), isamd_block(ipos) );
   pp=isamd_pp_open(is,ipos);
-  logf(LOG_LOG,"numKeys=%d, last=%d (%d:%d) ofs=%d ",
+  logf(LOG_LOG,"numKeys=%d,  ofs=%d d=%d",
        pp->numKeys, 
-       pp->lastblock, 
-       isamd_type(pp->lastblock), isamd_block(pp->lastblock),
-       pp->offset);
+       pp->offset, pp->diffs);
   oldoffs= pp->offset;
   while(isamd_pp_read(pp, &key))
   {
@@ -679,8 +656,8 @@ void isamd_pp_dump (ISAMH is, ISAMH_P ipos)
           logf(LOG_LOG,"  %05x: %s",i,hexdump(pp->buf+i,n,hexbuff));
           i+=n;
         }
-        if (oldoffs >  ISAMH_BLOCK_OFFSET_N)
-           oldoffs=ISAMH_BLOCK_OFFSET_N;
+        if (oldoffs >  ISAMD_BLOCK_OFFSET_N)
+           oldoffs=ISAMD_BLOCK_OFFSET_N;
      } /* new block */
      occur++;
      logf (LOG_LOG,"    got %d:%d=%x:%x from %s at %d=%x",
@@ -690,12 +667,16 @@ void isamd_pp_dump (ISAMH is, ISAMH_P ipos)
                  oldoffs, oldoffs);
      oldoffs = pp->offset;
   }
+  /*!*/ /*TODO: dump diffs too!!! */
   isamd_pp_close(pp);
 } /* dump */
 
 /*
  * $Log: isamd.c,v $
- * Revision 1.1  1999-07-14 12:34:43  heikki
+ * Revision 1.2  1999-07-14 15:05:30  heikki
+ * slow start on isam-d
+ *
+ * Revision 1.1  1999/07/14 12:34:43  heikki
  * Copied from isamh, starting to change things...
  *
  *

diff --git a/isamc/merge-d.c b/isamc/merge-d.c
index 47902e4..16032c8 100644 (file)
--- a/isamc/merge-d.c
+++ b/isamc/merge-d.c
@@ -31,19 +31,41 @@ static char *hexdump(unsigned char *p, int len, char *buff) {
 
 
 /* isamd - heikki's append-only isam 
-*/
+ *
+ * The record pointers arre kept in a linked list of buffers, as usual.
+ * When modifying the list, we just store diffs at the end of it (either
+ * in the only block, or in a separate block). Occasionally we have too
+ * many blocks, and then we merge the diffs into the list.
+ */
 
 
 
 ISAMD_P isamd_append (ISAMD is, ISAMD_P ipos, ISAMD_I data)
 {
-    
+  char i_item[128];    /* one input item */
+  char *i_ptr=i_item;
+  int i_more =1;
+  int i_mode;     /* 0 for delete, 1 for insert */ 
+
+  int retval=0;
+  
+  while (i_more)
+  {
+     i_ptr = i_item;
+     i_more = (*data->read_item)(data->clientData, &i_ptr, &i_mode); 
+     if (!retval)
+       memcpy(&retval,i_item, sizeof(retval));
+  }
+  return retval;
 } /*  isamh_append */
 
 
 /*
  * $Log: merge-d.c,v $
- * Revision 1.1  1999-07-14 13:14:47  heikki
+ * Revision 1.2  1999-07-14 15:05:30  heikki
+ * slow start on isam-d
+ *
+ * Revision 1.1  1999/07/14 13:14:47  heikki
  * Created empty
  *
  *