Keep up with lib/System changes

llvm-svn: 19057

lib/System/Win32/Process.cpp

@@ -12,6 +12,10 @@
 //===----------------------------------------------------------------------===//
 
 #include "Win32.h"
+#include <psapi.h>
+#include <malloc.h>
+
+#pragma comment(lib, "psapi.lib")
 
 //===----------------------------------------------------------------------===//
 //=== WARNING: Implementation here must contain only Win32 specific code 
@@ -41,28 +45,26 @@ Process::GetPageSize() {
   return PageSize;
 }
 
-void* 
 uint64_t 
 Process::GetMallocUsage()
 {
-#ifdef HAVE_MALLINFO
-  struct mallinfo mi = ::mallinfo();
-  return mi.uordblks;
-#warning Cannot get malloc info on this platform
-  return 0;
-#endif
+  _HEAPINFO hinfo;
+  hinfo._pentry = NULL;
+
+  size_t size = 0;
+
+  while (_heapwalk(&hinfo) == _HEAPOK)
+    size += hinfo._size;
+
+  return size;
 }
 
 uint64_t
 Process::GetTotalMemoryUsage()
 {
-#ifdef HAVE_MALLINFO
-  struct mallinfo mi = ::mallinfo();
-  return mi.uordblks + mi.hblkhd
-#else
-#warning Cannot get total memory size on this platform
-  return 0;
-#endif
+  PROCESS_MEMORY_COUNTERS pmc;
+  GetProcessMemoryInfo(GetCurrentProcess(), &pmc, sizeof(pmc));
+  return pmc.PagefileUsage;
 }
 
 void
@@ -71,17 +73,16 @@ Process::GetTimeUsage(
 {
   elapsed = TimeValue::now();
 
-  unsigned __int64 ProcCreate, ProcExit, KernelTime, UserTime;
+  uint64_t ProcCreate, ProcExit, KernelTime, UserTime;
   GetProcessTimes(GetCurrentProcess(), (FILETIME*)&ProcCreate, 
-                  (FILETIME*)&ProcExit, (FILETIME*)&KernelTime, 
-                  (FILETIME*)&UserTime
-  );
+                  (FILETIME*)&ProcExit, (FILETIME*)&KernelTime,
+                  (FILETIME*)&UserTime);
 
   // FILETIME's are # of 100 nanosecond ticks (1/10th of a microsecond)
   user_time.seconds( UserTime / 10000000 );
-  user_time.nanoseconds( (UserTime % 10000000) * 100 );
+  user_time.nanoseconds( unsigned(UserTime % 10000000) * 100 );
   sys_time.seconds( KernelTime / 10000000 );
-  user_time.nanoseconds( (UserTime % 10000000) * 100 );
+  sys_time.nanoseconds( unsigned(KernelTime % 10000000) * 100 );
 }
 
 }

lib/System/Win32/Program.cpp

@@ -69,8 +69,10 @@ Program::FindProgramByName(const std::string& progName) {
 //
 int 
 Program::ExecuteAndWait(const Path& path, 
-                        const std::vector<std::string>& args,
-                        const char** envp) {
+                        const char** args,
+                        const char** envp,
+                        const Path** redirects,
+                        unsigned secondsToWait) {
   if (!path.executable())
     throw path.toString() + " is not executable"; 
 
@@ -84,9 +86,9 @@ Program::ExecuteAndWait(const Path& path,
   if (progname.find(' ') != std::string::npos)
     len += 2;
 
-  for (unsigned i = 0; i < args.size(); i++) {
-    len += args[i].length() + 1;
-    if (args[i].find(' ') != std::string::npos)
+  for (unsigned i = 0; args[i]; i++) {
+    len += strlen(args[i]) + 1;
+    if (strchr(args[i], ' '))
       len += 2;
   }
 
@@ -103,13 +105,14 @@ Program::ExecuteAndWait(const Path& path,
     *p++ = '"';
   *p++ = ' ';
 
-  for (unsigned i = 0; i < args.size(); i++) {
-    const std::string& arg = args[i];
-    needsQuoting = arg.find(' ') != std::string::npos;
+  for (unsigned i = 0; args[i]; i++) {
+    const char *arg = args[i];
+	size_t len = strlen(arg);
+    needsQuoting = strchr(arg, ' ') != 0;
     if (needsQuoting)
       *p++ = '"';
-    memcpy(p, arg.c_str(), arg.length());
-    p += arg.length();
+    memcpy(p, arg, len);
+    p += len;
     if (needsQuoting)
       *p++ = '"';
     *p++ = ' ';
@@ -122,6 +125,8 @@ Program::ExecuteAndWait(const Path& path,
   memset(&si, 0, sizeof(si));
   si.cb = sizeof(si);
 
+  // TODO: do replacement of standard input/output/error handles.
+
   PROCESS_INFORMATION pi;
   memset(&pi, 0, sizeof(pi));
 
@@ -133,7 +138,17 @@ Program::ExecuteAndWait(const Path& path,
   }
 
   // Wait for it to terminate.
-  WaitForSingleObject(pi.hProcess, INFINITE);
+  DWORD millisecondsToWait = INFINITE;
+  if (secondsToWait > 0)
+    millisecondsToWait = secondsToWait * 1000;
+
+  if (WaitForSingleObject(pi.hProcess, millisecondsToWait) == WAIT_TIMEOUT) {
+    if (!TerminateProcess(pi.hProcess, 1)) {
+      ThrowError(std::string("Failed to terminate timed-out program '") + 
+                 path.toString() + "'");
+    }
+    WaitForSingleObject(pi.hProcess, INFINITE);
+  }
   
   // Get its exit status.
   DWORD status;