X-Git-Url: http://git.indexdata.com/?a=blobdiff_plain;f=isamc%2Fisamc.c;h=3e89b327172d59d5f9be9bb1f36de1678dce180f;hb=cd0427111b705e414406e1e262f3772e40c7f662;hp=656cae0f46eb8214ae5ac900065959bcd007a1d3;hpb=16153aaaa1fcb0881ff7e3056bd9c991fcf57c29;p=idzebra-moved-to-github.git diff --git a/isamc/isamc.c b/isamc/isamc.c index 656cae0..3e89b32 100644 --- a/isamc/isamc.c +++ b/isamc/isamc.c @@ -1,10 +1,37 @@ /* - * Copyright (c) 1995-1996, Index Data. + * Copyright (c) 1995-1998, Index Data. * See the file LICENSE for details. * Sebastian Hammer, Adam Dickmeiss * * $Log: isamc.c,v $ - * Revision 1.5 1996-11-04 14:08:57 adam + * Revision 1.12 1998-03-16 10:37:24 adam + * Added more statistics. + * + * Revision 1.11 1998/03/13 15:30:50 adam + * New functions isc_block_used and isc_block_size. Fixed 'leak' + * in isc_alloc_block. + * + * Revision 1.10 1998/03/11 11:18:18 adam + * Changed the isc_merge to take into account the mfill (minimum-fill). + * + * Revision 1.9 1998/03/06 13:54:02 adam + * Fixed two nasty bugs in isc_merge. + * + * Revision 1.8 1997/09/17 12:19:20 adam + * Zebra version corresponds to YAZ version 1.4. + * Changed Zebra server so that it doesn't depend on global common_resource. + * + * Revision 1.7 1997/02/12 20:42:43 adam + * Bug fix: during isc_merge operations, some pages weren't marked dirty + * even though they should be. At this point the merge operation marks + * a page dirty if the previous page changed at all. A better approach is + * to mark it dirty if the last key written changed in previous page. + * + * Revision 1.6 1996/11/08 11:15:29 adam + * Number of keys in chain are stored in first block and the function + * to retrieve this information, isc_pp_num is implemented. + * + * Revision 1.5 1996/11/04 14:08:57 adam * Optimized free block usage. * * Revision 1.4 1996/11/01 13:36:46 adam @@ -27,7 +54,6 @@ /* * TODO: * Reduction to lower categories in isc_merge - * Implementation of isc_numkeys */ #include #include @@ -40,14 +66,20 @@ static void release_fc (ISAMC is, int cat); static void init_fc (ISAMC is, int cat); +#define SMALL_TEST 0 + ISAMC_M isc_getmethod (void) { static struct ISAMC_filecat_s def_cat[] = { - { 32, 28, 0, 20 }, - { 512, 490, 100, 20 }, - { 4096, 3950, 1000, 20 }, - {32768, 32000, 10000, 0 }, - { 0, 0, 0, 0 } +#if SMALL_TEST + { 32, 28, 0, 3 }, + { 64, 54, 30, 0 }, +#else + { 32, 28, 24, 20 }, + { 512, 490, 350, 20 }, + { 4096, 3950, 4200, 20 }, + {32768, 32000, 30000, 0 }, +#endif }; ISAMC_M m = xmalloc (sizeof(*m)); m->filecat = def_cat; @@ -58,7 +90,7 @@ ISAMC_M isc_getmethod (void) m->compare_item = NULL; - m->debug = 0; + m->debug = 1; m->max_blocks_mem = 10; @@ -66,11 +98,11 @@ ISAMC_M isc_getmethod (void) } -ISAMC isc_open (const char *name, int writeflag, ISAMC_M method) +ISAMC isc_open (BFiles bfs, const char *name, int writeflag, ISAMC_M method) { ISAMC is; ISAMC_filecat filecat; - int i, j; + int i = 0; int max_buf_size = 0; is = xmalloc (sizeof(*is)); @@ -83,7 +115,7 @@ ISAMC isc_open (const char *name, int writeflag, ISAMC_M method) /* determine number of block categories */ if (is->method->debug) logf (LOG_LOG, "isc: bsize ifill mfill mblocks"); - for (i = 0; filecat[i].bsize; i++) + do { if (is->method->debug) logf (LOG_LOG, "isc:%6d %6d %6d %6d", @@ -91,7 +123,7 @@ ISAMC isc_open (const char *name, int writeflag, ISAMC_M method) filecat[i].mfill, filecat[i].mblocks); if (max_buf_size < filecat[i].mblocks * filecat[i].bsize) max_buf_size = filecat[i].mblocks * filecat[i].bsize; - } + } while (filecat[i++].mblocks); is->no_files = i; is->max_cat = --i; /* max_buf_size is the larget buffer to be used during merge */ @@ -105,8 +137,8 @@ ISAMC isc_open (const char *name, int writeflag, ISAMC_M method) is->files = xmalloc (sizeof(*is->files)*is->no_files); if (writeflag) { - is->merge_buf = xmalloc (max_buf_size+128); - memset (is->merge_buf, 0, max_buf_size+128); + is->merge_buf = xmalloc (max_buf_size+256); + memset (is->merge_buf, 0, max_buf_size+256); } else is->merge_buf = NULL; @@ -115,7 +147,7 @@ ISAMC isc_open (const char *name, int writeflag, ISAMC_M method) char fname[512]; sprintf (fname, "%s%c", name, i+'A'); - is->files[i].bf = bf_open (fname, is->method->filecat[i].bsize, + 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(ISAMC_head), @@ -130,17 +162,54 @@ ISAMC isc_open (const char *name, int writeflag, ISAMC_M method) is->files[i].no_allocated = 0; is->files[i].no_released = 0; is->files[i].no_remap = 0; + is->files[i].no_forward = 0; + is->files[i].no_backward = 0; + is->files[i].sum_forward = 0; + is->files[i].sum_backward = 0; + is->files[i].no_next = 0; + is->files[i].no_prev = 0; init_fc (is, i); } return is; } +int isc_block_used (ISAMC is, int type) +{ + if (type < 0 || type >= is->no_files) + return -1; + return is->files[type].head.lastblock-1; +} + +int isc_block_size (ISAMC is, int type) +{ + ISAMC_filecat filecat = is->method->filecat; + if (type < 0 || type >= is->no_files) + return -1; + return filecat[type].bsize; +} + int isc_close (ISAMC is) { int i; if (is->method->debug) + { + logf (LOG_LOG, "isc: next forw mid-f prev backw mid-b"); + for (i = 0; ino_files; i++) + logf (LOG_LOG, "isc:%8d%8d%8.1f%8d%8d%8.1f", + 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, + 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); + } + if (is->method->debug) logf (LOG_LOG, "isc: writes reads skipped alloc released remap"); for (i = 0; ino_files; i++) { @@ -169,8 +238,6 @@ int isc_close (ISAMC is) int isc_read_block (ISAMC is, int cat, int pos, char *dst) { ++(is->files[cat].no_reads); - if (is->method->debug > 2) - logf (LOG_LOG, "isc: read_block %d %d", cat, pos); return bf_read (is->files[cat].bf, pos, 0, 0, dst); } @@ -185,13 +252,14 @@ int isc_write_block (ISAMC is, int cat, int pos, char *src) int isc_write_dblock (ISAMC is, int cat, int pos, char *src, int nextpos, int offset) { - int xoffset = offset + 2*sizeof(int); + unsigned short size = offset + ISAMC_BLOCK_OFFSET_N; if (is->method->debug > 2) logf (LOG_LOG, "isc: write_dblock. size=%d nextpos=%d", - offset, nextpos); - memcpy (src - sizeof(int)*2, &nextpos, sizeof(int)); - memcpy (src - sizeof(int), &xoffset, sizeof(int)); - return isc_write_block (is, cat, pos, src - sizeof(int)*2); + (int) size, nextpos); + src -= ISAMC_BLOCK_OFFSET_N; + memcpy (src, &nextpos, sizeof(int)); + memcpy (src + sizeof(int), &size, sizeof(size)); + return isc_write_block (is, cat, pos, src); } static int alloc_block (ISAMC is, int cat) @@ -222,6 +290,7 @@ int isc_alloc_block (ISAMC is, int cat) if ((nb = is->files[cat].fc_list[j]) && (!block || nb < block)) { is->files[cat].fc_list[j] = 0; + block = nb; break; } } @@ -249,7 +318,7 @@ void isc_release_block (ISAMC is, int cat, int pos) logf (LOG_LOG, "isc: release_block in cat %d: %d", cat, pos); if (is->files[cat].fc_list) { - int b, j; + int j; for (j = 0; jfiles[cat].fc_max; j++) if (!is->files[cat].fc_list[j]) { @@ -297,26 +366,49 @@ ISAMC_PP isc_pp_open (ISAMC is, ISAMC_P ipos) char *src; pp->cat = isc_type(ipos); - pp->next = isc_block(ipos); + pp->pos = isc_block(ipos); src = pp->buf = xmalloc (is->method->filecat[pp->cat].bsize); - pp->pos = 0; + pp->next = 0; pp->size = 0; pp->offset = 0; pp->is = is; pp->decodeClientData = (*is->method->code_start)(ISAMC_DECODE); pp->deleteFlag = 0; + pp->numKeys = 0; + + if (pp->pos) + { + src = pp->buf; + isc_read_block (is, pp->cat, pp->pos, src); + memcpy (&pp->next, src, sizeof(pp->next)); + src += sizeof(pp->next); + memcpy (&pp->size, src, sizeof(pp->size)); + src += sizeof(pp->size); + memcpy (&pp->numKeys, src, sizeof(pp->numKeys)); + src += sizeof(pp->numKeys); + assert (pp->next != pp->pos); + pp->offset = src - pp->buf; + assert (pp->offset == ISAMC_BLOCK_OFFSET_1); + if (is->method->debug > 2) + logf (LOG_LOG, "isc: read_block size=%d %d %d next=%d", + pp->size, pp->cat, pp->pos, pp->next); + } return pp; } /* returns non-zero if item could be read; 0 otherwise */ -int isc_read_key (ISAMC_PP pp, void *buf) +int isc_pp_read (ISAMC_PP pp, void *buf) { return isc_read_item (pp, (char **) &buf); } -/* returns non-zero if item could be read; 0 otherwise */ +/* read one item from file - decode and store it in *dst. + Returns + 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 isc_read_item (ISAMC_PP pp, char **dst) { ISAMC is = pp->is; @@ -324,21 +416,50 @@ int isc_read_item (ISAMC_PP pp, char **dst) if (pp->offset >= pp->size) { + if (!pp->next) + { + pp->pos = 0; + return 0; /* end of file */ + } + if (pp->next > pp->pos) + { + if (pp->next == pp->pos + 1) + is->files[pp->cat].no_next++; + else + { + is->files[pp->cat].no_forward++; + is->files[pp->cat].sum_forward += pp->next - pp->pos; + } + } + else + { + if (pp->next + 1 == pp->pos) + is->files[pp->cat].no_prev++; + else + { + is->files[pp->cat].no_backward++; + is->files[pp->cat].sum_backward += pp->pos - pp->next; + } + } + /* out new block position */ pp->pos = pp->next; - if (!pp->pos) - return 0; src = pp->buf; + /* read block and save 'next' and 'size' entry */ isc_read_block (is, pp->cat, pp->pos, src); memcpy (&pp->next, src, sizeof(pp->next)); src += sizeof(pp->next); memcpy (&pp->size, src, sizeof(pp->size)); src += sizeof(pp->size); /* assume block is non-empty */ + assert (src - pp->buf == ISAMC_BLOCK_OFFSET_N); assert (pp->next != pp->pos); if (pp->deleteFlag) isc_release_block (is, pp->cat, pp->pos); (*is->method->code_item)(ISAMC_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", + pp->size, pp->cat, pp->pos, pp->next); return 2; } (*is->method->code_item)(ISAMC_DECODE, pp->decodeClientData, dst, &src); @@ -346,8 +467,8 @@ int isc_read_item (ISAMC_PP pp, char **dst) return 1; } -int isc_numkeys (ISAMC_PP pp) +int isc_pp_num (ISAMC_PP pp) { - return 1; + return pp->numKeys; }