Type profiler by intercepting 'new' and 'delete' expressions.

base/process_util_posix.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <dirent.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <sys/resource.h>
@@ skipping 15 matching lines @@
 #include "base/files/dir_reader_posix.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/process_util.h"
 #include "base/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread_restrictions.h"
 
+#ifdef USE_ALLOCATED_TYPE
+#include "base/allocator/allocated_type_tcmalloc.h"
+#endif
+
 #if defined(OS_CHROMEOS)
 #include <sys/ioctl.h>
 #endif
 
 #if defined(OS_FREEBSD)
 #include <sys/event.h>
 #include <sys/ucontext.h>
 #endif
 
 #if defined(OS_MACOSX)
@@ skipping 586 matching lines @@
 
     if (options.new_process_group) {
       // Instead of inheriting the process group ID of the parent, the child
       // starts off a new process group with pgid equal to its process ID.
       if (setpgid(0, 0) < 0) {
         RAW_LOG(ERROR, "setpgid failed");
         _exit(127);
       }
     }
 
+#ifdef USE_ALLOCATED_TYPE
+    // Stop interceptors for allocated type to avoid using locks.
+    StopAllocatedTypeIntercept();
+#endif

[Dai Mikurube (NOT FULLTIME), 2012/08/07 11:35:55]

Note: I kept #ifdef here since the file has just two
StopAllocatedTypeIntercept() calls.

For only two #ifdefs, they make the code easier to read since readers can skip
the #ifdef blocks easily.

[jar (doing other things), 2012/08/07 17:07:34]

Readers can't skip the ifdef without trying to figure out what it is, and what
it does.  As noted, these ifdefs are details about your implementation, and
probably should not be in this file.

On 2012/08/07 11:35:55, Dai Mikurube wrote:

[Dai Mikurube (NOT FULLTIME), 2012/08/08 06:16:23]

Ok, done in base/allocator/allocated_type_tcmalloc.cc.

On 2012/08/07 17:07:34, jar wrote:

     if (options.maximize_rlimits) {
       // Some resource limits need to be maximal in this child.
       std::set<int>::const_iterator resource;
       for (resource = options.maximize_rlimits->begin();
            resource != options.maximize_rlimits->end();
            ++resource) {
         struct rlimit limit;
         if (getrlimit(*resource, &limit) < 0) {
           RAW_LOG(WARNING, "getrlimit failed");
         } else if (limit.rlim_cur < limit.rlim_max) {
@@ skipping 448 matching lines @@
 
         // Obscure fork() rule: in the child, if you don't end up doing exec*(),
         // you call _exit() instead of exit(). This is because _exit() does not
         // call any previously-registered (in the parent) exit handlers, which
         // might do things like block waiting for threads that don't even exist
         // in the child.
         int dev_null = open("/dev/null", O_WRONLY);
         if (dev_null < 0)
           _exit(127);
 
+#ifdef USE_ALLOCATED_TYPE
+        // Stop interceptors for allocated type to avoid using locks.
+        StopAllocatedTypeIntercept();
+#endif
         fd_shuffle1.push_back(InjectionArc(pipe_fd[1], STDOUT_FILENO, true));
         fd_shuffle1.push_back(InjectionArc(dev_null, STDERR_FILENO, true));
         fd_shuffle1.push_back(InjectionArc(dev_null, STDIN_FILENO, true));
         // Adding another element here? Remeber to increase the argument to
         // reserve(), above.
 
         std::copy(fd_shuffle1.begin(), fd_shuffle1.end(),
                   std::back_inserter(fd_shuffle2));
 
         if (!ShuffleFileDescriptors(&fd_shuffle1))
@@ skipping 207 matching lines @@
   if (IsChildDead(process))
     return;
 
   BackgroundReaper* reaper = new BackgroundReaper(process, 0);
   PlatformThread::CreateNonJoinable(0, reaper);
 }
 
 #endif  // !defined(OS_MACOSX)
 
 }  // namespace base