Merge tcmalloc r111 (perftools v. 1.8) with the chromium/ branch.

third_party/tcmalloc/chromium/src/memfs_malloc.cc

 // Copyright (c) 2007, 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 40 matching lines @@
 #include <sys/mman.h>                   // for mmap, MAP_FAILED, etc
 #include <sys/statfs.h>                 // for fstatfs, statfs
 #include <unistd.h>                     // for ftruncate, off_t, unlink
 #include <new>                          // for operator new
 #include <string>
 
 #include <google/malloc_extension.h>
 #include "base/basictypes.h"
 #include "base/googleinit.h"
 #include "base/sysinfo.h"
-#include "system-alloc.h"
 #include "internal_logging.h"
 
 using std::string;
 
 DEFINE_string(memfs_malloc_path, EnvToString("TCMALLOC_MEMFS_MALLOC_PATH", ""),
               "Path where hugetlbfs or tmpfs is mounted. The caller is "
               "responsible for ensuring that the path is unique and does "
               "not conflict with another process");
 DEFINE_int64(memfs_malloc_limit_mb,
              EnvToInt("TCMALLOC_MEMFS_LIMIT_MB", 0),
              "Limit total allocation size to the "
              "specified number of MiB.  0 == no limit.");
 DEFINE_bool(memfs_malloc_abort_on_fail,
             EnvToBool("TCMALLOC_MEMFS_ABORT_ON_FAIL", false),
             "abort() whenever memfs_malloc fails to satisfy an allocation "
             "for any reason.");
 DEFINE_bool(memfs_malloc_ignore_mmap_fail,
             EnvToBool("TCMALLOC_MEMFS_IGNORE_MMAP_FAIL", false),
             "Ignore failures from mmap");
 DEFINE_bool(memfs_malloc_map_private,
             EnvToBool("TCMALLOC_MEMFS_MAP_PRIVATE", false),
             "Use MAP_PRIVATE with mmap");
 
 // Hugetlbfs based allocator for tcmalloc
 class HugetlbSysAllocator: public SysAllocator {
 public:
   explicit HugetlbSysAllocator(SysAllocator* fallback)
-    : failed_(true),  // Unusable until FlagsInitialized() is called
+    : failed_(true),  // To disable allocator until Initialize() is called.
       big_page_size_(0),
       hugetlb_fd_(-1),
       hugetlb_base_(0),
       fallback_(fallback) {
   }
 
   void* Alloc(size_t size, size_t *actual_size, size_t alignment);
-
-  void FlagsInitialized();
+  bool Initialize();
 
   bool failed_;          // Whether failed to allocate memory.
+
 private:
   void* AllocInternal(size_t size, size_t *actual_size, size_t alignment);
 
   int64 big_page_size_;
   int hugetlb_fd_;       // file descriptor for hugetlb
   off_t hugetlb_base_;
 
   SysAllocator* fallback_;  // Default system allocator to fall back to.
 };
 static char hugetlb_space[sizeof(HugetlbSysAllocator)];
@@ skipping 94 matching lines @@
   ptr += adjust;
   hugetlb_base_ += (size + extra);
 
   if (actual_size) {
     *actual_size = size + extra - adjust;
   }
 
   return reinterpret_cast<void*>(ptr);
 }
 
-void HugetlbSysAllocator::FlagsInitialized() {
-  if (FLAGS_memfs_malloc_path.length()) {
-    char path[PATH_MAX];
-    int rc = snprintf(path, sizeof(path), "%s.XXXXXX",
-                      FLAGS_memfs_malloc_path.c_str());
-    if (rc < 0 || rc >= sizeof(path)) {
-      CRASH("XX fatal: memfs_malloc_path too long\n");
-    }
+bool HugetlbSysAllocator::Initialize() {
+  char path[PATH_MAX];
+  int rc = snprintf(path, sizeof(path), "%s.XXXXXX",
+                    FLAGS_memfs_malloc_path.c_str());
+  if (rc < 0 || rc >= sizeof(path)) {
+    CRASH("XX fatal: memfs_malloc_path too long\n");
+    return false;
+  }
 
-    int hugetlb_fd = mkstemp(path);
-    if (hugetlb_fd == -1) {
-      TCMalloc_MESSAGE(__FILE__, __LINE__,
-                       "warning: unable to create memfs_malloc_path %s: %s\n",
-                       path, strerror(errno));
-      return;
-    }
+  int hugetlb_fd = mkstemp(path);
+  if (hugetlb_fd == -1) {
+    TCMalloc_MESSAGE(__FILE__, __LINE__,
+                     "warning: unable to create memfs_malloc_path %s: %s\n",
+                     path, strerror(errno));
+    return false;
+  }
 
-    // Cleanup memory on process exit
-    if (unlink(path) == -1) {
-      CRASH("fatal: error unlinking memfs_malloc_path %s: %s\n",
-            path, strerror(errno));
-    }
+  // Cleanup memory on process exit
+  if (unlink(path) == -1) {
+    CRASH("fatal: error unlinking memfs_malloc_path %s: %s\n",
+          path, strerror(errno));
+    return false;
+  }
 
-    // Use fstatfs to figure out the default page size for memfs
-    struct statfs sfs;
-    if (fstatfs(hugetlb_fd, &sfs) == -1) {
-      CRASH("fatal: error fstatfs of memfs_malloc_path: %s\n",
-            strerror(errno));
-    }
-    int64 page_size = sfs.f_bsize;
+  // Use fstatfs to figure out the default page size for memfs
+  struct statfs sfs;
+  if (fstatfs(hugetlb_fd, &sfs) == -1) {
+    CRASH("fatal: error fstatfs of memfs_malloc_path: %s\n",
+          strerror(errno));
+    return false;
+  }
+  int64 page_size = sfs.f_bsize;
 
-    hugetlb_fd_ = hugetlb_fd;
-    big_page_size_ = page_size;
-    failed_ = false;
-  }
+  hugetlb_fd_ = hugetlb_fd;
+  big_page_size_ = page_size;
+  failed_ = false;
+  return true;
 }
 
-static void InitSystemAllocator() {
-  SysAllocator *alloc = MallocExtension::instance()->GetSystemAllocator();
-  HugetlbSysAllocator *hugetlb = new (hugetlb_space) HugetlbSysAllocator(alloc);
-  MallocExtension::instance()->SetSystemAllocator(hugetlb);
-}
-
-REGISTER_MODULE_INITIALIZER(memfs_malloc, { InitSystemAllocator(); });
+REGISTER_MODULE_INITIALIZER(memfs_malloc, {
+  if (FLAGS_memfs_malloc_path.length()) {
+    SysAllocator* alloc = MallocExtension::instance()->GetSystemAllocator();
+    HugetlbSysAllocator* hp = new (hugetlb_space) HugetlbSysAllocator(alloc);
+    if (hp->Initialize()) {
+      MallocExtension::instance()->SetSystemAllocator(hp);
+    }
+  }
+});
 
 #endif   /* ifdef __linux */