X-Git-Url: http://git.indexdata.com/?p=idzebra-moved-to-github.git;a=blobdiff_plain;f=isamc%2Fisamd.c;h=7333d31c129a5f8890a8e125eb9392144f023236;hp=f398b99af12a8047c5a247be6a372f1818760e7f;hb=e150e51a7e20a902e9fd2f11f00811f94f67d529;hpb=7afdc32625057ad7146fd043f5bcac1eeb3d53b6 diff --git a/isamc/isamd.c b/isamc/isamd.c index f398b99..7333d31 100644 --- a/isamc/isamd.c +++ b/isamc/isamd.c @@ -1,10 +1,14 @@ /* * Copyright (c) 1995-1998, Index Data. * See the file LICENSE for details. - * Heikki Levanto - * + * $Id: isamd.c,v 1.19 1999-11-30 13:48:04 adam Exp $ + * * Isamd - isam with diffs + * Programmed by: Heikki Levanto * + * Todo + * - Statistics are missing and/or completely wrong + * - Lots of code stolen from isamc, not all needed any more */ @@ -13,7 +17,7 @@ #include #include -#include +#include #include "../index/index.h" /* isamd uses the internal structure of it_key */ #include "isamd-p.h" @@ -23,41 +27,51 @@ static void init_fc (ISAMD is, int cat); #define ISAMD_FREELIST_CHUNK 1 -#define SMALL_TEST 1 +#define SMALL_TEST 0 ISAMD_M isamd_getmethod (ISAMD_M me) { static struct ISAMD_filecat_s def_cat[] = { #if SMALL_TEST -/* blocksz, max keys before switching size. Unused time being */ - { 20, 40 }, - { 32, 0 }, +/* blocksz, max. Unused time being */ + { 32, 40 }, /* 24 is the smallest unreasonable size! */ + { 64, 0 }, #else - { 24, 1 }, + { 64, 1 }, + { 128, 1 }, + { 256, 1 }, + { 512, 1 }, + { 1024, 1 }, + { 2048, 1 }, + { 4096, 1 }, + { 8192, 0 }, + +#endif +#ifdef SKIPTHIS + + + + { 32, 1 }, + { 128, 1 }, + { 512, 1 }, + { 2048, 1 }, + { 8192, 1 }, + { 32768, 1 }, + {131072, 0 }, + + { 24, 1 }, /* Experimental sizes */ { 32, 1 }, { 64, 1 }, { 128, 1 }, { 256, 1 }, + { 512, 1 }, { 1024, 1 }, { 2048, 0 }, #endif -/* old values from isamc, long time ago... - { 24, 40 }, - { 128, 256 }, - { 512, 1024 }, - { 2048, 4096 }, - { 8192,16384 }, - { 32768, 0 }, -*/ - -/* 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 */ - }; - ISAMD_M m = (ISAMD_M) xmalloc (sizeof(*m)); /*??? never released??? */ - m->filecat = def_cat; + ISAMD_M m = (ISAMD_M) xmalloc (sizeof(*m)); /* never released! */ + m->filecat = def_cat; /* ok, only alloc'd once */ m->code_start = NULL; m->code_item = NULL; @@ -66,7 +80,7 @@ ISAMD_M isamd_getmethod (ISAMD_M me) m->compare_item = NULL; - m->debug = 1; + m->debug = 0; /* default to no debug */ m->max_blocks_mem = 10; @@ -89,11 +103,11 @@ ISAMD isamd_open (BFiles bfs, const char *name, int writeflag, ISAMD_M method) assert (filecat); /* determine number of block categories */ - if (is->method->debug) + if (is->method->debug>0) logf (LOG_LOG, "isamd: bsize maxkeys"); do { - if (is->method->debug) + if (is->method->debug>0) logf (LOG_LOG, "isamd:%6d %6d", filecat[i].bsize, filecat[i].mblocks); } while (filecat[i++].mblocks); @@ -104,13 +118,6 @@ ISAMD isamd_open (BFiles bfs, const char *name, int writeflag, ISAMD_M method) assert (is->max_cat <=8 ); /* we have only 3 bits for it */ is->files = (ISAMD_file) xmalloc (sizeof(*is->files)*is->no_files); - if (writeflag) - { - /* TODO - what ever needs to be done here... */ - } - else - { - } for (i = 0; ino_files; i++) { @@ -143,14 +150,38 @@ ISAMD isamd_open (BFiles bfs, const char *name, int writeflag, ISAMD_M method) is->files[i].sum_backward = 0; is->files[i].no_next = 0; is->files[i].no_prev = 0; - + is->files[i].no_op_diffonly=0; + is->files[i].no_op_main=0; init_fc (is, i); } + is->last_pos=0; + is->last_cat=0; + is->no_read=0; + is->no_read_main=0; + is->no_write=0; + is->no_op_single=0; + is->no_op_new=0; + is->no_read_keys=0; + is->no_read_eof=0; + is->no_seek_nxt=0; + is->no_seek_sam=0; + is->no_seek_fwd=0; + is->no_seek_prv=0; + is->no_seek_bak=0; + is->no_seek_cat=0; + is->no_fbuilds=0; + is->no_appds=0; + is->no_merges=0; + is->no_non=0; + is->no_singles=0; + return is; } int isamd_block_used (ISAMD is, int type) { + if ( type==-1) /* singleton */ + return 0; if (type < 0 || type >= is->no_files) return -1; return is->files[type].head.lastblock-1; @@ -159,6 +190,8 @@ int isamd_block_used (ISAMD is, int type) int isamd_block_size (ISAMD is, int type) { ISAMD_filecat filecat = is->method->filecat; + if ( type==-1) /* singleton */ + return 0; /* no bytes used */ if (type < 0 || type >= is->no_files) return -1; return filecat[type].bsize; @@ -167,25 +200,27 @@ int isamd_block_size (ISAMD is, int type) int isamd_close (ISAMD is) { int i; + int s; - if (is->method->debug) + if (is->method->debug>0) { - logf (LOG_LOG, "isamd: next forw mid-f prev backw mid-b"); + logf (LOG_LOG, "isamd statistics"); + logf (LOG_LOG, "f nxt forw mid-f prev backw mid-b"); for (i = 0; ino_files; i++) - logf (LOG_LOG, "isamd:%8d%8d%8.1f%8d%8d%8.1f", + logf (LOG_LOG, "%d%7d%7d%7.1f%7d%7d%7.1f",i, is->files[i].no_next, is->files[i].no_forward, is->files[i].no_forward ? - (double) is->files[i].sum_forward/is->files[i].no_forward - : 0.0, + (double) is->files[i].sum_forward/is->files[i].no_forward + : 0.0, is->files[i].no_prev, is->files[i].no_backward, is->files[i].no_backward ? - (double) is->files[i].sum_backward/is->files[i].no_backward - : 0.0); + (double) is->files[i].sum_backward/is->files[i].no_backward + : 0.0); } - if (is->method->debug) - logf (LOG_LOG, "isamd: writes reads skipped alloc released remap"); + if (is->method->debug>0) + logf (LOG_LOG, "f writes reads skipped alloc released "); for (i = 0; ino_files; i++) { release_fc (is, i); @@ -193,35 +228,106 @@ int isamd_close (ISAMD is) if (is->files[i].head_is_dirty) bf_write (is->files[i].bf, 0, 0, sizeof(ISAMD_head), &is->files[i].head); - if (is->method->debug) - logf (LOG_LOG, "isamd:%8d%8d%8d%8d%8d%8d", + if (is->method->debug>0) + logf (LOG_LOG, "%d%8d%8d%8d%8d%8d",i, is->files[i].no_writes, is->files[i].no_reads, is->files[i].no_skip_writes, is->files[i].no_allocated, - is->files[i].no_released, - is->files[i].no_remap); + is->files[i].no_released); xfree (is->files[i].fc_list); flush_block (is, i); bf_close (is->files[i].bf); } + + if (is->method->debug>0) + { + logf (LOG_LOG, "f opens main diffonly"); + for (i = 0; ino_files; i++) + { + logf (LOG_LOG, "%d%8d%8d%8d",i, + is->files[i].no_op_main+ + is->files[i].no_op_diffonly, + is->files[i].no_op_main, + is->files[i].no_op_diffonly); + } + logf(LOG_LOG,"open single %8d", is->no_op_single); + logf(LOG_LOG,"open new %8d", is->no_op_new); + + logf(LOG_LOG, "new build %8d", is->no_fbuilds); + logf(LOG_LOG, "append %8d", is->no_appds); + logf(LOG_LOG, " merges %8d", is->no_merges); + logf(LOG_LOG, " singles %8d", is->no_singles); + logf(LOG_LOG, " no-ops %8d", is->no_non); + + logf(LOG_LOG, "read blocks %8d", is->no_read); + logf(LOG_LOG, "read keys: %8d %8.1f k/bl", + is->no_read_keys, + 1.0*(is->no_read_keys+1)/(is->no_read+1) ); + logf(LOG_LOG, "read main-k %8d %8.1f %% of keys", + is->no_read_main, + 100.0*(is->no_read_main+1)/(is->no_read_keys+1) ); + logf(LOG_LOG, "read ends: %8d %8.1f k/e", + is->no_read_eof, + 1.0*(is->no_read_keys+1)/(is->no_read_eof+1) ); + s= is->no_seek_nxt+ is->no_seek_sam+ is->no_seek_fwd + + is->no_seek_prv+ is->no_seek_bak+ is->no_seek_cat; + if (s==0) + s++; + logf(LOG_LOG, "seek same %8d %8.1f%%", + is->no_seek_sam, 100.0*is->no_seek_sam/s ); + logf(LOG_LOG, "seek next %8d %8.1f%%", + is->no_seek_nxt, 100.0*is->no_seek_nxt/s ); + logf(LOG_LOG, "seek prev %8d %8.1f%%", + is->no_seek_prv, 100.0*is->no_seek_prv/s ); + logf(LOG_LOG, "seek forw %8d %8.1f%%", + is->no_seek_fwd, 100.0*is->no_seek_fwd/s ); + logf(LOG_LOG, "seek back %8d %8.1f%%", + is->no_seek_bak, 100.0*is->no_seek_bak/s ); + logf(LOG_LOG, "seek cat %8d %8.1f%%", + is->no_seek_cat, 100.0*is->no_seek_cat/s ); + } xfree (is->files); xfree (is->method); xfree (is); return 0; } +static void isamd_seek_stat(ISAMD is, int cat, int pos) +{ + if (cat != is->last_cat) + is->no_seek_cat++; + else if ( pos == is->last_pos) + is->no_seek_sam++; + else if ( pos == is->last_pos+1) + is->no_seek_nxt++; + else if ( pos == is->last_pos-1) + is->no_seek_prv++; + else if ( pos > is->last_pos) + is->no_seek_fwd++; + else if ( pos < is->last_pos) + is->no_seek_bak++; + is->last_cat = cat; + is->last_pos = pos; +} /* seek_stat */ + int isamd_read_block (ISAMD is, int cat, int pos, char *dst) { + isamd_seek_stat(is,cat,pos); ++(is->files[cat].no_reads); + ++(is->no_read); + if (is->method->debug > 6) + logf (LOG_LOG, "isamd: read_block %d:%d",cat, pos); return bf_read (is->files[cat].bf, pos, 0, 0, dst); } int isamd_write_block (ISAMD is, int cat, int pos, char *src) { + isamd_seek_stat(is,cat,pos); ++(is->files[cat].no_writes); - if (is->method->debug > 2) - logf (LOG_LOG, "isamd: write_block %d %d", cat, pos); + ++(is->no_write); + if (is->method->debug > 6) + logf (LOG_LOG, "isamd: write_block %d:%d", cat, pos); return bf_write (is->files[cat].bf, pos, 0, 0, src); } @@ -229,7 +335,7 @@ int isamd_write_dblock (ISAMD is, int cat, int pos, char *src, int nextpos, int offset) { ISAMD_BLOCK_SIZE size = offset + ISAMD_BLOCK_OFFSET_N; - if (is->method->debug > 2) + if (is->method->debug > 4) logf (LOG_LOG, "isamd: write_dblock. size=%d nextpos=%d", (int) size, nextpos); src -= ISAMD_BLOCK_OFFSET_N; @@ -388,14 +494,14 @@ int isamd_alloc_block (ISAMD is, int cat) } if (!block) block = alloc_block (is, cat); - if (is->method->debug > 3) + if (is->method->debug > 4) logf (LOG_LOG, "isamd: alloc_block in cat %d: %d", cat, block); return block; } void isamd_release_block (ISAMD is, int cat, int pos) { - if (is->method->debug > 3) + if (is->method->debug > 4) logf (LOG_LOG, "isamd: release_block in cat %d: %d", cat, pos); assert(pos!=0); @@ -443,7 +549,7 @@ void isamd_pp_close (ISAMD_PP pp) isamd_free_diffs(pp); /* see merge-d.h */ xfree (pp->buf); xfree (pp); - if (is->method->debug > 2) + if (is->method->debug > 5) logf (LOG_LOG, "isamd_pp_close %p %d=%d:%d sz=%d n=%d=%d:%d", pp, isamd_addr(pp->pos, pp->cat), pp->cat, pp->pos, pp->size, pp->next, isamd_type(pp->next), isamd_block(pp->next) ); @@ -455,23 +561,63 @@ ISAMD_PP isamd_pp_open (ISAMD is, ISAMD_P ipos) { ISAMD_PP pp = (ISAMD_PP) xmalloc (sizeof(*pp)); char *src; - - pp->cat = isamd_type(ipos); - pp->pos = isamd_block(ipos); - - src = pp->buf = (char *) xmalloc (is->method->filecat[is->max_cat].bsize); + int sz = is->method->filecat[is->max_cat].bsize; /* always allocate for the largest blocks, saves trouble */ + struct it_key singlekey; + char *c_ptr; /* for fake encoding the singlekey */ + char *i_ptr; + int ofs; + + pp->numKeys = 0; + src = pp->buf = (char *) xmalloc (sz); + memset(src,'\0',sz); /* clear the buffer, for new blocks */ + pp->next = 0; pp->size = 0; pp->offset = 0; pp->is = is; - pp->decodeClientData = (*is->method->code_start)(ISAMD_DECODE); - pp->numKeys = 0; pp->diffs=0; - pp->diffbuf=0; pp->diffinfo=0; + pp->decodeClientData = (*is->method->code_start)(ISAMD_DECODE); + + if ( is_singleton(ipos) ) + { + pp->cat=0; + pp->pos=0; + if (is->method->debug > 5) + logf (LOG_LOG, "isamd_pp_open %p %d=%d:%d sz=%d n=%d=%d:%d", + pp, isamd_addr(pp->pos, pp->cat), pp->cat, pp->pos, pp->size, + pp->next, isamd_type(pp->next), isamd_block(pp->next) ); + singleton_decode(ipos, &singlekey ); + pp->offset=ISAMD_BLOCK_OFFSET_1; + pp->numKeys = 1; + ofs=pp->offset+sizeof(int); /* reserve length of diffsegment */ + singlekey.seqno = singlekey.seqno * 2 + 1; /* make an insert diff */ + c_ptr=&(pp->buf[ofs]); + i_ptr=(char*)(&singlekey); + (*is->method->code_item)(ISAMD_ENCODE, pp->decodeClientData, + &c_ptr, &i_ptr); + (*is->method->code_reset)(pp->decodeClientData); + ofs += c_ptr-&(pp->buf[ofs]); + memcpy( &(pp->buf[pp->offset]), &ofs, sizeof(int) ); + /* since we memset buf earlier, we already have a zero endmark! */ + pp->size = ofs; + if (is->method->debug > 5) + logf (LOG_LOG, "isamd_pp_open single %d=%x: %d.%d sz=%d", + ipos,ipos, + singlekey.sysno, singlekey.seqno/2, + pp->size ); + is->no_op_single++; + return pp; + } /* singleton */ + + pp->cat = isamd_type(ipos); + pp->pos = isamd_block(ipos); + if (0==pp->pos) + is->no_op_new++; + if (pp->pos) { src = pp->buf; @@ -482,22 +628,20 @@ ISAMD_PP isamd_pp_open (ISAMD is, ISAMD_P ipos) src += sizeof(pp->size); memcpy (&pp->numKeys, src, sizeof(pp->numKeys)); src += sizeof(pp->numKeys); - memcpy (&pp->diffs, src, sizeof(pp->diffs)); - src += sizeof(pp->diffs); - assert (pp->next != pp->pos); + assert (pp->next != isamd_addr(pp->pos,pp->cat)); pp->offset = src - pp->buf; assert (pp->offset == ISAMD_BLOCK_OFFSET_1); -// if (is->method->debug > 2) -// logf (LOG_LOG, "isamd_pp_open %p %d=%d:%d sz=%d n=%d=%d:%d", -// pp, isamd_addr(pp->pos, pp->cat), pp->cat, pp->pos, pp->size, -// pp->next, isamd_type(pp->next), isamd_block(pp->next) ); + assert(pp->size>=ISAMD_BLOCK_OFFSET_1); /*??*/ + if (pp->next) + is->files[pp->cat].no_op_main++; + else + is->files[pp->cat].no_op_diffonly++; } - if (is->method->debug > 2) + if (is->method->debug > 5) logf (LOG_LOG, "isamd_pp_open %p %d=%d:%d sz=%d n=%d=%d:%d", pp, isamd_addr(pp->pos, pp->cat), pp->cat, pp->pos, pp->size, pp->next, isamd_type(pp->next), isamd_block(pp->next) ); - - + return pp; } @@ -506,22 +650,19 @@ ISAMD_PP isamd_pp_open (ISAMD is, ISAMD_P ipos) void isamd_buildfirstblock(ISAMD_PP pp){ char *dst=pp->buf; assert(pp->buf); - assert(pp->next != pp->pos); + assert(pp->next != isamd_addr(pp->pos,pp->cat)); memcpy(dst, &pp->next, sizeof(pp->next) ); dst += sizeof(pp->next); memcpy(dst, &pp->size,sizeof(pp->size)); dst += sizeof(pp->size); memcpy(dst, &pp->numKeys, sizeof(pp->numKeys)); dst += sizeof(pp->numKeys); - 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 nk=%d d=%d", - pp->size, - pp->cat, pp->pos, - isamd_type(pp->next), isamd_block(pp->next), - pp->numKeys, pp->diffs); + if (pp->is->method->debug > 5) + logf (LOG_LOG, "isamd: bldfirst: p=%d=%d:%d n=%d:%d:%d sz=%d nk=%d ", + isamd_addr(pp->pos,pp->cat),pp->cat, pp->pos, + pp->next, isamd_type(pp->next), isamd_block(pp->next), + pp->size, pp->numKeys); } void isamd_buildlaterblock(ISAMD_PP pp){ @@ -533,7 +674,7 @@ void isamd_buildlaterblock(ISAMD_PP pp){ memcpy(dst, &pp->size,sizeof(pp->size)); dst += sizeof(pp->size); assert (dst - pp->buf == ISAMD_BLOCK_OFFSET_N); - if (pp->is->method->debug > 2) + if (pp->is->method->debug > 5) logf (LOG_LOG, "isamd: l8r: sz=%d p=%d/%d>%d/%d", pp->size, pp->pos, pp->cat, @@ -545,9 +686,10 @@ void isamd_buildlaterblock(ISAMD_PP pp){ /* returns non-zero if item could be read; 0 otherwise */ int isamd_pp_read (ISAMD_PP pp, void *buf) { + return isamd_read_item (pp, (char **) &buf); - /* note: isamd_read_item is in merge-d.c, because it is so */ - /* convoluted with the merge process */ + /* note: isamd_read_item is in merge-d.c, because it is so */ + /* convoluted with the merge process */ } /* read one main item from file - decode and store it in *dst. @@ -561,6 +703,7 @@ int isamd_read_main_item (ISAMD_PP pp, char **dst) ISAMD is = pp->is; char *src = pp->buf + pp->offset; int newcat; + int oldoffs; if (pp->offset >= pp->size) { @@ -593,7 +736,7 @@ int isamd_read_main_item (ISAMD_PP pp, char **dst) newcat = isamd_type(pp->next); pp->pos = isamd_block(pp->next); pp->cat = isamd_type(pp->next); - + pp->is->no_read_main++; src = pp->buf; /* read block and save 'next' and 'size' entry */ isamd_read_block (is, pp->cat, pp->pos, src); @@ -602,20 +745,24 @@ int isamd_read_main_item (ISAMD_PP pp, char **dst) memcpy (&pp->size, src, sizeof(pp->size)); src += sizeof(pp->size); /* assume block is non-empty */ - assert (src - pp->buf == ISAMD_BLOCK_OFFSET_N); + pp->offset = oldoffs = src - pp->buf; + assert (pp->offset == ISAMD_BLOCK_OFFSET_N); assert (pp->next != isamd_addr(pp->pos,pp->cat)); - //if (pp->deleteFlag) - // isamd_release_block (is, pp->cat, pp->pos); (*is->method->code_reset)(pp->decodeClientData); + /* finally, read the item */ (*is->method->code_item)(ISAMD_DECODE, pp->decodeClientData, dst, &src); pp->offset = src - pp->buf; - if (is->method->debug > 2) - logf (LOG_LOG, "isamd: read_block size=%d %d %d next=%d", - pp->size, pp->cat, pp->pos, pp->next); + if (is->method->debug > 8) + logf (LOG_LOG, "isamd: read_m: block %d:%d sz=%d ofs=%d-%d next=%d", + pp->cat, pp->pos, pp->size, oldoffs, pp->offset, pp->next); return 2; } + oldoffs=pp->offset; (*is->method->code_item)(ISAMD_DECODE, pp->decodeClientData, dst, &src); pp->offset = src - pp->buf; + if (is->method->debug > 8) + logf (LOG_LOG, "isamd: read_m: got %d:%d sz=%d ofs=%d-%d next=%d", + pp->cat, pp->pos, pp->size, oldoffs, pp->offset, pp->next); return 1; } @@ -647,23 +794,35 @@ void isamd_pp_dump (ISAMD is, ISAMD_P ipos) int i,n; int occur =0; int oldoffs; + int diffmax=1; + int diffidx; char hexbuff[64]; + int olddebug= is->method->debug; + is->method->debug=0; /* no debug logs while reading for dump */ 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, ofs=%d d=%d", - pp->numKeys, - pp->offset, pp->diffs); - oldoffs= pp->offset; + logf(LOG_LOG,"numKeys=%d, ofs=%d sz=%d", + pp->numKeys, pp->offset, pp->size ); + diffidx=oldoffs= pp->offset; + while ((diffidx < is->method->filecat[pp->cat].bsize) && (diffmax>0)) + { + memcpy(&diffmax,&(pp->buf[diffidx]),sizeof(int)); + logf (LOG_LOG,"diff set at %d-%d: %s", diffidx, diffmax, + hexdump(pp->buf+diffidx,8,0)); + /*! todo: dump the actual diffs as well !!! */ + diffidx=diffmax; + + } /* dump diffs */ while(isamd_pp_read(pp, &key)) { if (oldaddr != isamd_addr(pp->pos,pp->cat) ) { oldaddr = isamd_addr(pp->pos,pp->cat); - logf(LOG_LOG,"block %d (%d:%d) sz=%d nx=%d (%d:%d) ofs=%d", - isamd_addr(pp->pos,pp->cat), - pp->cat, pp->pos, pp->size, + logf(LOG_LOG,"block %d=%d:%d sz=%d nx=%d=%d:%d ofs=%d", + isamd_addr(pp->pos,pp->cat), pp->cat, pp->pos, + pp->size, pp->next, isamd_type(pp->next), isamd_block(pp->next), pp->offset); i=0; @@ -686,11 +845,49 @@ void isamd_pp_dump (ISAMD is, ISAMD_P ipos) } /*!*/ /*TODO: dump diffs too!!! */ isamd_pp_close(pp); + is->method->debug=olddebug; } /* dump */ /* * $Log: isamd.c,v $ - * Revision 1.6 1999-08-17 19:44:25 heikki + * Revision 1.19 1999-11-30 13:48:04 adam + * Improved installation. Updated for inclusion of YAZ header files. + * + * Revision 1.18 1999/10/06 15:18:13 heikki + * + * Improving block sizes again + * + * Revision 1.17 1999/10/06 11:46:36 heikki + * mproved statistics on isam-d + * + * Revision 1.16 1999/10/05 09:57:40 heikki + * Tuning the isam-d (and fixed a small "detail") + * + * Revision 1.15 1999/09/27 14:36:36 heikki + * singletons + * + * Revision 1.14 1999/09/23 18:01:18 heikki + * singleton optimising + * + * Revision 1.13 1999/09/20 15:48:06 heikki + * Small changes + * + * Revision 1.12 1999/09/13 13:28:28 heikki + * isam-d optimizing: merging input data in the same go + * + * Revision 1.11 1999/08/25 18:09:24 heikki + * Starting to optimize + * + * Revision 1.10 1999/08/24 13:17:42 heikki + * Block sizes, comments + * + * Revision 1.9 1999/08/20 12:25:58 heikki + * Statistics in isamd + * + * Revision 1.8 1999/08/18 13:28:16 heikki + * Set log levels to decent values + * + * Revision 1.6 1999/08/17 19:44:25 heikki * Fixed memory leaks * * Revision 1.4 1999/08/04 14:21:18 heikki @@ -704,4 +901,4 @@ void isamd_pp_dump (ISAMD is, ISAMD_P ipos) * Copied from isamh, starting to change things... * * - */ \ No newline at end of file + */