X-Git-Url: http://jsfdemo.indexdata.com/?a=blobdiff_plain;f=isamc%2Fisamc.c;h=9cd4471f04d577947a95491f2072e5c0154a246e;hb=154c6dacd76fe573d1d6ee3bc7284a05f0445bc6;hp=656cae0f46eb8214ae5ac900065959bcd007a1d3;hpb=16153aaaa1fcb0881ff7e3056bd9c991fcf57c29;p=idzebra-moved-to-github.git diff --git a/isamc/isamc.c b/isamc/isamc.c index 656cae0..9cd4471 100644 --- a/isamc/isamc.c +++ b/isamc/isamc.c @@ -1,10 +1,30 @@ /* - * 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.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 +47,6 @@ /* * TODO: * Reduction to lower categories in isc_merge - * Implementation of isc_numkeys */ #include #include @@ -40,14 +59,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, 20, 20 }, + { 512, 490, 340, 20 }, + { 4096, 3950, 3200, 20 }, + {32768, 32000, 30000, 0 }, +#endif }; ISAMC_M m = xmalloc (sizeof(*m)); m->filecat = def_cat; @@ -58,7 +83,7 @@ ISAMC_M isc_getmethod (void) m->compare_item = NULL; - m->debug = 0; + m->debug = 1; m->max_blocks_mem = 10; @@ -66,11 +91,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 +108,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 +116,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 +130,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 +140,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), @@ -169,8 +194,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 +208,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) @@ -249,7 +273,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 +321,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 +371,27 @@ int isc_read_item (ISAMC_PP pp, char **dst) if (pp->offset >= pp->size) { + /* out new block position */ pp->pos = pp->next; if (!pp->pos) - return 0; + return 0; /* end of file */ 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 +399,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; }