Changeset 3457 for trunk/src

Timestamp:

Sep 14, 2020, 7:34:28 PM (5 years ago)

Author:

bird

Message:

kash: New parser allocator for non-forked-mode.

Location:

trunk/src/kash

Files:

• Makefile.kmk (modified) (1 diff)
• memalloc.c (modified) (9 diffs)
• memalloc.h (modified) (3 diffs)
• parser.c (modified) (17 diffs)
• shinstance.h (modified) (2 diffs)
• shthread.h (modified) (2 diffs)

trunk/src/kash/Makefile.kmk

@@ -36 +36 @@
 kash_NAME = kmk_ash
 kash_ASTOOL = YASM
-kash_DEFS = lint SHELL SMALL
+kash_DEFS = lint SHELL SMALL #KASH_SEPARATE_PARSER_ALLOCATOR
 if "$(KBUILD_TARGET)" != "win" || defined(KASH_WIN_FORKED_MODE)
 kash_DEFS += SH_FORKED_MODE

trunk/src/kash/memalloc.c

@@ -42 +42 @@
 
 #include <stdlib.h>
+#include <stddef.h>
 #include <assert.h>
 
@@ -183 +184 @@
         mark->stacknleft = psh->stacknleft;
         mark->marknext = psh->markp;
+#ifdef KASH_SEPARATE_PARSER_ALLOCATOR
+        mark->pstacksize = psh->pstacksize;
+#endif
         psh->markp = mark;
 }
@@ -201 +205 @@
         psh->stacknxt = mark->stacknxt;
         psh->stacknleft = mark->stacknleft;
+
+#ifdef KASH_SEPARATE_PARSER_ALLOCATOR
+        assert(mark->pstacksize <= psh->pstacksize);
+        while (mark->pstacksize < psh->pstacksize) {
+                unsigned idx = --psh->pstacksize;
+                pstack_block *psk = psh->pstack[idx];
+                psh->pstack[idx] = NULL;
+                if (psh->curpstack == psk)
+                    psh->curpstack = idx > 0 ? psh->pstack[idx - 1] : NULL;
+                pstackrelease(psh, psk);
+        }
+
+# ifndef NDEBUG
+        if (psh->curpstack) {
+                unsigned i;
+                for (i = 0; i < psh->pstacksize; i++)
+                        if (psh->curpstack == psh->pstack[i])
+                                break;
+                assert(i < psh->pstacksize);
+        }
+# endif
+#endif
         INTON;
 }
@@ -354 +380 @@
  * Parser stack allocator.
  */
+#ifdef KASH_SEPARATE_PARSER_ALLOCATOR
+
+unsigned pstackretain(pstack_block *pst)
+{
+        unsigned refs = sh_atomic_inc(&pst->refs);
+        assert(refs > 1);
+        assert(refs < 256 /* bogus, but useful */);
+        return refs;
+}
+
+unsigned pstackrelease(shinstance *psh, pstack_block *pst)
+{
+        unsigned refs;
+        if (pst) {
+                refs = sh_atomic_dec(&pst->refs);
+                if (refs == 0) {
+                        shinstance * const psh = shthread_get_shell();
+                        struct stack_block *top;
+                        while ((top = pst->top) != &pst->first)
+                        {
+                            pst->top = top->prev;
+                            assert(pst->top);
+                            top->prev = NULL;
+                            sh_free(psh, top);
+                        }
+                        pst->nextbyte = NULL;
+                        pst->top = NULL;
+                        sh_free(psh, pst);
+                }
+        } else
+                refs = 0;
+        return refs;
+}
+
+pstack_block *pstackpush(shinstance *psh)
+{
+        size_t const blocksize = offsetof(pstack_block, first.space) + MINSIZE;
+        pstack_block *pst;
+        unsigned i;
+
+        INTOFF;
+
+        /*
+         * Allocate and initialize it.
+         */
+        pst = (pstack_block *)ckmalloc(psh, blocksize);
+        pst->nextbyte          = &pst->first.space[0];
+        pst->avail             = blocksize - offsetof(pstack_block, first.space);
+        pst->topsize           = blocksize - offsetof(pstack_block, first.space);
+        pst->strleft           = 0;
+        pst->top               = &pst->first;
+        pst->allocations       = 0;
+        pst->bytesalloced      = 0;
+        pst->nodesalloced      = 0;
+        pst->entriesalloced    = 0;
+        pst->strbytesalloced   = 0;
+        pst->blocks            = 0;
+        pst->fragmentation     = 0;
+        pst->refs              = 1;
+        pst->padding           = 42;
+        pst->first.prev        = NULL;
+
+        /*
+         * Push it onto the stack.
+         */
+        i = psh->pstacksize;
+        if (i + 1 < psh->pstackalloced) {
+                /* likely, except for the first time */
+        } else {
+                psh->pstack = (pstack_block **)ckrealloc(psh, psh->pstack, sizeof(psh->pstack[0]) * (i + 32));
+                memset(&psh->pstack[i], 0, sizeof(psh->pstack[0]) * 32);
+        }
+        psh->pstack[i] = pst;
+        psh->pstacksize = i + 1;
+        psh->curpstack = pst;
+
+        INTON;
+        return pst;
+}
+
+/**
+ * Allocates and pushes a new block onto the stack, min payload size @a nbytes.
+ */
+static void pstallocnewblock(shinstance *psh, pstack_block *pst, size_t nbytes)
+{
+        /* Allocate a new stack node. */
+        struct stack_block *sp;
+        size_t const blocksize = nbytes <= MINSIZE
+                               ? offsetof(struct stack_block, space) + MINSIZE
+                               : K_ALIGN_Z(nbytes + offsetof(struct stack_block, space), 1024);
+
+        INTOFF;
+        sp = ckmalloc(psh, blocksize);
+        sp->prev = pst->top;
+        pst->fragmentation += pst->avail;
+        pst->topsize        = blocksize - offsetof(struct stack_block, space);
+        pst->avail          = blocksize - offsetof(struct stack_block, space);
+        pst->nextbyte       = sp->space;
+        pst->top            = sp;
+        pst->blocks        += 1;
+        INTON;
+}
+
+/**
+ * Tries to grow the current stack block to hold a minimum of @a nbytes,
+ * will allocate a new block and copy over pending string bytes if that's not
+ * possible.
+ */
+static void pstgrowblock(shinstance *psh, pstack_block *pst, size_t nbytes, size_t tocopy)
+{
+        struct stack_block *top = pst->top;
+        size_t blocksize;
+
+        assert(pst->avail < nbytes); /* only called when we need more space */
+        assert(tocopy <= pst->avail);
+
+        /* Double the size used thus far and add some fudge and alignment.  Make
+           sure to at least allocate MINSIZE. */
+        blocksize = K_MAX(K_ALIGN_Z(pst->avail * 2 + 100 + offsetof(struct stack_block, space), 64), MINSIZE);
+
+        /* If that isn't sufficient, do request size w/ some fudge and alignment. */
+        if (blocksize < nbytes + offsetof(struct stack_block, space))
+            blocksize = K_ALIGN_Z(nbytes + offsetof(struct stack_block, space) + 100, 1024);
+
+        /*
+         * Reallocate the current stack node if we can.
+         */
+        if (   pst->nextbyte == &top->space[0] /* can't have anything else in the block */
+            && top->prev != NULL /* first block is embedded in pst and cannot be reallocated */ ) {
+                top = (struct stack_block *)ckrealloc(psh, top, blocksize);
+                pst->top      = top;
+                pst->topsize  = blocksize - offsetof(struct stack_block, space);
+                pst->avail    = blocksize - offsetof(struct stack_block, space);
+                pst->nextbyte = top->space;
+        }
+        /*
+         * Otherwise allocate a new node and copy over the avail bytes
+         * from the old one.
+         */
+        else {
+                char const * const copysrc = pst->nextbyte;
+                pstallocnewblock(psh, pst, nbytes);
+                assert(pst->avail >= nbytes);
+                assert(pst->avail >= tocopy);
+                memcpy(pst->nextbyte, copysrc, tocopy);
+        }
+}
+
+K_INLINE void *pstallocint(shinstance *psh, pstack_block *pst, size_t nbytes)
+{
+        void *ret;
+
+        /*
+         * Align the size and make sure we've got sufficient bytes available:
+         */
+        nbytes = SHELL_ALIGN(nbytes);
+        if (pst->avail >= nbytes && (ssize_t)pst->avail >= 0) { /* likely*/ }
+        else pstallocnewblock(psh, pst, nbytes);
+
+        /*
+         * Carve out the return block.
+         */
+        ret = pst->nextbyte;
+        pst->nextbyte     += nbytes;
+        pst->avail        -= nbytes;
+        pst->bytesalloced += nbytes;
+        pst->allocations  += 1;
+        return ret;
+}
+
+#endif KASH_SEPARATE_PARSER_ALLOCATOR
+
+
 void *pstalloc(struct shinstance *psh, size_t nbytes)
 {
+#ifdef KASH_SEPARATE_PARSER_ALLOCATOR
+        return pstallocint(psh, psh->curpstack, nbytes);
+#else
         return stalloc(psh, nbytes);
+#endif
 }
 
 union node *pstallocnode(struct shinstance *psh, size_t nbytes)
 {
+#ifdef KASH_SEPARATE_PARSER_ALLOCATOR
+        pstack_block *pst = psh->curpstack;
+        pst->nodesalloced++;
+        return (union node *)pstallocint(psh, pst, nbytes);
+#else
         return (union node *)pstalloc(psh, nbytes);
+#endif
 }
 
 struct nodelist *pstalloclist(struct shinstance *psh)
 {
+#ifdef KASH_SEPARATE_PARSER_ALLOCATOR
+        pstack_block *pst = psh->curpstack;
+        pst->entriesalloced++;
+        return (struct nodelist *)pstallocint(psh, pst, sizeof(struct nodelist));
+#endif
         return (struct nodelist *)pstalloc(psh, sizeof(struct nodelist));
 }
@@ -372 +586 @@
 {
         if (str) {
-                size_t nbytes = strlen(str) + 1;
+                size_t const nbytes = strlen(str) + 1;
+#ifdef KASH_SEPARATE_PARSER_ALLOCATOR
+                pstack_block *pst = psh->curpstack;
+                pst->strbytesalloced += SHELL_ALIGN(nbytes);
+                return (char *)memcpy(pstallocint(psh, pst, nbytes), str, nbytes);
+#else
                 return (char *)memcpy(pstalloc(psh, nbytes), str, nbytes);
+#endif
         }
         return NULL;
@@ -380 +600 @@
 char *pstmakestrspace(struct shinstance *psh, size_t minbytes, char *end)
 {
+#ifdef KASH_SEPARATE_PARSER_ALLOCATOR
+        pstack_block *pst = psh->curpstack;
+        size_t const len = end - pst->nextbyte;
+
+        assert(pst->avail - pst->strleft == len);
+        TRACE2((psh, "pstmakestrspace: len=%u minbytes=%u (=> %u)\n", len, minbytes, len + minbytes));
+
+        pstgrowblock(psh, pst, minbytes + len, len);
+
+        pst->strleft = pst->avail - len;
+        return pst->nextbyte + len;
+
+#else
         size_t const len = end - stackblock(psh);
+
         assert(stackblocksize(psh) - psh->sstrnleft == len);
-TRACE2((psh, "pstmakestrspace: len=%u minbytes=%u (=> %u)\n", len, minbytes, len + minbytes));
+        TRACE2((psh, "pstmakestrspace: len=%u minbytes=%u (=> %u)\n", len, minbytes, len + minbytes));
+
         minbytes += len;
         while (stackblocksize(psh) < minbytes)
                 growstackblock(psh);
+
         psh->sstrnleft = (int)(stackblocksize(psh) - len);
         return (char *)stackblock(psh) + len;
+#endif
 }
 
@@ -393 +630 @@
 char *pstputcgrow(shinstance *psh, char *end, char c)
 {
-        psh->sstrnleft++; /* PSTPUTC() already incremented it. */
+#ifdef KASH_SEPARATE_PARSER_ALLOCATOR
+        pstack_block *pst = psh->curpstack;
+        pst->strleft++;         /* PSTPUTC() already incremented it. */
+        end = pstmakestrspace(psh, 1, end);
+        assert(pst->strleft > 0);
+        pst->strleft--;
+#else
+        psh->sstrnleft++;       /* PSTPUTC() already incremented it. */
         end = pstmakestrspace(psh, 1, end);
         assert(psh->sstrnleft > 0);
         psh->sstrnleft--;
+#endif
         *end++ = c;
         return end;
@@ -404 +649 @@
 char *pstgrabstr(struct shinstance *psh, char *end)
 {
+#ifdef KASH_SEPARATE_PARSER_ALLOCATOR
+        pstack_block *pst = psh->curpstack;
+        char * const pstart = pst->nextbyte;
+        size_t nbytes = (size_t)(end - pstart);
+
+        assert((uintptr_t)end > (uintptr_t)pstart);
+        assert(end[-1] == '\0');
+        assert(SHELL_ALIGN((uintptr_t)pstart) == (uintptr_t)pstart);
+        assert(pst->avail - pst->strleft >= nbytes);
+
+        nbytes = SHELL_ALIGN(nbytes); /** @todo don't align strings, align the other allocations. */
+        pst->nextbyte += nbytes;
+        pst->avail    -= nbytes;
+        pst->strbytesalloced += nbytes;
+
+        return pstart;
+
+#else
         char * const pstart = stackblock(psh);
         size_t nbytes = (size_t)(end - pstart);
@@ -417 +680 @@
 
         return pstart;
-}
-
+#endif
+}
+

trunk/src/kash/memalloc.h

@@ -39 +39 @@
         char *stacknxt;
         int stacknleft;
+#ifdef KASH_SEPARATE_PARSER_ALLOCATOR
+        unsigned pstacksize;
+#endif
         struct stackmark *marknext;
 };
@@ -84 +87 @@
  * subshells by simple reference counting.
  * @{ */
+#ifdef KASH_SEPARATE_PARSER_ALLOCATOR
+struct pstack_block;
+unsigned pstackretain(struct pstack_block *);
+unsigned pstackrelease(struct shinstance *, struct pstack_block *);
+struct pstack_block *pstackpush(struct shinstance *);
+#endif
 void *pstalloc(struct shinstance *, size_t);
 union node;
@@ -90 +99 @@
 struct nodelist *pstalloclist(struct shinstance *);
 char *pstsavestr(struct shinstance *, const char *); /* was: stsavestr */
-#define PSTARTSTACKSTR(psh, p)      do { (p) = (psh)->stacknxt; (psh)->sstrnleft = (psh)->stacknleft; } while (0)
 char *pstmakestrspace(struct shinstance *, size_t, char *); /* was: makestrspace / growstackstr */
-#define PSTCHECKSTRSPACE(psh, n, p) do { if ((psh)->sstrnleft >= (n)) {/*likely*/} \
+char *pstputcgrow(struct shinstance *, char *, char);
+char *pstgrabstr(struct shinstance *, char *); /* was: grabstackstr / grabstackblock*/
+#ifdef KASH_SEPARATE_PARSER_ALLOCATOR
+# define PSTBLOCK(psh)               ((psh)->curpstack->nextbyte)
+# define PSTARTSTACKSTR(psh, p) do { \
+        pstack_block *pstmacro = (psh)->curpstack; \
+        pstmacro->strleft = pstmacro->avail; \
+        (p) = pstmacro->nextbyte; \
+    } while (0)
+# define PSTCHECKSTRSPACE(psh, n, p) do { \
+        if ((psh)->curpstack->strleft >= (n)) {/*likely*/} \
+        else { (p) = pstmakestrspace(psh, (n), (p)); assert((psh)->curpstack->strleft >= (n)); } \
+    } while (0)
+# define PSTUPUTC(psh, c, p) do { \
+        assert((psh)->curpstack->strleft > 0); \
+        (psh)->curpstack->strleft -= 1; \
+        *(p)++ = (c); \
+    } while (0)
+# define PSTPUTC(psh, c, p) do { \
+        if ((ssize_t)--(psh)->curpstack->strleft >= 0) *(p)++ = (c); \
+        else (p) = pstputcgrow(psh, (p), (c)); \
+    } while (0)
+# define PSTPUTSTRN(psh, str, n, p) do { \
+        pstack_block *pstmacro = (psh)->curpstack; \
+        if (pstmacro->strleft >= (n)) {/*likely?*/} \
+        else (p) = pstmakestrspace(psh, (n), (p)); \
+        pstmacro->strleft -= (n); \
+        memcpy((p), (str), (n)); \
+        (p) += (n); \
+    } while (0)
+#else
+# define PSTBLOCK(psh)               ((psh)->stacknxt)
+# define PSTARTSTACKSTR(psh, p)      do { (p) = (psh)->stacknxt; (psh)->sstrnleft = (psh)->stacknleft; } while (0)
+# define PSTCHECKSTRSPACE(psh, n, p) do { if ((psh)->sstrnleft >= (n)) {/*likely*/} \
                                          else { (p) = pstmakestrspace(psh, (n), (p)); assert((psh)->sstrnleft >= (n)); } } while (0)
-#define PSTUPUTC(psh, c, p)         do { assert((psh)->sstrnleft > 0); --(psh)->sstrnleft; *(p)++ = (c); } while (0)
-char *pstputcgrow(struct shinstance *, char *, char);
-#define PSTPUTC(psh, c, p)          do { if (--(psh)->sstrnleft >= 0) *(p)++ = (c); else (p) = pstputcgrow(psh, (p), (c)); } while (0)
-#define PSTPUTSTRN(psh, str, n, p)  do { if ((psh)->sstrnleft >= (n)) {/*likely?*/} else (p) = pstmakestrspace(psh, (n), (p)); \
+# define PSTUPUTC(psh, c, p)         do { assert((psh)->sstrnleft > 0); --(psh)->sstrnleft; *(p)++ = (c); } while (0)
+# define PSTPUTC(psh, c, p)          do { if (--(psh)->sstrnleft >= 0) *(p)++ = (c); else (p) = pstputcgrow(psh, (p), (c)); } while (0)
+# define PSTPUTSTRN(psh, str, n, p)  do { if ((psh)->sstrnleft >= (n)) {/*likely?*/} else (p) = pstmakestrspace(psh, (n), (p)); \
                                          memcpy((p), (str), (n)); (psh)->sstrnleft -= (n); (p) += (n); } while (0)
-#define PSTBLOCK(psh)               ((psh)->stacknxt)
-char *pstgrabstr(struct shinstance *, char *); /* was: grabstackstr / grabstackblock*/
+#endif
 /** @} */
 

trunk/src/kash/parser.c

@@ -133 +133 @@
         union node *ret;
         int t;
+
         TRACE2((psh, "parsecmd(%d)\n", interact));
-
+#ifdef KASH_SEPARATE_PARSER_ALLOCATOR
+        pstackpush(psh);
+#endif
         psh->tokpushback = 0;
         psh->doprompt = interact;
@@ -1785 +1788 @@
 }
 
+static union node *copyparsetreeint(shinstance *psh, union node *src);
+
 /*
- * Helper to copyparsetree.
+ * Helper to copyparsetreeint.
  */
 static struct nodelist *
@@ -1799 +1804 @@
                         *ppnext = dst;
                         ppnext = &dst->next;
-                        dst->n = copyparsetree(psh, src->n);
+                        dst->n = copyparsetreeint(psh, src->n);
                         src = src->next;
                 }
@@ -1811 +1816 @@
  * Note! This could probably be generated from nodelist.
  */
-union node *
-copyparsetree(shinstance *psh, union node *src)
+static union node *
+copyparsetreeint(shinstance *psh, union node *src)
 {
         /** @todo Try avoid recursion for one of the sub-nodes, esp. when there
@@ -1827 +1832 @@
                                 ret = pstallocnode(psh, sizeof(src->nbinary));
                                 ret->nbinary.type = type;
-                                ret->nbinary.ch1  = copyparsetree(psh, src->nbinary.ch1);
-                                ret->nbinary.ch2  = copyparsetree(psh, src->nbinary.ch2);
+                                ret->nbinary.ch1  = copyparsetreeint(psh, src->nbinary.ch1);
+                                ret->nbinary.ch2  = copyparsetreeint(psh, src->nbinary.ch2);
                                 break;
 
@@ -1835 +1840 @@
                                 ret->ncmd.type     = NCMD;
                                 ret->ncmd.backgnd  = src->ncmd.backgnd;
-                                ret->ncmd.args     = copyparsetree(psh, src->ncmd.args);
-                                ret->ncmd.redirect = copyparsetree(psh, src->ncmd.redirect);
+                                ret->ncmd.args     = copyparsetreeint(psh, src->ncmd.args);
+                                ret->ncmd.redirect = copyparsetreeint(psh, src->ncmd.redirect);
                                 break;
 
@@ -1851 +1856 @@
                                 ret = pstallocnode(psh, sizeof(src->nredir));
                                 ret->nredir.type     = type;
-                                ret->nredir.n        = copyparsetree(psh, src->nredir.n);
-                                ret->nredir.redirect = copyparsetree(psh, src->nredir.redirect);
+                                ret->nredir.n        = copyparsetreeint(psh, src->nredir.n);
+                                ret->nredir.redirect = copyparsetreeint(psh, src->nredir.redirect);
                                 break;
 
@@ -1858 +1863 @@
                                 ret = pstallocnode(psh, sizeof(src->nif));
                                 ret->nif.type        = NIF;
-                                ret->nif.test        = copyparsetree(psh, src->nif.test);
-                                ret->nif.ifpart      = copyparsetree(psh, src->nif.ifpart);
-                                ret->nif.elsepart    = copyparsetree(psh, src->nif.elsepart);
+                                ret->nif.test        = copyparsetreeint(psh, src->nif.test);
+                                ret->nif.ifpart      = copyparsetreeint(psh, src->nif.ifpart);
+                                ret->nif.elsepart    = copyparsetreeint(psh, src->nif.elsepart);
                                 break;
 
@@ -1866 +1871 @@
                                 ret = pstallocnode(psh, sizeof(src->nfor));
                                 ret->nfor.type       = NFOR;
-                                ret->nfor.args       = copyparsetree(psh, src->nfor.args);
-                                ret->nfor.body       = copyparsetree(psh, src->nfor.body);
+                                ret->nfor.args       = copyparsetreeint(psh, src->nfor.args);
+                                ret->nfor.body       = copyparsetreeint(psh, src->nfor.body);
                                 ret->nfor.var        = pstsavestr(psh, src->nfor.var);
                                 break;
@@ -1874 +1879 @@
                                 ret = pstallocnode(psh, sizeof(src->ncase));
                                 ret->ncase.type      = NCASE;
-                                ret->ncase.expr      = copyparsetree(psh, src->ncase.expr);
-                                ret->ncase.cases     = copyparsetree(psh, src->ncase.cases);
+                                ret->ncase.expr      = copyparsetreeint(psh, src->ncase.expr);
+                                ret->ncase.cases     = copyparsetreeint(psh, src->ncase.cases);
                                 break;
 
@@ -1881 +1886 @@
                                 ret = pstallocnode(psh, sizeof(src->nclist));
                                 ret->nclist.type     = NCLIST;
-                                ret->nclist.next     = copyparsetree(psh, src->nclist.next);
-                                ret->nclist.pattern  = copyparsetree(psh, src->nclist.pattern);
-                                ret->nclist.body     = copyparsetree(psh, src->nclist.body);
+                                ret->nclist.next     = copyparsetreeint(psh, src->nclist.next);
+                                ret->nclist.pattern  = copyparsetreeint(psh, src->nclist.pattern);
+                                ret->nclist.body     = copyparsetreeint(psh, src->nclist.body);
                                 break;
 
@@ -1890 +1895 @@
                                 ret = pstallocnode(psh, sizeof(src->narg));
                                 ret->narg.type       = type;
-                                ret->narg.next       = copyparsetree(psh, src->narg.next);
+                                ret->narg.next       = copyparsetreeint(psh, src->narg.next);
                                 ret->narg.text       = pstsavestr(psh, src->narg.text);
                                 ret->narg.backquote  = copynodelist(psh, src->narg.backquote);
@@ -1903 +1908 @@
                                 ret->nfile.type      = type;
                                 ret->nfile.fd        = src->nfile.fd;
-                                ret->nfile.next      = copyparsetree(psh, src->nfile.next);
-                                ret->nfile.fname     = copyparsetree(psh, src->nfile.fname);
+                                ret->nfile.next      = copyparsetreeint(psh, src->nfile.next);
+                                ret->nfile.fname     = copyparsetreeint(psh, src->nfile.fname);
                                 break;
 
@@ -1912 +1917 @@
                                 ret->ndup.type       = type;
                                 ret->ndup.fd         = src->ndup.fd;
-                                ret->ndup.next       = copyparsetree(psh, src->ndup.next);
+                                ret->ndup.next       = copyparsetreeint(psh, src->ndup.next);
                                 ret->ndup.dupfd      = src->ndup.dupfd;
-                                ret->ndup.vname      = copyparsetree(psh, src->ndup.vname);
+                                ret->ndup.vname      = copyparsetreeint(psh, src->ndup.vname);
                                 break;
 
@@ -1922 +1927 @@
                                 ret->nhere.type      = type;
                                 ret->nhere.fd        = src->nhere.fd;
-                                ret->nhere.next      = copyparsetree(psh, src->nhere.next);
-                                ret->nhere.doc       = copyparsetree(psh, src->nhere.doc);
+                                ret->nhere.next      = copyparsetreeint(psh, src->nhere.next);
+                                ret->nhere.doc       = copyparsetreeint(psh, src->nhere.doc);
                                 break;
 
@@ -1929 +1934 @@
                                 ret = pstallocnode(psh, sizeof(src->nnot));
                                 ret->nnot.type      = NNOT;
-                                ret->nnot.com       = copyparsetree(psh, src->nnot.com);
+                                ret->nnot.com       = copyparsetreeint(psh, src->nnot.com);
                                 break;
 
@@ -1942 +1947 @@
 }
 
+union node *copyparsetree(shinstance *psh, union node *src)
+{
+#ifdef KASH_SEPARATE_PARSER_ALLOCATOR
+        pstackpush(psh);
+#endif
+        return copyparsetreeint(psh, src);
+}
+

trunk/src/kash/shinstance.h

@@ -84 +84 @@
         char space[MINSIZE];
 };
+
+#ifdef KASH_SEPARATE_PARSER_ALLOCATOR
+/** Parser stack allocator block.
+ * These are reference counted so they can be shared between the parent and
+ * child shells.  They are also using as an alternative to copying function
+ * definitions, here the final goal is to automatically emit separate
+ * pstack_blocks for function while parsing to make it more flexible. */
+typedef struct pstack_block {
+    /** Pointer to the next unallocated byte (= stacknxt). */
+    char               *nextbyte;
+    /** Number of bytes available in the current stack block (= stacknleft). */
+    size_t              avail;
+    /* Number of chars left for string data (PSTPUTC, PSTUPUTC, et al) (= sstrnleft). */
+    size_t              strleft;
+    /** Top of the allocation stack (nextbyte points within this). */
+    struct stack_block *top;
+    /** Size of the top stack element (user space only). */
+    size_t              topsize;
+    /** @name statistics
+     * @{ */
+    size_t              allocations;
+    size_t              bytesalloced;
+    size_t              nodesalloced;
+    size_t              entriesalloced;
+    size_t              strbytesalloced;
+    size_t              blocks;
+    size_t              fragmentation;
+    /** @} */
+    /** Reference counter. */
+    unsigned volatile   refs;
+    unsigned            padding;
+    /** The first stack block. */
+    struct stack_block  first;
+} pstack_block;
+#endif
 
 /* input.c */
@@ -275 +310 @@
     struct stack_block *stackp/* = &stackbase*/;
     struct stackmark   *markp;
+
+#ifdef KASH_SEPARATE_PARSER_ALLOCATOR
+    pstack_block       *curpstack;      /**< The pstack entry we're currently allocating from (NULL when not in parse.c). */
+    pstack_block      **pstack;         /**< Stack of parsed stuff. */
+    unsigned            pstacksize;     /**< Number of entries in pstack. */
+    unsigned            pstackalloced;  /**< The allocated size of pstack. */
+#endif
 
     /* myhistedit.h */

trunk/src/kash/shthread.h

@@ -64 +64 @@
     return _InterlockedIncrement((long *)valuep);
 #else
-    return __sync_fetch_and_add(valuep, 1);
+    return __sync_add_and_fetch(valuep, 1);
 #endif
 }
@@ -73 +73 @@
     return _InterlockedDecrement((long *)valuep);
 #else
-    return __sync_fetch_and_sub(valuep, 1);
+    return __sync_sub_and_fetch(valuep, 1);
 #endif
 }