X-Git-Url: http://git.indexdata.com/?a=blobdiff_plain;f=isamb%2Fisamb.c;h=460b8ad7eb25dbd04862b483e1f9c238b612124e;hb=dbf15c09e6ad1986b914c695c161f81f774e9f39;hp=be62d0981470994c3f09d646a2eaeb6133fe6f21;hpb=896c0427df9d8eff5de6a1735dcd992e067df844;p=idzebra-moved-to-github.git

diff --git a/isamb/isamb.c b/isamb/isamb.c
index be62d09..460b8ad 100644
--- a/isamb/isamb.c
+++ b/isamb/isamb.c
@@ -1,5 +1,5 @@
-/* $Id: isamb.c,v 1.19 2002-08-02 19:26:56 adam Exp $
-   Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002
+/* $Id: isamb.c,v 1.24 2003-03-17 20:22:54 adam Exp $
+   Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003
    Index Data Aps
 
 This file is part of the Zebra server.
@@ -20,7 +20,7 @@ Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 02111-1307, USA.
 */
 
-
+#include <string.h>
 #include <yaz/xmalloc.h>
 #include <yaz/log.h>
 #include <isamb.h>
@@ -31,6 +31,7 @@ struct ISAMB_head {
     int last_block;
     int block_size;
     int block_max;
+    int free_list;
 };
 
 #define ISAMB_DATA_OFFSET 3
@@ -44,7 +45,7 @@ struct ISAMB_head {
 
 struct ISAMB_cache_entry {
     ISAMB_P pos;
-    char *buf;
+    unsigned char *buf;
     int dirty;
     int hits;
     struct ISAMB_cache_entry *next;
@@ -65,6 +66,8 @@ struct ISAMB_s {
     struct ISAMB_file *file;
     int no_cat;
     int cache; /* 0=no cache, 1=use cache, -1=dummy isam (for testing only) */
+    int log_io;        /* log level for bf_read/bf_write calls */
+    int log_freelist;  /* log level for freelist handling */
 };
 
 struct ISAMB_block {
@@ -73,10 +76,12 @@ struct ISAMB_block {
     int size;
     int leaf;
     int dirty;
+    int deleted;
     int offset;
     char *bytes;
     unsigned char *buf;
     void *decodeClientData;
+    int log_rw;
 };
 
 struct ISAMB_PP_s {
@@ -110,8 +115,10 @@ ISAMB isamb_open (BFiles bfs, const char *name, int writeflag, ISAMC_M method,
     isamb->method = (ISAMC_M) xmalloc (sizeof(*method));
     memcpy (isamb->method, method, sizeof(*method));
     isamb->no_cat = 4;
+    isamb->log_io = 0;
     isamb->cache = cache;
 
+    assert (cache == 0);
     isamb->file = xmalloc (sizeof(*isamb->file) * isamb->no_cat);
     for (i = 0; i<isamb->no_cat; i++)
     {
@@ -133,6 +140,7 @@ ISAMB isamb_open (BFiles bfs, const char *name, int writeflag, ISAMC_M method,
             isamb->file[i].head.last_block = isamb->file[i].head.first_block;
             isamb->file[i].head.block_size = b_size;
             isamb->file[i].head.block_max = b_size - ISAMB_DATA_OFFSET;
+            isamb->file[i].head.free_list = 0;
 	}
         assert (isamb->file[i].head.block_size >= ISAMB_DATA_OFFSET);
         isamb->file[i].head_dirty = 0;
@@ -150,7 +158,10 @@ static void flush_blocks (ISAMB b, int cat)
         b->file[cat].cache_entries = ce_this->next;
 
         if (ce_this->dirty)
+        {
+            yaz_log (b->log_io, "bf_write: flush_blocks");
             bf_write (b->file[cat].bf, ce_this->pos, 0, 0, ce_this->buf);
+        }
         xfree (ce_this->buf);
         xfree (ce_this);
     }
@@ -200,7 +211,10 @@ static int get_block (ISAMB b, ISAMC_P pos, char *userbuf, int wr)
         ce_this = *ce_last;
         *ce_last = 0;  /* remove the last entry from list */
         if (ce_this->dirty)
+        {
+            yaz_log (b->log_io, "bf_write: get_block");
             bf_write (b->file[cat].bf, ce_this->pos, 0, 0, ce_this->buf);
+        }
         xfree (ce_this->buf);
         xfree (ce_this);
     }
@@ -209,6 +223,7 @@ static int get_block (ISAMB b, ISAMC_P pos, char *userbuf, int wr)
     b->file[cat].cache_entries = ce_this;
     ce_this->buf = xmalloc (ISAMB_CACHE_ENTRY_SIZE);
     ce_this->pos = norm;
+    yaz_log (b->log_io, "bf_read: get_block");
     if (!bf_read (b->file[cat].bf, norm, 0, 0, ce_this->buf))
         memset (ce_this->buf, 0, ISAMB_CACHE_ENTRY_SIZE);
     if (wr)
@@ -235,6 +250,7 @@ void isamb_close (ISAMB isamb)
             bf_write (isamb->file[i].bf, 0, 0,
                       sizeof(struct ISAMB_head), &isamb->file[i].head);
         
+        bf_close (isamb->file[i].bf);
     }
     xfree (isamb->file);
     xfree (isamb->method);
@@ -255,6 +271,7 @@ struct ISAMB_block *open_block (ISAMB b, ISAMC_P pos)
 
     if (!get_block (b, pos, p->buf, 0))
     {
+        yaz_log (b->log_io, "bf_read: open_block");
         if (!bf_read (b->file[cat].bf, pos/4, 0, 0, p->buf))
         {
             yaz_log (LOG_FATAL, "read failure for pos=%ld block=%ld",
@@ -264,9 +281,15 @@ struct ISAMB_block *open_block (ISAMB b, ISAMC_P pos)
     }
     p->bytes = p->buf + ISAMB_DATA_OFFSET;
     p->leaf = p->buf[0];
-    p->size = p->buf[1] + 256 * p->buf[2] - ISAMB_DATA_OFFSET;
+    p->size = (p->buf[1] + 256 * p->buf[2]) - ISAMB_DATA_OFFSET;
+    if (p->size < 0)
+    {
+        fprintf (stderr, "pos=%d\n", pos);
+    }
+    assert (p->size >= 0);
     p->offset = 0;
     p->dirty = 0;
+    p->deleted = 0;
     p->decodeClientData = (*b->method->code_start)(ISAMC_DECODE);
     return p;
 }
@@ -274,20 +297,42 @@ struct ISAMB_block *open_block (ISAMB b, ISAMC_P pos)
 struct ISAMB_block *new_block (ISAMB b, int leaf, int cat)
 {
     struct ISAMB_block *p;
-    int block_no;
-    
+
     p = xmalloc (sizeof(*p));
-    block_no = b->file[cat].head.last_block++;
-    p->cat = cat;
-    p->pos = block_no * 4 + cat;
+    p->buf = xmalloc (b->file[cat].head.block_size);
+
+    if (!b->file[cat].head.free_list)
+    {
+        int block_no;
+        block_no = b->file[cat].head.last_block++;
+        p->pos = block_no * 4 + cat;
+    }
+    else
+    {
+        p->pos = b->file[cat].head.free_list;
+        assert((p->pos & 3) == cat);
+        if (!get_block (b, p->pos, p->buf, 0))
+        {
+            yaz_log (b->log_io, "bf_read: new_block");
+            if (!bf_read (b->file[cat].bf, p->pos/4, 0, 0, p->buf))
+            {
+                yaz_log (LOG_FATAL, "read failure for pos=%ld block=%ld",
+                         (long) p->pos/4, (long) p->pos/4);
+                abort ();
+            }
+        }
+        yaz_log (b->log_freelist, "got block %d from freelist %d:%d", p->pos,
+                 cat, p->pos/4);
+        memcpy (&b->file[cat].head.free_list, p->buf, sizeof(int));
+    }
     p->cat = cat;
     b->file[cat].head_dirty = 1;
-    p->buf = xmalloc (b->file[cat].head.block_size);
     memset (p->buf, 0, b->file[cat].head.block_size);
     p->bytes = p->buf + ISAMB_DATA_OFFSET;
     p->leaf = leaf;
     p->size = 0;
     p->dirty = 1;
+    p->deleted = 0;
     p->offset = 0;
     p->decodeClientData = (*b->method->code_start)(ISAMC_DECODE);
     return p;
@@ -304,18 +349,63 @@ struct ISAMB_block *new_int (ISAMB b, int cat)
     return new_block (b, 0, cat);
 }
 
+static void check_block (ISAMB b, struct ISAMB_block *p)
+{
+    if (p->leaf)
+    {
+        ;
+    }
+    else
+    {
+        /* sanity check */
+        char *startp = p->bytes;
+        char *src = startp;
+        char *endp = p->bytes + p->size;
+        int pos;
+            
+        decode_ptr (&src, &pos);
+        assert ((pos&3) == p->cat);
+        while (src != endp)
+        {
+            int item_len;
+            decode_ptr (&src, &item_len);
+            assert (item_len > 0 && item_len < 30);
+            src += item_len;
+            decode_ptr (&src, &pos);
+            assert ((pos&3) == p->cat);
+        }
+    }
+}
+
 void close_block (ISAMB b, struct ISAMB_block *p)
 {
     if (!p)
         return;
-    if (p->dirty)
+    if (p->deleted)
+    {
+        yaz_log (b->log_freelist, "release block %d from freelist %d:%d",
+                 p->pos, p->cat, p->pos/4);
+        memcpy (p->buf, &b->file[p->cat].head.free_list, sizeof(int));
+        b->file[p->cat].head.free_list = p->pos;
+        if (!get_block (b, p->pos, p->buf, 1))
+        {
+            yaz_log (b->log_io, "bf_write: close_block (deleted)");
+            bf_write (b->file[p->cat].bf, p->pos/4, 0, 0, p->buf);
+        }
+    }
+    else if (p->dirty)
     {
         int size = p->size + ISAMB_DATA_OFFSET;
+        assert (p->size >= 0);
         p->buf[0] = p->leaf;
         p->buf[1] = size & 255;
         p->buf[2] = size >> 8;
+        check_block(b, p);
         if (!get_block (b, p->pos, p->buf, 1))
+        {
+            yaz_log (b->log_io, "bf_write: close_block");
             bf_write (b->file[p->cat].bf, p->pos/4, 0, 0, p->buf);
+        }
     }
     (*b->method->code_stop)(ISAMC_DECODE, p->decodeClientData);
     xfree (p->buf);
@@ -345,11 +435,13 @@ int insert_int (ISAMB b, struct ISAMB_block *p, void *lookahead_item,
 
     *sp = 0;
 
+    assert(p->size >= 0);
     decode_ptr (&src, &pos);
     while (src != endp)
     {
         int item_len;
         int d;
+        char *src0 = src;
         decode_ptr (&src, &item_len);
         d = (*b->method->compare_item)(src, lookahead_item);
         if (d > 0)
@@ -359,6 +451,7 @@ int insert_int (ISAMB b, struct ISAMB_block *p, void *lookahead_item,
             more = insert_sub (b, &sub_p1, lookahead_item, mode,
                                stream, &sub_p2, 
                                sub_item, &sub_size, src);
+            src = src0;
             break;
         }
         src += item_len;
@@ -395,6 +488,7 @@ int insert_int (ISAMB b, struct ISAMB_block *p, void *lookahead_item,
             dst += endp - src;
         }
         p->size = dst - dst_buf;
+        assert (p->size >= 0);
         if (p->size <= b->file[p->cat].head.block_max)
         {
             memcpy (startp, dst_buf, dst - dst_buf);
@@ -600,6 +694,7 @@ int insert_leaf (ISAMB b, struct ISAMB_block **sp1, void *lookahead_item,
         new_size > b->file[p->cat].head.block_max)
     {
         /* non-btree block will be removed */
+        p->deleted = 1;
         close_block (b, p);
         /* delete it too!! */
         p = 0; /* make a new one anyway */
@@ -785,7 +880,7 @@ int isamb_block_info (ISAMB isamb, int cat)
 
 void isamb_pp_close (ISAMB_PP pp)
 {
-    return isamb_pp_close_x (pp, 0, 0);
+    isamb_pp_close_x (pp, 0, 0);
 }
 
 int isamb_pp_read (ISAMB_PP pp, void *buf)