Merge google-perftools r109 (the current contents of third_party/tcmalloc/vendor)

third_party/tcmalloc/chromium/src/base/sysinfo.cc

 // Copyright (c) 2006, Google Inc.
 // All rights reserved.
 // 
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 // 
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
@@ skipping 38 matching lines @@
 #include <sys/sysctl.h>
 #elif defined __sun__         // Solaris
 #include <procfs.h>           // for, e.g., prmap_t
 #elif defined(PLATFORM_WINDOWS)
 #include <process.h>          // for getpid() (actually, _getpid())
 #include <shlwapi.h>          // for SHGetValueA()
 #include <tlhelp32.h>         // for Module32First()
 #endif
 #include "base/sysinfo.h"
 #include "base/commandlineflags.h"
+#include "base/dynamic_annotations.h"   // for RunningOnValgrind
 #include "base/logging.h"
 #include "base/cycleclock.h"
 
 #ifdef PLATFORM_WINDOWS
 #ifdef MODULEENTRY32
 // In a change from the usual W-A pattern, there is no A variant of
 // MODULEENTRY32.  Tlhelp32.h #defines the W variant, but not the A.
 // In unicode mode, tlhelp32.h #defines MODULEENTRY32 to be
 // MODULEENTRY32W.  These #undefs are the only way I see to get back
 // access to the original, ascii struct (and related functions).
@@ skipping 34 matching lines @@
 // It's not safe to call getenv() in the malloc hooks, because they
 // might be called extremely early, before libc is done setting up
 // correctly.  In particular, the thread library may not be done
 // setting up errno.  So instead, we use the built-in __environ array
 // if it exists, and otherwise read /proc/self/environ directly, using
 // system calls to read the file, and thus avoid setting errno.
 // /proc/self/environ has a limit of how much data it exports (around
 // 8K), so it's not an ideal solution.
 const char* GetenvBeforeMain(const char* name) {
 #if defined(HAVE___ENVIRON)   // if we have it, it's declared in unistd.h
-  const int namelen = strlen(name);
-  for (char** p = __environ; *p; p++) {
-    if (!memcmp(*p, name, namelen) && (*p)[namelen] == '=')  // it's a match
-      return *p + namelen+1;                                 // point after =
+  if (__environ) {            // can exist but be NULL, if statically linked
+    const int namelen = strlen(name);
+    for (char** p = __environ; *p; p++) {
+      if (!memcmp(*p, name, namelen) && (*p)[namelen] == '=')  // it's a match
+        return *p + namelen+1;                                 // point after =
+    }
+    return NULL;
   }
-  return NULL;
-#elif defined(PLATFORM_WINDOWS)
+#endif
+#if defined(PLATFORM_WINDOWS)
   // TODO(mbelshe) - repeated calls to this function will overwrite the
   // contents of the static buffer.
-  static char envbuf[1024];  // enough to hold any envvar we care about
-  if (!GetEnvironmentVariableA(name, envbuf, sizeof(envbuf)-1))
+  static char envvar_buf[1024];  // enough to hold any envvar we care about
+  if (!GetEnvironmentVariableA(name, envvar_buf, sizeof(envvar_buf)-1))
     return NULL;
-  return envbuf;
-#else
+  return envvar_buf;
+#endif
   // static is ok because this function should only be called before
   // main(), when we're single-threaded.
   static char envbuf[16<<10];
   if (*envbuf == '\0') {    // haven't read the environ yet
     int fd = safeopen("/proc/self/environ", O_RDONLY);
     // The -2 below guarantees the last two bytes of the buffer will be \0\0
     if (fd == -1 ||           // unable to open the file, fall back onto libc
         saferead(fd, envbuf, sizeof(envbuf) - 2) < 0) { // error reading file
       RAW_VLOG(1, "Unable to open /proc/self/environ, falling back "
                "on getenv(\"%s\"), which may not work", name);
       if (fd != -1) safeclose(fd);
       return getenv(name);
     }
     safeclose(fd);
   }
   const int namelen = strlen(name);
   const char* p = envbuf;
   while (*p != '\0') {    // will happen at the \0\0 that terminates the buffer
     // proc file has the format NAME=value\0NAME=value\0NAME=value\0...
     const char* endp = (char*)memchr(p, '\0', sizeof(envbuf) - (p - envbuf));
     if (endp == NULL)            // this entry isn't NUL terminated
       return NULL;
     else if (!memcmp(p, name, namelen) && p[namelen] == '=')    // it's a match
       return p + namelen+1;      // point after =
     p = endp + 1;
   }
   return NULL;                   // env var never found
-#endif
 }
 
 // This takes as an argument an environment-variable name (like
 // CPUPROFILE) whose value is supposed to be a file-path, and sets
 // path to that path, and returns true.  If the env var doesn't exist,
 // or is the empty string, leave path unchanged and returns false.
 // The reason this is non-trivial is that this function handles munged
 // pathnames.  Here's why:
 //
 // If we're a child process of the 'main' process, we can't just use
@@ skipping 34 matching lines @@
 // CyclesPerSecond()
 // NumCPUs()
 //    It's important this not call malloc! -- they may be called at
 //    global-construct time, before we've set up all our proper malloc
 //    hooks and such.
 // ----------------------------------------------------------------------
 
 static double cpuinfo_cycles_per_second = 1.0;  // 0.0 might be dangerous
 static int cpuinfo_num_cpus = 1;  // Conservative guess
 
-static void SleepForMilliseconds(int milliseconds) {
+void SleepForMilliseconds(int milliseconds) {
 #ifdef PLATFORM_WINDOWS
   _sleep(milliseconds);   // Windows's _sleep takes milliseconds argument
 #else
   // Sleep for a few milliseconds
   struct timespec sleep_time;
   sleep_time.tv_sec = milliseconds / 1000;
   sleep_time.tv_nsec = (milliseconds % 1000) * 1000000;
   while (nanosleep(&sleep_time, &sleep_time) != 0 && errno == EINTR)
     ;  // Ignore signals and wait for the full interval to elapse.
 #endif
 }
 
 // Helper function estimates cycles/sec by observing cycles elapsed during
 // sleep(). Using small sleep time decreases accuracy significantly.
 static int64 EstimateCyclesPerSecond(const int estimate_time_ms) {
   assert(estimate_time_ms > 0);
   if (estimate_time_ms <= 0)
     return 1;
   double multiplier = 1000.0 / (double)estimate_time_ms;  // scale by this much
 
   const int64 start_ticks = CycleClock::Now();
   SleepForMilliseconds(estimate_time_ms);
   const int64 guess = int64(multiplier * (CycleClock::Now() - start_ticks));
   return guess;
 }
 
+// ReadIntFromFile is only called on linux and cygwin platforms.
+#if defined(__linux__) || defined(__CYGWIN__) || defined(__CYGWIN32__)
+// Helper function for reading an int from a file. Returns true if successful
+// and the memory location pointed to by value is set to the value read.
+static bool ReadIntFromFile(const char *file, int *value) {
+  bool ret = false;
+  int fd = open(file, O_RDONLY);
+  if (fd != -1) {
+    char line[1024];
+    char* err;
+    memset(line, '\0', sizeof(line));
+    read(fd, line, sizeof(line) - 1);
+    const int temp_value = strtol(line, &err, 10);
+    if (line[0] != '\0' && (*err == '\n' || *err == '\0')) {
+      *value = temp_value;
+      ret = true;
+    }
+    close(fd);
+  }
+  return ret;
+}
+#endif
+
 // WARNING: logging calls back to InitializeSystemInfo() so it must
 // not invoke any logging code.  Also, InitializeSystemInfo() can be
 // called before main() -- in fact it *must* be since already_called
 // isn't protected -- before malloc hooks are properly set up, so
 // we make an effort not to call any routines which might allocate
 // memory.
 
 static void InitializeSystemInfo() {
   static bool already_called = false;   // safe if we run before threads
   if (already_called)  return;
   already_called = true;
 
-  // I put in a never-called reference to EstimateCyclesPerSecond() here
-  // to silence the compiler for OS's that don't need it
-  if (0) EstimateCyclesPerSecond(0);
+  bool saw_mhz = false;
+
+  if (RunningOnValgrind()) {
+    // Valgrind may slow the progress of time artificially (--scale-time=N
+    // option). We thus can't rely on CPU Mhz info stored in /sys or /proc
+    // files. Thus, actually measure the cps.
+    cpuinfo_cycles_per_second = EstimateCyclesPerSecond(100);
+    saw_mhz = true;
+  }
 
 #if defined(__linux__) || defined(__CYGWIN__) || defined(__CYGWIN32__)
   char line[1024];
   char* err;
+  int freq;
+
+  // If the kernel is exporting the tsc frequency use that. There are issues
+  // where cpuinfo_max_freq cannot be relied on because the BIOS may be
+  // exporintg an invalid p-state (on x86) or p-states may be used to put the
+  // processor in a new mode (turbo mode). Essentially, those frequencies
+  // cannot always be relied upon. The same reasons apply to /proc/cpuinfo as
+  // well.
+  if (!saw_mhz &&
+      ReadIntFromFile("/sys/devices/system/cpu/cpu0/tsc_freq_khz", &freq)) {
+      // The value is in kHz (as the file name suggests).  For example, on a
+      // 2GHz warpstation, the file contains the value "2000000".
+      cpuinfo_cycles_per_second = freq * 1000.0;
+      saw_mhz = true;
+  }
 
   // If CPU scaling is in effect, we want to use the *maximum* frequency,
   // not whatever CPU speed some random processor happens to be using now.
-  bool saw_mhz = false;
-  const char* pname0 = "/sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq";
-  int fd0 = open(pname0, O_RDONLY);
-  if (fd0 != -1) {
-    memset(line, '\0', sizeof(line));
-    read(fd0, line, sizeof(line));
-    const int max_freq = strtol(line, &err, 10);
-    if (line[0] != '\0' && (*err == '\n' || *err == '\0')) {
-      // The value is in kHz.  For example, on a 2GHz machine, the file
-      // contains the value "2000000".  Historically this file contained no
-      // newline, but at some point the kernel started appending a newline.
-      cpuinfo_cycles_per_second = max_freq * 1000.0;
-      saw_mhz = true;
-    }
-    close(fd0);
+  if (!saw_mhz &&
+      ReadIntFromFile("/sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq",
+                      &freq)) {
+    // The value is in kHz.  For example, on a 2GHz machine, the file
+    // contains the value "2000000".
+    cpuinfo_cycles_per_second = freq * 1000.0;
+    saw_mhz = true;
   }
 
   // Read /proc/cpuinfo for other values, and if there is no cpuinfo_max_freq.
   const char* pname = "/proc/cpuinfo";
   int fd = open(pname, O_RDONLY);
   if (fd == -1) {
     perror(pname);
-    cpuinfo_cycles_per_second = EstimateCyclesPerSecond(1000);
+    if (!saw_mhz) {
+      cpuinfo_cycles_per_second = EstimateCyclesPerSecond(1000);
+    }
     return;          // TODO: use generic tester instead?
   }
 
   double bogo_clock = 1.0;
+  bool saw_bogo = false;
   int num_cpus = 0;
   line[0] = line[1] = '\0';
   int chars_read = 0;
   do {   // we'll exit when the last read didn't read anything
     // Move the next line to the beginning of the buffer
     const int oldlinelen = strlen(line);
     if (sizeof(line) == oldlinelen + 1)    // oldlinelen took up entire line
       line[0] = '\0';
     else                                   // still other lines left to save
       memmove(line, line + oldlinelen+1, sizeof(line) - (oldlinelen+1));
     // Terminate the new line, reading more if we can't find the newline
     char* newline = strchr(line, '\n');
     if (newline == NULL) {
       const int linelen = strlen(line);
       const int bytes_to_read = sizeof(line)-1 - linelen;
       assert(bytes_to_read > 0);  // because the memmove recovered >=1 bytes
       chars_read = read(fd, line + linelen, bytes_to_read);
       line[linelen + chars_read] = '\0';
       newline = strchr(line, '\n');
     }
     if (newline != NULL)
       *newline = '\0';
 
-    if (!saw_mhz && strncmp(line, "cpu MHz", sizeof("cpu MHz")-1) == 0) {
+    // When parsing the "cpu MHz" and "bogomips" (fallback) entries, we only
+    // accept postive values. Some environments (virtual machines) report zero,
+    // which would cause infinite looping in WallTime_Init.
+    if (!saw_mhz && strncasecmp(line, "cpu MHz", sizeof("cpu MHz")-1) == 0) {
       const char* freqstr = strchr(line, ':');
       if (freqstr) {
         cpuinfo_cycles_per_second = strtod(freqstr+1, &err) * 1000000.0;
-        if (freqstr[1] != '\0' && *err == '\0')
+        if (freqstr[1] != '\0' && *err == '\0' && cpuinfo_cycles_per_second > 0)
           saw_mhz = true;
       }
-    } else if (strncmp(line, "bogomips", sizeof("bogomips")-1) == 0) {
+    } else if (strncasecmp(line, "bogomips", sizeof("bogomips")-1) == 0) {
       const char* freqstr = strchr(line, ':');
-      if (freqstr)
+      if (freqstr) {
         bogo_clock = strtod(freqstr+1, &err) * 1000000.0;
-      if (freqstr == NULL || freqstr[1] == '\0' || *err != '\0')
-        bogo_clock = 1.0;
-    } else if (strncmp(line, "processor", sizeof("processor")-1) == 0) {
+        if (freqstr[1] != '\0' && *err == '\0' && bogo_clock > 0)
+          saw_bogo = true;
+      }
+    } else if (strncasecmp(line, "processor", sizeof("processor")-1) == 0) {
       num_cpus++;  // count up every time we see an "processor :" entry
     }
   } while (chars_read > 0);
   close(fd);
 
   if (!saw_mhz) {
-    // If we didn't find anything better, we'll use bogomips, but
-    // we're not happy about it.
-    cpuinfo_cycles_per_second = bogo_clock;
+    if (saw_bogo) {
+      // If we didn't find anything better, we'll use bogomips, but
+      // we're not happy about it.
+      cpuinfo_cycles_per_second = bogo_clock;
+    } else {
+      // If we don't even have bogomips, we'll use the slow estimation.
+      cpuinfo_cycles_per_second = EstimateCyclesPerSecond(1000);
+    }
   }
   if (cpuinfo_cycles_per_second == 0.0) {
     cpuinfo_cycles_per_second = 1.0;   // maybe unnecessary, but safe
   }
   if (num_cpus > 0) {
     cpuinfo_num_cpus = num_cpus;
   }
 
 #elif defined __FreeBSD__
   // For this sysctl to work, the machine must be configured without
@@ skipping 110 matching lines @@
 #endif  // else OS_LINUX
 }
 
 // ----------------------------------------------------------------------
 
 #if defined __linux__ || defined __FreeBSD__ || defined __sun__ || defined __CYGWIN__ || defined __CYGWIN32__
 static void ConstructFilename(const char* spec, pid_t pid,
                               char* buf, int buf_size) {
   CHECK_LT(snprintf(buf, buf_size,
                     spec,
-                    pid ? pid : getpid()), buf_size);
+                    static_cast<int>(pid ? pid : getpid())), buf_size);
 }
 #endif
 
 // A templatized helper function instantiated for Mach (OS X) only.
 // It can handle finding info for both 32 bits and 64 bits.
 // Returns true if it successfully handled the hdr, false else.
 #ifdef __MACH__          // Mac OS X, almost certainly
 template<uint32_t kMagic, uint32_t kLCSegment,
          typename MachHeader, typename SegmentCommand>
 static bool NextExtMachHelper(const mach_header* hdr,
@@ skipping 292 matching lines @@
     // Best-effort attempt to get the inode from the filename.  I think the
     // two middle ints are major and minor device numbers, but I'm not sure.
     sscanf(mapinfo->pr_mapname, "ufs.%*d.%*d.%ld", &inode_from_mapname);
 
     if (pid_ == 0) {
       CHECK_LT(snprintf(object_path.buf_, Buffer::kBufSize,
                         "/proc/self/path/%s", mapinfo->pr_mapname),
                Buffer::kBufSize);
     } else {
       CHECK_LT(snprintf(object_path.buf_, Buffer::kBufSize,
-                        "/proc/%d/path/%s", pid_, mapinfo->pr_mapname),
+                        "/proc/%d/path/%s",
+                        static_cast<int>(pid_), mapinfo->pr_mapname),
                Buffer::kBufSize);
     }
     ssize_t len = readlink(object_path.buf_, current_filename_, PATH_MAX);
     CHECK_LT(len, PATH_MAX);
     if (len < 0)
       len = 0;
     current_filename_[len] = '\0';
 
     if (start) *start = mapinfo->pr_vaddr;
     if (end) *end = mapinfo->pr_vaddr + mapinfo->pr_size;
@@ skipping 90 matching lines @@
                           start, end, r,w,x,p, offset,
                           static_cast<int>(dev/256), static_cast<int>(dev%256),
                           inode, filename);
   return (rc < 0 || rc >= bufsize) ? 0 : rc;
 }
 
 namespace tcmalloc {
 
 // Helper to add the list of mapped shared libraries to a profile.
 // Fill formatted "/proc/self/maps" contents into buffer 'buf' of size 'size'
-// and return the actual size occupied in 'buf'.
+// and return the actual size occupied in 'buf'.  We fill wrote_all to true
+// if we successfully wrote all proc lines to buf, false else.
 // We do not provision for 0-terminating 'buf'.
-int FillProcSelfMaps(char buf[], int size) {
+int FillProcSelfMaps(char buf[], int size, bool* wrote_all) {
   ProcMapsIterator::Buffer iterbuf;
   ProcMapsIterator it(0, &iterbuf);   // 0 means "current pid"
 
   uint64 start, end, offset;
   int64 inode;
   char *flags, *filename;
   int bytes_written = 0;
+  *wrote_all = true;
   while (it.Next(&start, &end, &flags, &offset, &inode, &filename)) {
-    bytes_written += it.FormatLine(buf + bytes_written, size - bytes_written,
-                                   start, end, flags, offset, inode, filename,
-                                   0);
+    const int line_length = it.FormatLine(buf + bytes_written,
+                                          size - bytes_written,
+                                          start, end, flags, offset,
+                                          inode, filename, 0);
+    if (line_length == 0)
+      *wrote_all = false;     // failed to write this line out
+    else
+      bytes_written += line_length;
+
   }
   return bytes_written;
 }
 
 // Dump the same data as FillProcSelfMaps reads to fd.
 // It seems easier to repeat parts of FillProcSelfMaps here than to
 // reuse it via a call.
 void DumpProcSelfMaps(RawFD fd) {
   ProcMapsIterator::Buffer iterbuf;
   ProcMapsIterator it(0, &iterbuf);   // 0 means "current pid"
 
   uint64 start, end, offset;
   int64 inode;
   char *flags, *filename;
   ProcMapsIterator::Buffer linebuf;
   while (it.Next(&start, &end, &flags, &offset, &inode, &filename)) {
     int written = it.FormatLine(linebuf.buf_, sizeof(linebuf.buf_),
                                 start, end, flags, offset, inode, filename,
                                 0);
     RawWrite(fd, linebuf.buf_, written);
   }
 }
 
 }  // namespace tcmalloc