Process.inc revision c9413c745bec9707064211bc5fd02cdfb153c92d 
1//===- Win32/Process.cpp - Win32 Process Implementation ------- -*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file provides the Win32 specific implementation of the Process class.
11//
12//===----------------------------------------------------------------------===//
13
14#include "Windows.h"
15#include <psapi.h>
16#include <malloc.h>
17#include <io.h>
18#include <direct.h>
19
20#ifdef __MINGW32__
21 #if (HAVE_LIBPSAPI != 1)
22  #error "libpsapi.a should be present"
23 #endif
24#else
25 #pragma comment(lib, "psapi.lib")
26#endif
27
28//===----------------------------------------------------------------------===//
29//=== WARNING: Implementation here must contain only Win32 specific code
30//===          and must not be UNIX code
31//===----------------------------------------------------------------------===//
32
33#ifdef __MINGW32__
34// This ban should be lifted when MinGW 1.0+ has defined this value.
35#  define _HEAPOK (-2)
36#endif
37
38namespace llvm {
39using namespace sys;
40
41// This function retrieves the page size using GetSystemInfo and is present
42// solely so it can be called once in Process::GetPageSize to initialize the
43// static variable PageSize.
44inline unsigned GetPageSizeOnce() {
45  // NOTE: A 32-bit application running under WOW64 is supposed to use
46  // GetNativeSystemInfo.  However, this interface is not present prior
47  // to Windows XP so to use it requires dynamic linking.  It is not clear
48  // how this affects the reported page size, if at all.  One could argue
49  // that LLVM ought to run as 64-bits on a 64-bit system, anyway.
50  SYSTEM_INFO info;
51  GetSystemInfo(&info);
52  return static_cast<unsigned>(info.dwPageSize);
53}
54
55unsigned
56Process::GetPageSize() {
57  static const unsigned PageSize = GetPageSizeOnce();
58  return PageSize;
59}
60
61size_t
62Process::GetMallocUsage()
63{
64  _HEAPINFO hinfo;
65  hinfo._pentry = NULL;
66
67  size_t size = 0;
68
69  while (_heapwalk(&hinfo) == _HEAPOK)
70    size += hinfo._size;
71
72  return size;
73}
74
75size_t
76Process::GetTotalMemoryUsage()
77{
78  PROCESS_MEMORY_COUNTERS pmc;
79  GetProcessMemoryInfo(GetCurrentProcess(), &pmc, sizeof(pmc));
80  return pmc.PagefileUsage;
81}
82
83void
84Process::GetTimeUsage(
85  TimeValue& elapsed, TimeValue& user_time, TimeValue& sys_time)
86{
87  elapsed = TimeValue::now();
88
89  uint64_t ProcCreate, ProcExit, KernelTime, UserTime;
90  GetProcessTimes(GetCurrentProcess(), (FILETIME*)&ProcCreate,
91                  (FILETIME*)&ProcExit, (FILETIME*)&KernelTime,
92                  (FILETIME*)&UserTime);
93
94  // FILETIME's are # of 100 nanosecond ticks (1/10th of a microsecond)
95  user_time.seconds( UserTime / 10000000 );
96  user_time.nanoseconds( unsigned(UserTime % 10000000) * 100 );
97  sys_time.seconds( KernelTime / 10000000 );
98  sys_time.nanoseconds( unsigned(KernelTime % 10000000) * 100 );
99}
100
101int Process::GetCurrentUserId()
102{
103  return 65536;
104}
105
106int Process::GetCurrentGroupId()
107{
108  return 65536;
109}
110
111// Some LLVM programs such as bugpoint produce core files as a normal part of
112// their operation. To prevent the disk from filling up, this configuration item
113// does what's necessary to prevent their generation.
114void Process::PreventCoreFiles() {
115  // Windows doesn't do core files, but it does do modal pop-up message
116  // boxes.  As this method is used by bugpoint, preventing these pop-ups
117  // is the moral equivalent of suppressing core files.
118  SetErrorMode(SEM_FAILCRITICALERRORS |
119               SEM_NOGPFAULTERRORBOX |
120               SEM_NOOPENFILEERRORBOX);
121}
122
123bool Process::StandardInIsUserInput() {
124  return FileDescriptorIsDisplayed(0);
125}
126
127bool Process::StandardOutIsDisplayed() {
128  return FileDescriptorIsDisplayed(1);
129}
130
131bool Process::StandardErrIsDisplayed() {
132  return FileDescriptorIsDisplayed(2);
133}
134
135bool Process::FileDescriptorIsDisplayed(int fd) {
136  DWORD Mode;	// Unused
137  return (GetConsoleMode((HANDLE)_get_osfhandle(fd), &Mode) != 0);
138}
139
140unsigned Process::StandardOutColumns() {
141  unsigned Columns = 0;
142  CONSOLE_SCREEN_BUFFER_INFO csbi;
143  if (GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi))
144    Columns = csbi.dwSize.X;
145  return Columns;
146}
147
148unsigned Process::StandardErrColumns() {
149  unsigned Columns = 0;
150  CONSOLE_SCREEN_BUFFER_INFO csbi;
151  if (GetConsoleScreenBufferInfo(GetStdHandle(STD_ERROR_HANDLE), &csbi))
152    Columns = csbi.dwSize.X;
153  return Columns;
154}
155
156// It always has colors.
157bool Process::StandardErrHasColors() {
158  return StandardErrIsDisplayed();
159}
160
161bool Process::StandardOutHasColors() {
162  return StandardOutIsDisplayed();
163}
164
165namespace {
166class DefaultColors
167{
168  private:
169    WORD defaultColor;
170  public:
171    DefaultColors()
172     :defaultColor(GetCurrentColor()) {}
173    static unsigned GetCurrentColor() {
174      CONSOLE_SCREEN_BUFFER_INFO csbi;
175      if (GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi))
176        return csbi.wAttributes;
177      return 0;
178    }
179    WORD operator()() const { return defaultColor; }
180};
181
182DefaultColors defaultColors;
183}
184
185bool Process::ColorNeedsFlush() {
186  return true;
187}
188
189const char *Process::OutputBold(bool bg) {
190  WORD colors = DefaultColors::GetCurrentColor();
191  if (bg)
192    colors |= BACKGROUND_INTENSITY;
193  else
194    colors |= FOREGROUND_INTENSITY;
195  SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), colors);
196  return 0;
197}
198
199const char *Process::OutputColor(char code, bool bold, bool bg) {
200  WORD colors;
201  if (bg) {
202    colors = ((code&1) ? BACKGROUND_RED : 0) |
203      ((code&2) ? BACKGROUND_GREEN : 0 ) |
204      ((code&4) ? BACKGROUND_BLUE : 0);
205    if (bold)
206      colors |= BACKGROUND_INTENSITY;
207  } else {
208    colors = ((code&1) ? FOREGROUND_RED : 0) |
209      ((code&2) ? FOREGROUND_GREEN : 0 ) |
210      ((code&4) ? FOREGROUND_BLUE : 0);
211    if (bold)
212      colors |= FOREGROUND_INTENSITY;
213  }
214  SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), colors);
215  return 0;
216}
217
218const char *Process::ResetColor() {
219  SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), defaultColors());
220  return 0;
221}
222
223}
224