Reduce the memory requirement for large ispell dictionaries.

This patch eliminates per-chunk palloc overhead for most small allocations
needed in the representation of an ispell dictionary.  This saves close to
a factor of 2 on the current Czech ispell data.  While it doesn't cover
every last small allocation in the ispell code, we are at the point of
diminishing returns, because about 95% of the allocations are covered
already.

Pavel Stehule, rather heavily revised by Tom

diff --git a/src/backend/tsearch/spell.c b/src/backend/tsearch/spell.c
index cd7ada6613872e65cd00e276faf120ac0b470d71..713833986a3e942db0806b4660c422378fa69696 100644 (file)
--- a/src/backend/tsearch/spell.c
+++ b/src/backend/tsearch/spell.c
@@ -59,6 +59,63 @@ NIFinishBuild(IspellDict *Conf)
    /* Just for cleanliness, zero the now-dangling pointers */
    Conf->buildCxt = NULL;
    Conf->Spell = NULL;
+   Conf->firstfree = NULL;
+}
+
+
+/*
+ * "Compact" palloc: allocate without extra palloc overhead.
+ *
+ * Since we have no need to free the ispell data items individually, there's
+ * not much value in the per-chunk overhead normally consumed by palloc.
+ * Getting rid of it is helpful since ispell can allocate a lot of small nodes.
+ *
+ * We currently pre-zero all data allocated this way, even though some of it
+ * doesn't need that.  The cpalloc and cpalloc0 macros are just documentation
+ * to indicate which allocations actually require zeroing.
+ */
+#define COMPACT_ALLOC_CHUNK    8192    /* must be > aset.c's allocChunkLimit */
+#define COMPACT_MAX_REQ        1024    /* must be < COMPACT_ALLOC_CHUNK */
+
+static void *
+compact_palloc0(IspellDict *Conf, size_t size)
+{
+   void       *result;
+
+   /* Should only be called during init */
+   Assert(Conf->buildCxt != NULL);
+
+   /* No point in this for large chunks */
+   if (size > COMPACT_MAX_REQ)
+       return palloc0(size);
+
+   /* Keep everything maxaligned */
+   size = MAXALIGN(size);
+
+   /* Need more space? */
+   if (size > Conf->avail)
+   {
+       Conf->firstfree = palloc0(COMPACT_ALLOC_CHUNK);
+       Conf->avail = COMPACT_ALLOC_CHUNK;
+   }
+
+   result = (void *) Conf->firstfree;
+   Conf->firstfree += size;
+   Conf->avail -= size;
+
+   return result;
+}
+
+#define cpalloc(size) compact_palloc0(Conf, size)
+#define cpalloc0(size) compact_palloc0(Conf, size)
+
+static char *
+cpstrdup(IspellDict *Conf, const char *str)
+{
+   char       *res = cpalloc(strlen(str) + 1);
+
+   strcpy(res, str);
+   return res;
 }
 
 
@@ -186,7 +243,7 @@ NIAddSpell(IspellDict *Conf, const char *word, const char *flag)
    {
        if (Conf->mspell)
        {
-           Conf->mspell += 1024 * 20;
+           Conf->mspell *= 2;
            Conf->Spell = (SPELL **) repalloc(Conf->Spell, Conf->mspell * sizeof(SPELL *));
        }
        else
@@ -324,7 +381,7 @@ NIAddAffix(IspellDict *Conf, int flag, char flagflags, const char *mask, const c
    {
        if (Conf->maffixes)
        {
-           Conf->maffixes += 16;
+           Conf->maffixes *= 2;
            Conf->Affix = (AFFIX *) repalloc((void *) Conf->Affix, Conf->maffixes * sizeof(AFFIX));
        }
        else
@@ -389,9 +446,9 @@ NIAddAffix(IspellDict *Conf, int flag, char flagflags, const char *mask, const c
    Affix->flag = flag;
    Affix->type = type;
 
-   Affix->find = (find && *find) ? pstrdup(find) : VoidString;
+   Affix->find = (find && *find) ? cpstrdup(Conf, find) : VoidString;
    if ((Affix->replen = strlen(repl)) > 0)
-       Affix->repl = pstrdup(repl);
+       Affix->repl = cpstrdup(Conf, repl);
    else
        Affix->repl = VoidString;
    Conf->naffixes++;
@@ -843,8 +900,9 @@ MergeAffix(IspellDict *Conf, int a1, int a2)
    }
 
    ptr = Conf->AffixData + Conf->nAffixData;
-   *ptr = palloc(strlen(Conf->AffixData[a1]) + strlen(Conf->AffixData[a2]) +
-                 1 /* space */ + 1 /* \0 */ );
+   *ptr = cpalloc(strlen(Conf->AffixData[a1]) +
+                  strlen(Conf->AffixData[a2]) +
+                  1 /* space */ + 1 /* \0 */ );
    sprintf(*ptr, "%s %s", Conf->AffixData[a1], Conf->AffixData[a2]);
    ptr++;
    *ptr = NULL;
@@ -888,7 +946,7 @@ mkSPNode(IspellDict *Conf, int low, int high, int level)
    if (!nchar)
        return NULL;
 
-   rs = (SPNode *) palloc0(SPNHDRSZ + nchar * sizeof(SPNodeData));
+   rs = (SPNode *) cpalloc0(SPNHDRSZ + nchar * sizeof(SPNodeData));
    rs->length = nchar;
    data = rs->data;
 
@@ -982,7 +1040,7 @@ NISortDictionary(IspellDict *Conf)
        {
            curaffix++;
            Assert(curaffix < naffix);
-           Conf->AffixData[curaffix] = pstrdup(Conf->Spell[i]->p.flag);
+           Conf->AffixData[curaffix] = cpstrdup(Conf, Conf->Spell[i]->p.flag);
        }
 
        Conf->Spell[i]->p.d.affix = curaffix;
@@ -1020,7 +1078,7 @@ mkANode(IspellDict *Conf, int low, int high, int level, int type)
    aff = (AFFIX **) tmpalloc(sizeof(AFFIX *) * (high - low + 1));
    naff = 0;
 
-   rs = (AffixNode *) palloc0(ANHRDSZ + nchar * sizeof(AffixNodeData));
+   rs = (AffixNode *) cpalloc0(ANHRDSZ + nchar * sizeof(AffixNodeData));
    rs->length = nchar;
    data = rs->data;
 
@@ -1036,7 +1094,7 @@ mkANode(IspellDict *Conf, int low, int high, int level, int type)
                    if (naff)
                    {
                        data->naff = naff;
-                       data->aff = (AFFIX **) palloc(sizeof(AFFIX *) * naff);
+                       data->aff = (AFFIX **) cpalloc(sizeof(AFFIX *) * naff);
                        memcpy(data->aff, aff, sizeof(AFFIX *) * naff);
                        naff = 0;
                    }
@@ -1056,7 +1114,7 @@ mkANode(IspellDict *Conf, int low, int high, int level, int type)
    if (naff)
    {
        data->naff = naff;
-       data->aff = (AFFIX **) palloc(sizeof(AFFIX *) * naff);
+       data->aff = (AFFIX **) cpalloc(sizeof(AFFIX *) * naff);
        memcpy(data->aff, aff, sizeof(AFFIX *) * naff);
        naff = 0;
    }
@@ -1097,7 +1155,7 @@ mkVoidAffix(IspellDict *Conf, bool issuffix, int startsuffix)
    if (cnt == 0)
        return;
 
-   Affix->data->aff = (AFFIX **) palloc(sizeof(AFFIX *) * cnt);
+   Affix->data->aff = (AFFIX **) cpalloc(sizeof(AFFIX *) * cnt);
    Affix->data->naff = (uint32) cnt;
 
    cnt = 0;

diff --git a/src/include/tsearch/dicts/spell.h b/src/include/tsearch/dicts/spell.h
index 421a636dc717e9217bcadedd5bc2ab5421e87ea2..b41fbb6fd5f6cf151a3fe4e766b52a3f5a680f5f 100644 (file)
--- a/src/include/tsearch/dicts/spell.h
+++ b/src/include/tsearch/dicts/spell.h
@@ -161,6 +161,10 @@ typedef struct
    SPELL     **Spell;
    int         nspell;         /* number of valid entries in Spell array */
    int         mspell;         /* allocated length of Spell array */
+
+   /* These are used to allocate "compact" data without palloc overhead */
+   char       *firstfree;      /* first free address (always maxaligned) */
+   size_t      avail;          /* free space remaining at firstfree */
 } IspellDict;
 
 extern TSLexeme *NINormalizeWord(IspellDict *Conf, char *word);