Avoid repeated creation/freeing of per-subre DFAs during regex search.

In nested sub-regex trees, lower-level nodes created DFAs and then
destroyed them again before exiting, which is a bit dumb considering that
the recursive search is likely to call those nodes again later.  Instead
cache each created DFA until the end of pg_regexec().  This is basically a
space for time tradeoff, in that it might increase the maximum memory
usage.  However, in most regex patterns there are not all that many subre
nodes, so not that many DFAs --- and in any case, the peak usage occurs
when reaching the bottom recursion level, and except for alternation cases
that's going to be the same anyway.

diff --git a/src/backend/regex/regexec.c b/src/backend/regex/regexec.c
index 55f0c18d14f6af48432638fd95f72dcc27fb0081..d3e850a86994cadd2984fbd24140dfaea4985478 100644 (file)
--- a/src/backend/regex/regexec.c
+++ b/src/backend/regex/regexec.c
@@ -112,6 +112,7 @@ struct vars
        chr                *search_start;       /* search start of string */
        chr                *stop;                       /* just past end of string */
        int                     err;                    /* error code if any (0 none) */
+       struct dfa **subdfas;           /* per-subre DFAs */
        struct smalldfa dfa1;
        struct smalldfa dfa2;
 };
@@ -130,6 +131,7 @@ struct vars
  * forward declarations
  */
 /* === regexec.c === */
+static struct dfa *getsubdfa(struct vars *, struct subre *);
 static int     find(struct vars *, struct cnfa *, struct colormap *);
 static int     cfind(struct vars *, struct cnfa *, struct colormap *);
 static int     cfindloop(struct vars *, struct cnfa *, struct colormap *, struct dfa *, struct dfa *, chr **);
@@ -180,11 +182,15 @@ pg_regexec(regex_t *re,
        register struct vars *v = &var;
        int                     st;
        size_t          n;
+       size_t          i;
        int                     backref;
 
 #define  LOCALMAT       20
        regmatch_t      mat[LOCALMAT];
 
+#define  LOCALDFAS      40
+       struct dfa *subdfas[LOCALDFAS];
+
        /* sanity checks */
        if (re == NULL || string == NULL || re->re_magic != REMAGIC)
                return REG_INVARG;
@@ -225,6 +231,20 @@ pg_regexec(regex_t *re,
        v->search_start = (chr *) string + search_start;
        v->stop = (chr *) string + len;
        v->err = 0;
+       assert(v->g->ntree >= 0);
+       n = (size_t) v->g->ntree;
+       if (n <= LOCALDFAS)
+               v->subdfas = subdfas;
+       else
+               v->subdfas = (struct dfa **) MALLOC(n * sizeof(struct dfa *));
+       if (v->subdfas == NULL)
+       {
+               if (v->pmatch != pmatch && v->pmatch != mat)
+                       FREE(v->pmatch);
+               return REG_ESPACE;
+       }
+       for (i = 0; i < n; i++)
+               v->subdfas[i] = NULL;
 
        /* do it */
        assert(v->g->tree != NULL);
@@ -244,9 +264,36 @@ pg_regexec(regex_t *re,
        /* clean up */
        if (v->pmatch != pmatch && v->pmatch != mat)
                FREE(v->pmatch);
+       for (i = 0; i < n; i++)
+       {
+               if (v->subdfas[i] != NULL)
+                       freedfa(v->subdfas[i]);
+       }
+       if (v->subdfas != subdfas)
+               FREE(v->subdfas);
+
        return st;
 }
 
+/*
+ * getsubdfa - create or re-fetch the DFA for a subre node
+ *
+ * We only need to create the DFA once per overall regex execution.
+ * The DFA will be freed by the cleanup step in pg_regexec().
+ */
+static struct dfa *
+getsubdfa(struct vars * v,
+                 struct subre * t)
+{
+       if (v->subdfas[t->id] == NULL)
+       {
+               v->subdfas[t->id] = newdfa(v, &t->cnfa, &v->g->cmap, DOMALLOC);
+               if (ISERR())
+                       return NULL;
+       }
+       return v->subdfas[t->id];
+}
+
 /*
  * find - find a match for the main NFA (no-complications case)
  */
@@ -578,15 +625,10 @@ condissect(struct vars * v,
        assert(t->left != NULL && t->left->cnfa.nstates > 0);
        assert(t->right != NULL && t->right->cnfa.nstates > 0);
 
-       d = newdfa(v, &t->left->cnfa, &v->g->cmap, &v->dfa1);
+       d = getsubdfa(v, t->left);
+       NOERR();
+       d2 = getsubdfa(v, t->right);
        NOERR();
-       d2 = newdfa(v, &t->right->cnfa, &v->g->cmap, &v->dfa2);
-       if (ISERR())
-       {
-               assert(d2 == NULL);
-               freedfa(d);
-               return v->err;
-       }
 
        /* pick a tentative midpoint */
        if (shorter)
@@ -595,11 +637,7 @@ condissect(struct vars * v,
        else
                mid = longest(v, d, begin, end, (int *) NULL);
        if (mid == NULL)
-       {
-               freedfa(d);
-               freedfa(d2);
                return REG_ASSERT;
-       }
        MDEBUG(("tentative midpoint %ld\n", LOFF(mid)));
 
        /* iterate until satisfaction or failure */
@@ -610,8 +648,6 @@ condissect(struct vars * v,
                {
                        /* all possibilities exhausted! */
                        MDEBUG(("no midpoint!\n"));
-                       freedfa(d);
-                       freedfa(d2);
                        return REG_ASSERT;
                }
                if (shorter)
@@ -623,8 +659,6 @@ condissect(struct vars * v,
                {
                        /* failed to find a new one! */
                        MDEBUG(("failed midpoint!\n"));
-                       freedfa(d);
-                       freedfa(d2);
                        return REG_ASSERT;
                }
                MDEBUG(("new midpoint %ld\n", LOFF(mid)));
@@ -632,8 +666,6 @@ condissect(struct vars * v,
 
        /* satisfaction */
        MDEBUG(("successful\n"));
-       freedfa(d);
-       freedfa(d2);
        i = dissect(v, t->left, begin, mid);
        if (i != REG_OKAY)
                return i;
@@ -659,16 +691,13 @@ altdissect(struct vars * v,
        {
                MDEBUG(("trying %dth\n", i));
                assert(t->left != NULL && t->left->cnfa.nstates > 0);
-               d = newdfa(v, &t->left->cnfa, &v->g->cmap, &v->dfa1);
-               if (ISERR())
-                       return v->err;
+               d = getsubdfa(v, t->left);
+               NOERR();
                if (longest(v, d, begin, end, (int *) NULL) == end)
                {
                        MDEBUG(("success\n"));
-                       freedfa(d);
                        return dissect(v, t->left, begin, end);
                }
-               freedfa(d);
        }
        return REG_ASSERT;                      /* none of them matched?!? */
 }
@@ -731,7 +760,7 @@ iterdissect(struct vars * v,
                return REG_ESPACE;
        endpts[0] = begin;
 
-       d = newdfa(v, &t->left->cnfa, &v->g->cmap, DOMALLOC);
+       d = getsubdfa(v, t->left);
        if (ISERR())
        {
                FREE(endpts);
@@ -814,7 +843,6 @@ iterdissect(struct vars * v,
                        if (er == REG_NOMATCH)
                                break;
                        /* oops, something failed */
-                       freedfa(d);
                        FREE(endpts);
                        return er;
                }
@@ -823,7 +851,6 @@ iterdissect(struct vars * v,
                {
                        /* satisfaction */
                        MDEBUG(("%d successful\n", t->id));
-                       freedfa(d);
                        FREE(endpts);
                        return REG_OKAY;
                }
@@ -856,7 +883,6 @@ backtrack:
 
        /* all possibilities exhausted - shouldn't happen in uncomplicated mode */
        MDEBUG(("%d failed\n", t->id));
-       freedfa(d);
        FREE(endpts);
        return REG_ASSERT;
 }
@@ -917,7 +943,7 @@ reviterdissect(struct vars * v,
                return REG_ESPACE;
        endpts[0] = begin;
 
-       d = newdfa(v, &t->left->cnfa, &v->g->cmap, DOMALLOC);
+       d = getsubdfa(v, t->left);
        if (ISERR())
        {
                FREE(endpts);
@@ -1002,7 +1028,6 @@ reviterdissect(struct vars * v,
                        if (er == REG_NOMATCH)
                                break;
                        /* oops, something failed */
-                       freedfa(d);
                        FREE(endpts);
                        return er;
                }
@@ -1011,7 +1036,6 @@ reviterdissect(struct vars * v,
                {
                        /* satisfaction */
                        MDEBUG(("%d successful\n", t->id));
-                       freedfa(d);
                        FREE(endpts);
                        return REG_OKAY;
                }
@@ -1037,7 +1061,6 @@ backtrack:
 
        /* all possibilities exhausted - shouldn't happen in uncomplicated mode */
        MDEBUG(("%d failed\n", t->id));
-       freedfa(d);
        FREE(endpts);
        return REG_ASSERT;
 }
@@ -1106,25 +1129,16 @@ ccondissect(struct vars * v,
        if (t->left->flags & SHORTER)           /* reverse scan */
                return crevdissect(v, t, begin, end);
 
-       d = newdfa(v, &t->left->cnfa, &v->g->cmap, DOMALLOC);
-       if (ISERR())
-               return v->err;
-       d2 = newdfa(v, &t->right->cnfa, &v->g->cmap, DOMALLOC);
-       if (ISERR())
-       {
-               freedfa(d);
-               return v->err;
-       }
+       d = getsubdfa(v, t->left);
+       NOERR();
+       d2 = getsubdfa(v, t->right);
+       NOERR();
        MDEBUG(("cconcat %d\n", t->id));
 
        /* pick a tentative midpoint */
        mid = longest(v, d, begin, end, (int *) NULL);
        if (mid == NULL)
-       {
-               freedfa(d);
-               freedfa(d2);
                return REG_NOMATCH;
-       }
        MDEBUG(("tentative midpoint %ld\n", LOFF(mid)));
 
        /* iterate until satisfaction or failure */
@@ -1141,17 +1155,11 @@ ccondissect(struct vars * v,
                                {
                                        /* satisfaction */
                                        MDEBUG(("successful\n"));
-                                       freedfa(d);
-                                       freedfa(d2);
                                        return REG_OKAY;
                                }
                        }
                        if (er != REG_OKAY && er != REG_NOMATCH)
-                       {
-                               freedfa(d);
-                               freedfa(d2);
                                return er;
-                       }
                }
 
                /* that midpoint didn't work, find a new one */
@@ -1159,8 +1167,6 @@ ccondissect(struct vars * v,
                {
                        /* all possibilities exhausted */
                        MDEBUG(("%d no midpoint\n", t->id));
-                       freedfa(d);
-                       freedfa(d2);
                        return REG_NOMATCH;
                }
                mid = longest(v, d, begin, mid - 1, (int *) NULL);
@@ -1168,8 +1174,6 @@ ccondissect(struct vars * v,
                {
                        /* failed to find a new one */
                        MDEBUG(("%d failed midpoint\n", t->id));
-                       freedfa(d);
-                       freedfa(d2);
                        return REG_NOMATCH;
                }
                MDEBUG(("%d: new midpoint %ld\n", t->id, LOFF(mid)));
@@ -1201,25 +1205,16 @@ crevdissect(struct vars * v,
        assert(t->left->flags & SHORTER);
 
        /* concatenation -- need to split the substring between parts */
-       d = newdfa(v, &t->left->cnfa, &v->g->cmap, DOMALLOC);
-       if (ISERR())
-               return v->err;
-       d2 = newdfa(v, &t->right->cnfa, &v->g->cmap, DOMALLOC);
-       if (ISERR())
-       {
-               freedfa(d);
-               return v->err;
-       }
+       d = getsubdfa(v, t->left);
+       NOERR();
+       d2 = getsubdfa(v, t->right);
+       NOERR();
        MDEBUG(("crev %d\n", t->id));
 
        /* pick a tentative midpoint */
        mid = shortest(v, d, begin, begin, end, (chr **) NULL, (int *) NULL);
        if (mid == NULL)
-       {
-               freedfa(d);
-               freedfa(d2);
                return REG_NOMATCH;
-       }
        MDEBUG(("tentative midpoint %ld\n", LOFF(mid)));
 
        /* iterate until satisfaction or failure */
@@ -1236,17 +1231,11 @@ crevdissect(struct vars * v,
                                {
                                        /* satisfaction */
                                        MDEBUG(("successful\n"));
-                                       freedfa(d);
-                                       freedfa(d2);
                                        return REG_OKAY;
                                }
                        }
                        if (er != REG_OKAY && er != REG_NOMATCH)
-                       {
-                               freedfa(d);
-                               freedfa(d2);
                                return er;
-                       }
                }
 
                /* that midpoint didn't work, find a new one */
@@ -1254,8 +1243,6 @@ crevdissect(struct vars * v,
                {
                        /* all possibilities exhausted */
                        MDEBUG(("%d no midpoint\n", t->id));
-                       freedfa(d);
-                       freedfa(d2);
                        return REG_NOMATCH;
                }
                mid = shortest(v, d, begin, mid + 1, end, (chr **) NULL, (int *) NULL);
@@ -1263,8 +1250,6 @@ crevdissect(struct vars * v,
                {
                        /* failed to find a new one */
                        MDEBUG(("%d failed midpoint\n", t->id));
-                       freedfa(d);
-                       freedfa(d2);
                        return REG_NOMATCH;
                }
                MDEBUG(("%d: new midpoint %ld\n", t->id, LOFF(mid)));
@@ -1377,15 +1362,10 @@ caltdissect(struct vars * v,
 
        MDEBUG(("calt n%d\n", t->id));
 
-       d = newdfa(v, &t->left->cnfa, &v->g->cmap, DOMALLOC);
-       if (ISERR())
-               return v->err;
+       d = getsubdfa(v, t->left);
+       NOERR();
        if (longest(v, d, begin, end, (int *) NULL) != end)
-       {
-               freedfa(d);
                return caltdissect(v, t->right, begin, end);
-       }
-       freedfa(d);
        MDEBUG(("calt matched\n"));
 
        er = cdissect(v, t->left, begin, end);
@@ -1453,7 +1433,7 @@ citerdissect(struct vars * v,
                return REG_ESPACE;
        endpts[0] = begin;
 
-       d = newdfa(v, &t->left->cnfa, &v->g->cmap, DOMALLOC);
+       d = getsubdfa(v, t->left);
        if (ISERR())
        {
                FREE(endpts);
@@ -1537,7 +1517,6 @@ citerdissect(struct vars * v,
                        if (er == REG_NOMATCH)
                                break;
                        /* oops, something failed */
-                       freedfa(d);
                        FREE(endpts);
                        return er;
                }
@@ -1546,7 +1525,6 @@ citerdissect(struct vars * v,
                {
                        /* satisfaction */
                        MDEBUG(("%d successful\n", t->id));
-                       freedfa(d);
                        FREE(endpts);
                        return REG_OKAY;
                }
@@ -1579,7 +1557,6 @@ backtrack:
 
        /* all possibilities exhausted */
        MDEBUG(("%d failed\n", t->id));
-       freedfa(d);
        FREE(endpts);
        return REG_NOMATCH;
 }
@@ -1640,7 +1617,7 @@ creviterdissect(struct vars * v,
                return REG_ESPACE;
        endpts[0] = begin;
 
-       d = newdfa(v, &t->left->cnfa, &v->g->cmap, DOMALLOC);
+       d = getsubdfa(v, t->left);
        if (ISERR())
        {
                FREE(endpts);
@@ -1726,7 +1703,6 @@ creviterdissect(struct vars * v,
                        if (er == REG_NOMATCH)
                                break;
                        /* oops, something failed */
-                       freedfa(d);
                        FREE(endpts);
                        return er;
                }
@@ -1735,7 +1711,6 @@ creviterdissect(struct vars * v,
                {
                        /* satisfaction */
                        MDEBUG(("%d successful\n", t->id));
-                       freedfa(d);
                        FREE(endpts);
                        return REG_OKAY;
                }
@@ -1761,7 +1736,6 @@ backtrack:
 
        /* all possibilities exhausted */
        MDEBUG(("%d failed\n", t->id));
-       freedfa(d);
        FREE(endpts);
        return REG_NOMATCH;
 }

diff --git a/src/include/regex/regguts.h b/src/include/regex/regguts.h
index bc5419d98e78bf103a0fa54c87292e83c17eb2aa..65b8d178da86d244080560e9afd5499a4b500b24 100644 (file)
--- a/src/include/regex/regguts.h
+++ b/src/include/regex/regguts.h
@@ -409,7 +409,7 @@ struct subre
 #define  PREF(f) ((f)&LOCAL)
 #define  PREF2(f1, f2)  ((PREF(f1) != 0) ? PREF(f1) : PREF(f2))
 #define  COMBINE(f1, f2) (UP((f1)|(f2)) | PREF2(f1, f2))
-       short           id;                             /* ID of subre (1..ntree) */
+       short           id;                             /* ID of subre (1..ntree-1) */
        int                     subno;                  /* subexpression number (for 'b' and '(') */
        short           min;                    /* min repetitions for iteration or backref */
        short           max;                    /* max repetitions for iteration or backref */
@@ -446,7 +446,7 @@ struct guts
        size_t          nsub;                   /* copy of re_nsub */
        struct subre *tree;
        struct cnfa search;                     /* for fast preliminary search */
-       int                     ntree;
+       int                     ntree;                  /* number of subre's, less one */
        struct colormap cmap;
        int                     FUNCPTR(compare, (const chr *, const chr *, size_t));
        struct subre *lacons;           /* lookahead-constraint vector */