Changeset 3159 for trunk/src/kmk/w32

Timestamp:

Mar 19, 2018, 2:37:13 PM (7 years ago)

Author:

bird

Message:

kmk/win: Some fixes & docs.

Location:

trunk/src/kmk/w32

Files:

• winchildren.c (modified) (24 diffs)
• winchildren.h (modified) (1 diff)

trunk/src/kmk/w32/winchildren.c

@@ -25 +25 @@
 
 /* No GNU coding style here atm, convert if upstreamed. */
+
+/** @page pg_win_children   Windows child process creation and managment
+ *
+ * This new implementation aims at addressing the following:
+ *
+ *      1. Speed up process creation by doing the expensive CreateProcess call
+ *         in a worker thread.
+ *
+ *      2. No 64 process limit imposed by WaitForMultipleObjects.
+ *
+ *      3. Better distribute jobs among processor groups.
+ *
+ *      4. Offloading more expensive kmkbuiltin operations to worker threads,
+ *         making the main thread focus on managing child processes.
+ *
+ *      5. Output synchronization using reusable pipes [not yet implemented].
+ *
+ *
+ * To be quite honest, the first item (CreateProcess expense) didn't occur to me
+ * at first and was more of a sideeffect discovered along the way.  A test
+ * rebuilding IPRT went from 4m52s to 3m19s on a 8 thread system.
+ *
+ * The 2nd and 3rd goals are related to newer build servers that have lots of
+ * CPU threads and various Windows NT (aka NT OS/2 at the time) design choices
+ * made in the late 1980ies.
+ *
+ * WaitForMultipleObjects does not support waiting for more than 64 objects,
+ * unlike poll and select.  This is just something everyone ends up having to
+ * work around in the end.
+ *
+ * Affinity masks are uintptr_t sized, so 64-bit hosts can only manage 64
+ * processors and 32-bit only 32.  Workaround was introduced with Windows 7
+ * (IIRC) and is called processor groups.  The CPU threads are grouped into 1 or
+ * more groups of up to 64 processors.  Processes are generally scheduled to a
+ * signle processor group at first, but threads may be changed to be scheduled
+ * on different groups.  This code will try distribute children evenly among the
+ * processor groups, using a very simple algorithm (see details in code).
+ *
+ */
+
 
 /*********************************************************************************************************************************
@@ -66 +106 @@
     /** Normal child process. */
     WINCHILDTYPE_PROCESS,
+#ifdef KMK
     /** kmkbuiltin command. */
     WINCHILDTYPE_BUILTIN,
@@ -72 +113 @@
     /** kmk_redirect job. */
     WINCHILDTYPE_REDIRECT,
+#endif
     /** End of valid child types. */
     WINCHILDTYPE_END
@@ -247 +289 @@
 static unsigned volatile    g_idxLastChildcareWorker = 0;
 
+/** Temporary RW lock for serializing kmkbuiltin_redirect and CreateProcess. */
+static SRWLOCK              g_RWLock;
 
 
@@ -320 +364 @@
         }
     }
+
+    /* Temporary: */
+    InitializeSRWLock(&g_RWLock);
 }
 
@@ -1205 +1252 @@
     if (rc == 0)
     {
+        AcquireSRWLockShared(&g_RWLock); /* temporary */
+
         /*
          * Populate startup info.
@@ -1248 +1297 @@
                               TRUE /*fInheritHandles*/, fFlags, pwszzEnvironment, NULL /*pwsz*/, &StartupInfo, &ProcInfo);
         rc = GetLastError();
+        ReleaseSRWLockShared(&g_RWLock); /* temporary */
         if (fRet)
         {
@@ -1315 +1365 @@
 }
 
+#ifdef KMK
+
 /**
  * Childcare worker: handle builtin command.
@@ -1366 +1418 @@
     mkWinChildcareWorkerWaitForProcess(pWorker, pChild, pChild->u.Redirect.hProcess);
 }
+
+#endif /* KMK */
 
 /**
@@ -1435 +1489 @@
                         mkWinChildcareWorkerThreadHandleProcess(pWorker, pChild);
                         break;
+#ifdef KMK
                     case WINCHILDTYPE_BUILTIN:
                         mkWinChildcareWorkerThreadHandleBuiltin(pWorker, pChild);
@@ -1444 +1499 @@
                         mkWinChildcareWorkerThreadHandleRedirect(pWorker, pChild);
                         break;
+#endif
+                    default:
+                        assert(0);
                 }
 
@@ -1638 +1696 @@
         }
 
+#ifdef KMK
+
         case WINCHILDTYPE_BUILTIN:
             assert(0);
@@ -1657 +1717 @@
             }
             break;
+
+#endif /* KMK */
+
+        default:
+            assert(0);
     }
 
@@ -1890 +1955 @@
 }
 
+#ifdef KMK
+
 /**
  * Interface used by kSubmit.c for registering stuff to wait on.
@@ -1919 +1986 @@
     return mkWinChildPushToCareWorker(pChild, pPid);
 }
+
+#endif /* CONFIG_NEW_WIN_CHILDREN */
 
 /**
@@ -1943 +2012 @@
                     pChild->iSignal = iSignal;
                     break;
+
+#ifdef KMK
 
                 case WINCHILDTYPE_SUBMIT:
@@ -1958 +2029 @@
                 case WINCHILDTYPE_BUILTIN:
                     break;
+
+#endif /* KMK */
+
+                default:
+                    assert(0);
             }
         }
@@ -2015 +2091 @@
         case WINCHILDTYPE_PROCESS:
             break;
+#ifdef KMK
         case WINCHILDTYPE_BUILTIN:
             break;
@@ -2021 +2098 @@
         case WINCHILDTYPE_REDIRECT:
             break;
+#endif /* KMK */
         default:
             assert(0);
     }
     mkWinChildDelete(pChild);
+
+#ifdef KMK
+    /* Flush the volatile directory cache. */
+    dir_cache_invalid_after_job();
+#endif
     return 0;
 }
 
-
+/**
+ * Get the child completed event handle.
+ *
+ * Needed when w32os.c is waiting for a job token to become available, given
+ * that completed children is the typical source of these tokens (esp. for kmk).
+ *
+ * @returns Event handle.
+ */
 intptr_t MkWinChildGetCompleteEventHandle(void)
 {
     return (intptr_t)g_hEvtWaitChildren;
 }
-
 
 /**
@@ -2053 +2142 @@
     int                     rc;
 
-/** @todo this code needs testing... */
-
     /*
      * Get the executable name.
@@ -2084 +2171 @@
     GetStartupInfoW(&StartupInfo);
     if (!CreateProcessW(wszImageName, pwszCommandLine, NULL /*pProcSecAttr*/, NULL /*pThreadSecAttr*/,
-                        TRUE /*fInheritHandles*/, 0 /*fFlags*/, pwszzEnvironment, NULL /*pwsz*/,
+                        TRUE /*fInheritHandles*/, CREATE_UNICODE_ENVIRONMENT, pwszzEnvironment, NULL /*pwsz*/,
                         &StartupInfo, &ProcInfo))
         ON(fatal, NILF, _("MkWinChildReExecMake: CreateProcessW failed: %u\n"), GetLastError());
@@ -2103 +2190 @@
         if (dwStatus == WAIT_OBJECT_0)
         {
-            if (GetExitCodeProcess(ProcInfo.hProcess, &dwExitCode))
+            if (!GetExitCodeProcess(ProcInfo.hProcess, &dwExitCode))
+            {
                 ON(fatal, NILF, _("MkWinChildReExecMake: GetExitCodeProcess failed: %u\n"), GetLastError());
-            else
                 dwExitCode = -2222;
+            }
         }
         else if (dwStatus)
@@ -2117 +2205 @@
 }
 
-
+/** Temporary serialization with kmkbuiltin_redirect. */
+void MkWinChildExclusiveAcquire(void)
+{
+    AcquireSRWLockExclusive(&g_RWLock);
+}
+
+/** Temporary serialization with kmkbuiltin_redirect. */
+void MkWinChildExclusiveRelease(void)
+{
+    ReleaseSRWLockExclusive(&g_RWLock);
+}
+
+/**
+ * Implementation of the CLOSE_ON_EXEC macro.
+ *
+ * @returns errno value.
+ * @param   fd          The file descriptor to hide from children.
+ */
 int MkWinChildUnrelatedCloseOnExec(int fd)
 {
@@ -2128 +2233 @@
                 return 0;
         }
+        return errno;
     }
     return EINVAL;
 }
 
-
-

trunk/src/kmk/w32/winchildren.h

@@ -36 +36 @@
 int     MkWinChildKill(pid_t pid, int iSignal, struct child *pMkChild);
 int     MkWinChildWait(int fBlock, pid_t *pPid, int *piExitCode, int *piSignal, int *pfCoreDumped, struct child **ppMkChild);
+void    MkWinChildExclusiveAcquire(void);
+void    MkWinChildExclusiveRelease(void);
 
 #undef  CLOSE_ON_EXEC