Changeset 2900 for trunk/src/kmk

Timestamp:

Sep 9, 2016, 4:42:06 PM (9 years ago)

Author:

bird

Message:

output optimizations

Location:

trunk/src/kmk

Files:

• kmkbuiltin/cat.c (modified) (4 diffs)
• kmkbuiltin/printf.c (modified) (9 diffs)
• main.c (modified) (1 diff)

trunk/src/kmk/kmkbuiltin/cat.c

@@ -81 +81 @@
 
 
+#ifdef KBUILD_OS_WINDOWS
+/* This is a trick to seriuosly speed up console output windows. */
+# undef write
+# define write maybe_con_write
+extern ssize_t maybe_con_write(int, void const *, size_t);
+#endif
+
+
 int bflag, eflag, nflag, sflag, tflag, vflag;
 /*int rval;*/
@@ -120 +128 @@
 #ifdef kmk_builtin_cat /* kmk did this already. */
         setlocale(LC_CTYPE, "");
+#else
+        fflush(stdout);
 #endif
 
@@ -288 +298 @@
 raw_cat(int rfd)
 {
-        int off, wfd;
+        int off, wfd = fileno(stdout);
         ssize_t nr, nw;
         static size_t bsize;
@@ -298 +308 @@
                 if (fstat(wfd, &sbuf))
                         return err(1, "%s", filename);
-#ifdef _MSC_VER
-                bsize = 1024;
+#ifdef KBUILD_OS_WINDOWS
+                bsize = 16384;
 #else
                 bsize = MAX(sbuf.st_blksize, 1024);

trunk/src/kmk/kmkbuiltin/printf.c

@@ -76 +76 @@
 #include "../kmkbuiltin.h"
 
+#ifdef KBUILD_OS_WINDOWS
+/* This is a trick to speed up console output on windows. */
+# undef fwrite
+# define fwrite maybe_con_fwrite
+extern size_t maybe_con_fwrite(void const *, size_t, size_t, FILE *);
+#endif
+
 
 #ifdef __GNUC__
@@ -113 +120 @@
 static int       usage(FILE *);
 
+static int      flush_buffer(void);
 static void     b_count(int);
 static void     b_output(int);
@@ -126 +134 @@
 #include "../../bin/sh/bltin/bltin.h"
 #endif /* SHELL */
+
+/* Buffer the output because windows doesn't do line buffering of stdout. */
+static char     g_achBuf[256];
+static size_t   g_cchBuf;
 
 #define PF(f, func) { \
@@ -156 +168 @@
         int ch;
 
-        /* kmk: reset getopt and set progname */
+        /* kmk: reset getopt, set progname and reset buffer. */
         g_progname = argv[0];
         opterr = 1;
@@ -225 +237 @@
         rval = 0;
         gargv = NULL;
+        g_cchBuf = 0;
 
         format = *argv;
@@ -272 +285 @@
                         ch = *fmt;
                         if (!ch) {
+                                flush_buffer();
                                 warnx("missing format character");
                                 return (1);
@@ -354 +368 @@
                         }
                         default:
+                                flush_buffer();
                                 warnx("%s: invalid directive", start);
                                 return 1;
@@ -360 +375 @@
                         *fmt = nextch;
                         /* escape if a \c was encountered */
-                        if (rval & 0x100)
+                        if (rval & 0x100) {
+                                flush_buffer();
                                 return rval & ~0x100;
+                        }
                 }
         } while (gargv != argv && *gargv);
 
+        flush_buffer();
         return rval;
 }
+
 
 /* helper functions for conv_escape_str */
@@ -408 +427 @@
         }
 #endif
-        return putchar(ch);
+        /* Buffered output. */
+        if (g_cchBuf + 1 < sizeof(g_achBuf)) {
+                g_achBuf[g_cchBuf++] = ch;
+        } else {
+                int rc = flush_buffer();
+                g_achBuf[g_cchBuf++] = ch;
+                if (rc)
+                        return -1;
+        }
+        return 0;
 }
 
 static int wrap_printf(const char * fmt, ...)
 {
-        int rc;
+        ssize_t cchRet;
         va_list va;
-
+        char *pszTmp;
+
+        va_start(va, fmt);
+        cchRet = vasprintf(&pszTmp, fmt, va);
+        va_end(va);
+        if (cchRet >= 0) {
 #ifndef kmk_builtin_printf
-        if (g_o) {
-                char *str;
-
-                va_start(va, fmt);
-                rc = vasprintf(&str, fmt, va);
-                va_end(va);
-                if (rc >= 0) {
-                        g_o = variable_buffer_output(g_o, str, rc);
-                        free(str);
-                }
-                return rc;
-        }
-#endif
-
-        va_start(va, fmt);
-        rc = vprintf(fmt, va);
-        va_end(va);
-        return rc;
-}
+                if (g_o) {
+                        g_o = variable_buffer_output(g_o, pszTmp, cchRet);
+                } else
+#endif
+                {
+                        if (cchRet + g_cchBuf <= sizeof(g_achBuf)) {
+                                /* We've got space in the buffer. */
+                                memcpy(&g_achBuf[g_cchBuf], pszTmp, cchRet);
+                                g_cchBuf += cchRet;
+                        } else {
+                                /* Try write out complete lines. */
+                                const char *pszLeft = pszTmp;
+                                ssize_t     cchLeft = cchRet;
+
+                                while (cchLeft > 0) {
+                                        const char *pchNewLine = strchr(pszLeft, '\n');
+                                        ssize_t     cchLine    = pchNewLine ? pchNewLine - pszLeft + 1 : cchLeft;
+                                        if (g_cchBuf + cchLine <= sizeof(g_achBuf)) {
+                                                memcpy(&g_achBuf[g_cchBuf], pszLeft, cchLine);
+                                                g_cchBuf += cchLine;
+                                        } else {
+                                                if (flush_buffer() < 0) {
+                                                        return -1;
+                                                }
+                                                if (fwrite(pszLeft, cchLine, 1, stdout) < 1) {
+                                                        return -1;
+                                                }
+                                        }
+                                        pszLeft += cchLine;
+                                        cchLeft -= cchLine;
+                                }
+                        }
+                }
+                free(pszTmp);
+        }
+        return (int)cchRet;
+}
+
+/**
+ * Flushes the g_abBuf/g_cchBuf.
+ */
+static int flush_buffer(void)
+{
+    if (g_cchBuf > 0) {
+                ssize_t cchToWrite = g_cchBuf;
+                ssize_t cchWritten = fwrite(g_achBuf, 1, g_cchBuf, stdout);
+                g_cchBuf = 0;
+                if (cchWritten >= cchToWrite) {
+                        /* likely */
+                } else {
+                        ssize_t off = cchWritten;
+                        if (cchWritten >= 0) {
+                                off = cchWritten;
+                        } else if (errno == EINTR) {
+                                cchWritten = 0;
+                        } else {
+                                return -1;
+                        }
+
+                        while (off < cchToWrite) {
+                                cchWritten = fwrite(&g_achBuf[off], 1, cchToWrite - off, stdout);
+                                if (cchWritten > 0) {
+                                        off += cchWritten;
+                                } else if (errno == EINTR) {
+                                        /* nothing */
+                                } else {
+                                        return -1;
+                                }
+                        }
+                }
+    }
+    return 0;
+}
+
 
 

trunk/src/kmk/main.c

@@ -1380 +1380 @@
   char *windows32_path = NULL;
 
-#ifndef ELECTRIC_HEAP /* Drop this because it prevents JIT debugging. */
+# ifndef ELECTRIC_HEAP /* Drop this because it prevents JIT debugging. */
   SetUnhandledExceptionFilter(handle_runtime_exceptions);
-#endif /* !ELECTRIC_HEAP */
+# endif /* !ELECTRIC_HEAP */
 
   /* start off assuming we have no shell */