X-Git-Url: http://git.indexdata.com/?a=blobdiff_plain;f=isam%2Fmemory.c;h=034f6d4eb751585987c5a21b0f6553e673c029a8;hb=b879b04a092d5b00cc866cf16f755e55053d2e89;hp=13be94b6c45d8848d590e7334f2e2c2e678ac9dd;hpb=c6c40893444f2288cdea91d30dd92df0f285e67d;p=idzebra-moved-to-github.git

diff --git a/isam/memory.c b/isam/memory.c
index 13be94b..034f6d4 100644
--- a/isam/memory.c
+++ b/isam/memory.c
@@ -4,7 +4,22 @@
  * Sebastian Hammer, Adam Dickmeiss
  *
  * $Log: memory.c,v $
- * Revision 1.1  1994-09-26 16:07:56  quinn
+ * Revision 1.6  1995-09-04 12:33:47  adam
+ * Various cleanup. YAZ util used instead.
+ *
+ * Revision 1.5  1994/09/28  16:58:33  quinn
+ * Small mod.
+ *
+ * Revision 1.4  1994/09/27  20:03:52  quinn
+ * Seems relatively bug-free.
+ *
+ * Revision 1.3  1994/09/26  17:11:30  quinn
+ * Trivial
+ *
+ * Revision 1.2  1994/09/26  17:06:35  quinn
+ * Back again...
+ *
+ * Revision 1.1  1994/09/26  16:07:56  quinn
  * Most of the functionality in place.
  *
  */
@@ -14,24 +29,35 @@
  */
 
 #include <assert.h>
+#include <stdio.h>
 
-#include <util.h>
-#include "memory.h"
-#include "physical.h"
+#include <alexutil.h>
 #include <isam.h>
 
 int is_mbuf_size[3] = { 0, 1024, 4096 };
 
-/*
- * TODO: make internal memory-management scheme for these units.
- */
+static is_mblock *mblock_tmplist = 0, *mblock_freelist = 0;
+static is_mbuf *mbuf_freelist[3] = {0, 0, 0};
+
+#define MALLOC_CHUNK 20
 
 is_mblock *xmalloc_mblock()
 {
     is_mblock *tmp;
+    int i;
 
-    tmp = xmalloc(sizeof(is_mblock));
+    if (!mblock_freelist)
+    {
+    	mblock_freelist = xmalloc(sizeof(is_mblock) * MALLOC_CHUNK);
+	for (i = 0; i < MALLOC_CHUNK - 1; i++)
+	    mblock_freelist[i].next = &mblock_freelist[i+1];
+	mblock_freelist[i].next = 0;
+    }
+    tmp = mblock_freelist;
+    mblock_freelist = mblock_freelist->next;
     tmp->next = 0;
+    tmp->state = IS_MBSTATE_UNREAD;
+    tmp->data = 0;
     return tmp;
 }
 
@@ -39,8 +65,16 @@ is_mbuf *xmalloc_mbuf(int type)
 {
     is_mbuf *tmp;
 
-    tmp = xmalloc(sizeof(is_mbuf) + is_mbuf_size[type]);
-    tmp->type = type;
+    if (mbuf_freelist[type])
+    {
+    	tmp = mbuf_freelist[type];
+    	mbuf_freelist[type] = tmp->next;
+    }
+    else
+    {
+    	tmp = xmalloc(sizeof(is_mbuf) + is_mbuf_size[type]);
+	tmp->type = type;
+    }
     tmp->refcount = type ? 1 : 0;
     tmp->offset = tmp->num = tmp->cur_record = 0;
     tmp->data = (char*) tmp + sizeof(is_mbuf);
@@ -48,19 +82,48 @@ is_mbuf *xmalloc_mbuf(int type)
     return tmp;
 }
 
-#if 0
+void xfree_mbuf(is_mbuf *p)
+{
+    p->next = mbuf_freelist[p->type];
+    mbuf_freelist[p->type] = p;
+}
+
+void xfree_mbufs(is_mbuf *l)
+{
+    is_mbuf *p;
+
+    while (l)
+    {
+    	p = l->next;
+    	xfree_mbuf(l);
+    	l = p;
+    }
+}
+
 void xfree_mblock(is_mblock *p)
 {
-    xfree(p);
+    xfree_mbufs(p->data);
+    p->next = mblock_freelist;
+    mblock_freelist = p;
+}
+
+void xrelease_mblock(is_mblock *p)
+{
+    p->next = mblock_tmplist;
+    mblock_tmplist = p;
 }
-#endif
 
-#if 0
-void xfree_mbuf(is_mblock *p)
+void xfree_mblocks(is_mblock *l)
 {
-    xfree(p);
+    is_mblock *p;
+
+    while (l)
+    {
+    	p = l->next;
+    	xfree_mblock(l);
+    	l = p;
+    }
 }
-#endif
 
 void is_m_establish_tab(ISAM is, is_mtable *tab, ISAM_P pos)
 {
@@ -91,6 +154,13 @@ void is_m_establish_tab(ISAM is, is_mtable *tab, ISAM_P pos)
     tab->is = is;
 }
 
+void is_m_release_tab(is_mtable *tab)
+{
+    xfree_mblocks(tab->data);
+    xfree_mblocks(mblock_tmplist);
+    mblock_tmplist = 0;
+}
+
 void is_m_rewind(is_mtable *tab)
 {
     tab->cur_mblock = tab->data;
@@ -205,7 +275,7 @@ int is_m_write_record(is_mtable *tab, const void *rec)
 	mbuf = tab->cur_mblock->cur_mbuf = mbuf->next;
 	mbuf->cur_record = 0;
     }
-    log(LOG_DEBUG, "is_m_write_rec(rec == %d)", mbuf->cur_record);
+    logf (LOG_DEBUG, "is_m_write_rec(rec == %d)", mbuf->cur_record);
     memcpy(mbuf->data + mbuf->offset + mbuf->cur_record * is_keysize(tab->is),
 	rec, is_keysize(tab->is));
     mbuf->num++;
@@ -228,23 +298,25 @@ void is_m_unread_record(is_mtable *tab)
 int is_m_peek_record(is_mtable *tab, void *rec)
 {
     is_mbuf *mbuf;
+    is_mblock *mblock;
 
     /* make sure block is all in memory */
     if (tab->cur_mblock->state <= IS_MBSTATE_PARTIAL)
     	if (read_current_full(tab, tab->cur_mblock) < 0)
 	    return -1;
-    mbuf = tab->cur_mblock->cur_mbuf;
+    mblock = tab->cur_mblock;
+    mbuf = mblock->cur_mbuf;
     if (mbuf->cur_record >= mbuf->num) /* are we at end of mbuf? */
     {
 	if (!mbuf->next) /* end of mblock */
 	{
-	    if (tab->cur_mblock->next)
+	    if (mblock->next)
 	    {
-		tab->cur_mblock = tab->cur_mblock->next;
-		if (tab->cur_mblock->next->state <= IS_MBSTATE_PARTIAL)
-		    if (read_current_full(tab, tab->cur_mblock->next) < 0)
+		mblock = mblock->next;
+		if (mblock->state <= IS_MBSTATE_PARTIAL)
+		    if (read_current_full(tab, mblock) < 0)
 			return -1;
-		mbuf = tab->cur_mblock->next->data;
+		mbuf = mblock->data;
 	    }
 	    else
 	    	return 0;   /* EOTable */
@@ -313,3 +385,14 @@ int is_m_seek_record(is_mtable *tab, const void *rec)
 	    return 0;
     }
 }
+
+int is_m_num_records(is_mtable *tab)
+{
+    if (tab->data->state < IS_MBSTATE_PARTIAL)
+	if (read_current_full(tab, tab->data) < 0)
+	{
+	    logf (LOG_FATAL, "read full failed");
+	    exit(1);
+	}
+    return tab->num_records;
+}