bfile/commit.c

   1 /* $Id: commit.c,v 1.30 2006-11-14 08:12:06 adam Exp $
   2    Copyright (C) 1995-2006
   3    Index Data ApS
   4
   5 This file is part of the Zebra server.
   6
   7 Zebra is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 Zebra is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  20
  21 */
  22
  23
  24 #include <assert.h>
  25 #include <stdlib.h>
  26
  27 #include <idzebra/util.h>
  28 #include <yaz/xmalloc.h>
  29 #include "mfile.h"
  30 #include "cfile.h"
  31
  32 #define CF_OPTIMIZE_COMMIT 0
  33
  34 #if CF_OPTIMIZE_COMMIT
  35 struct map_cache_entity {
  36     int from;
  37     int to;
  38 };
  39
  40 struct map_cache {
  41     int max;
  42     int no;
  43
  44     struct map_cache_entity *map;
  45     char *buf;
  46     CFile cf;
  47 };
  48
  49 static struct map_cache *map_cache_init (CFile cf)
  50 {
  51     int mem_max = 2000000;
  52     struct map_cache *m_p;
  53
  54     m_p = xmalloc (sizeof(*m_p));
  55     m_p->cf = cf;
  56     m_p->max = mem_max / cf->head.block_size;
  57     m_p->buf = xmalloc (mem_max);
  58     m_p->no = 0;
  59     m_p->map = xmalloc (sizeof(*m_p->map) * m_p->max);
  60     return m_p;
  61 }
  62
  63 static int map_cache_cmp_from (const void *p1, const void *p2)
  64 {
  65     return ((struct map_cache_entity*) p1)->from -
  66         ((struct map_cache_entity*) p2)->from;
  67 }
  68
  69 static int map_cache_cmp_to (const void *p1, const void *p2)
  70 {
  71     return ((struct map_cache_entity*) p1)->to -
  72         ((struct map_cache_entity*) p2)->to;
  73 }
  74
  75 static int map_cache_flush (struct map_cache *m_p)
  76 {
  77     int i;
  78
  79     qsort (m_p->map, m_p->no, sizeof(*m_p->map), map_cache_cmp_from);
  80     assert (m_p->no < 2 || m_p->map[0].from < m_p->map[1].from);
  81     for (i = 0; i<m_p->no; i++)
  82     {
  83         if (!mf_read (m_p->cf->block_mf, m_p->map[i].from, 0, 0,
  84                       m_p->buf + i * m_p->cf->head.block_size))
  85         {
  86             yaz_log (YLOG_FATAL, "read commit block at position %d",
  87                   m_p->map[i].from);
  88             return -1;
  89         }
  90         m_p->map[i].from = i;
  91     }
  92     qsort (m_p->map, m_p->no, sizeof(*m_p->map), map_cache_cmp_to);
  93     assert (m_p->no < 2 || m_p->map[0].to < m_p->map[1].to);
  94     for (i = 0; i<m_p->no; i++)
  95     {
  96         mf_write (m_p->cf->rmf, m_p->map[i].to, 0, 0,
  97                   m_p->buf + m_p->map[i].from * m_p->cf->head.block_size);
  98     }
  99     m_p->no = 0;
 100     return 0;
 101 }
 102
 103 static int map_cache_del(struct map_cache *m_p)
 104 {
 105     int r = map_cache_flush (m_p);
 106     xfree (m_p->map);
 107     xfree (m_p->buf);
 108     xfree (m_p);
 109     return r;
 110 }
 111
 112 static int map_cache_add(struct map_cache *m_p, int from, int to)
 113 {
 114     int i = m_p->no;
 115
 116     m_p->map[i].from = from;
 117     m_p->map[i].to = to;
 118     m_p->no = ++i;
 119     if (i == m_p->max)
 120         return map_cache_flush (m_p);
 121     return 0;
 122 }
 123
 124 /* CF_OPTIMIZE_COMMIT */
 125 #endif
 126
 127 static int cf_commit_hash (CFile cf)
 128 {
 129     int r = 0;
 130     int i;
 131     zint bucket_no;
 132     int hash_bytes;
 133     struct CFile_ph_bucket *p;
 134 #if CF_OPTIMIZE_COMMIT
 135     struct map_cache *m_p;
 136 #endif
 137
 138 #if CF_OPTIMIZE_COMMIT
 139     m_p = map_cache_init (cf);
 140 #endif
 141
 142     p = (struct CFile_ph_bucket *) xmalloc (sizeof(*p));
 143     hash_bytes = cf->head.hash_size * sizeof(zint);
 144     bucket_no = cf->head.first_bucket;
 145     for (; bucket_no < cf->head.next_bucket; bucket_no++)
 146     {
 147         if (mf_read (cf->hash_mf, bucket_no, 0, 0, p) != 1)
 148         {
 149             yaz_log (YLOG_FATAL, "read commit hash");
 150             r = -1;
 151             goto out;
 152         }
 153         for (i = 0; i<HASH_BUCKET && p->vno[i]; i++)
 154         {
 155 #if CF_OPTIMIZE_COMMIT
 156             if (map_cache_add(m_p, p->vno[i], p->no[i]))
 157             {
 158                 r = -1;
 159                 goto out;
 160             }
 161 #else
 162             if (mf_read (cf->block_mf, p->vno[i], 0, 0, cf->iobuf) != 1)
 163             {
 164                 yaz_log (YLOG_FATAL, "read commit block");
 165                 r = -1;
 166                 goto out;
 167             }
 168             if (mf_write (cf->rmf, p->no[i], 0, 0, cf->iobuf))
 169             {
 170                 yaz_log (YLOG_FATAL, "write commit block");
 171                 r = -1;
 172                 goto out;
 173             }
 174 #endif
 175         }
 176     }
 177  out:
 178 #if CF_OPTIMIZE_COMMIT
 179     if (map_cache_del(m_p))
 180         r = -1;
 181 #endif
 182     xfree(p);
 183     return r;
 184 }
 185
 186 static int cf_commit_flat(CFile cf)
 187 {
 188     zint *fp;
 189     zint hno;
 190     int i;
 191     int r = 0;
 192     zint vno = 0;
 193
 194 #if CF_OPTIMIZE_COMMIT
 195     struct map_cache *m_p;
 196 #endif
 197
 198
 199 #if CF_OPTIMIZE_COMMIT
 200     m_p = map_cache_init (cf);
 201 #endif
 202     fp = (zint *) xmalloc (HASH_BSIZE);
 203     for (hno = cf->head.next_bucket; hno < cf->head.flat_bucket; hno++)
 204     {
 205         for (i = 0; i < (int) (HASH_BSIZE/sizeof(zint)); i++)
 206             fp[i] = 0;
 207         if (!mf_read (cf->hash_mf, hno, 0, 0, fp) &&
 208             hno != cf->head.flat_bucket-1)
 209         {
 210             yaz_log (YLOG_FATAL, "read index block hno=" ZINT_FORMAT
 211                      " (" ZINT_FORMAT "-" ZINT_FORMAT ") commit",
 212                      hno, cf->head.next_bucket, cf->head.flat_bucket-1);
 213             r = -1;
 214             goto out;
 215         }
 216         for (i = 0; i < (int) (HASH_BSIZE/sizeof(zint)); i++)
 217         {
 218             if (fp[i])
 219             {
 220 #if CF_OPTIMIZE_COMMIT
 221                 if (map_cache_add(m_p, fp[i], vno))
 222                 {
 223                     r = -1;
 224                     goto out;
 225                 }
 226 #else
 227                 if (!mf_read (cf->block_mf, fp[i], 0, 0, cf->iobuf))
 228                 {
 229                     yaz_log (YLOG_FATAL, "read data block hno=" ZINT_FORMAT " (" ZINT_FORMAT "-" ZINT_FORMAT ") "
 230                              "i=%d commit block at " ZINT_FORMAT " (->" ZINT_FORMAT")",
 231                              hno, cf->head.next_bucket, cf->head.flat_bucket-1,
 232                              i, fp[i], vno);
 233                     r = -1;
 234                     goto out;
 235                 }
 236                 if (mf_write (cf->rmf, vno, 0, 0, cf->iobuf) != 1)
 237                 {
 238                     r = -1;
 239                     goto out;
 240                 }
 241 #endif
 242             }
 243             vno++;
 244         }
 245     }
 246  out:
 247 #if CF_OPTIMIZE_COMMIT
 248     if (map_cache_del(m_p))
 249         r = -1;
 250 #endif
 251     xfree(fp);
 252     return r;
 253 }
 254
 255 int cf_commit (CFile cf)
 256 {
 257     if (cf->bucket_in_memory)
 258     {
 259         yaz_log(YLOG_FATAL, "cf_commit: dirty cache");
 260         return -1;
 261     }
 262     if (cf->head.state == 1)
 263         return cf_commit_hash (cf);
 264     else if (cf->head.state == 2)
 265         return cf_commit_flat (cf);
 266     else
 267     {
 268         yaz_log(YLOG_FATAL, "cf_commit: bad state=%d", cf->head.state);
 269         return -1;
 270     }
 271 }
 272
 273 /*
 274  * Local variables:
 275  * c-basic-offset: 4
 276  * indent-tabs-mode: nil
 277  * End:
 278  * vim: shiftwidth=4 tabstop=8 expandtab
 279  */
 280