The Tor Browser: xpcom/build/MainThreadIOLogger.cpp@b8a032363ba2 (annotated)

xpcom/build/MainThreadIOLogger.cpp@b8a032363ba2 (annotated)

xpcom/build/MainThreadIOLogger.cpp

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #include "MainThreadIOLogger.h"
 #include "GeckoProfiler.h"
 #include "IOInterposerPrivate.h"
 #include "mozilla/IOInterposer.h"
 #include "mozilla/StaticPtr.h"
 #include "mozilla/TimeStamp.h"
 #include "nsAutoPtr.h"
 /**
  * This code uses NSPR stuff and STL containers because it must be detached
  * from leak checking code; this observer runs until the process terminates.
  */
 #include <prenv.h>
 #include <prprf.h>
 #include <prthread.h>
 #include <vector>
 namespace {
 struct ObservationWithStack
 {
   ObservationWithStack(mozilla::IOInterposeObserver::Observation& aObs,
                        ProfilerBacktrace *aStack)
     : mObservation(aObs)
     , mStack(aStack)
   {
     const char16_t* filename = aObs.Filename();
     if (filename) {
       mFilename = filename;
     }
   }
   mozilla::IOInterposeObserver::Observation mObservation;
   ProfilerBacktrace*                        mStack;
   nsString                                  mFilename;
 };
 } // anonymous namespace
 namespace mozilla {
 class MainThreadIOLoggerImpl MOZ_FINAL : public IOInterposeObserver
 {
 public:
   MainThreadIOLoggerImpl();
   ~MainThreadIOLoggerImpl();
   bool Init();
   void Observe(Observation& aObservation);
 private:
   static void sIOThreadFunc(void* aArg);
   void IOThreadFunc();
   TimeStamp             mLogStartTime;
   const char*           mFileName;
   PRThread*             mIOThread;
   IOInterposer::Monitor mMonitor;
   bool                  mShutdownRequired;
   std::vector<ObservationWithStack> mObservations;
 };
 static StaticAutoPtr<MainThreadIOLoggerImpl> sImpl;
 MainThreadIOLoggerImpl::MainThreadIOLoggerImpl()
   : mFileName(nullptr)
   , mIOThread(nullptr)
   , mShutdownRequired(false)
 {
 }
 MainThreadIOLoggerImpl::~MainThreadIOLoggerImpl()
 {
   if (!mIOThread) {
     return;
   }
   { // Scope for lock
     IOInterposer::MonitorAutoLock lock(mMonitor);
     mShutdownRequired = true;
     lock.Notify();
   }
   PR_JoinThread(mIOThread);
   mIOThread = nullptr;
 }
 bool
 MainThreadIOLoggerImpl::Init()
 {
   if (mFileName) {
     // Already initialized
     return true;
   }
   mFileName = PR_GetEnv("MOZ_MAIN_THREAD_IO_LOG");
   if (!mFileName) {
     // Can't start
     return false;
   }
   mIOThread = PR_CreateThread(PR_USER_THREAD, &sIOThreadFunc, this,
                               PR_PRIORITY_LOW, PR_GLOBAL_THREAD,
                               PR_JOINABLE_THREAD, 0);
   if (!mIOThread) {
     return false;
   }
   return true;
 }
 /* static */ void
 MainThreadIOLoggerImpl::sIOThreadFunc(void* aArg)
 {
   PR_SetCurrentThreadName("MainThreadIOLogger");
   MainThreadIOLoggerImpl* obj = static_cast<MainThreadIOLoggerImpl*>(aArg);
   obj->IOThreadFunc();
 }
 void
 MainThreadIOLoggerImpl::IOThreadFunc()
 {
   PRFileDesc* fd = PR_Open(mFileName, PR_WRONLY | PR_CREATE_FILE | PR_TRUNCATE,
                            PR_IRUSR | PR_IWUSR | PR_IRGRP);
   if (!fd) {
     IOInterposer::MonitorAutoLock lock(mMonitor);
     mShutdownRequired = true;
     std::vector<ObservationWithStack>().swap(mObservations);
     return;
   }
   mLogStartTime = TimeStamp::Now();
   { // Scope for lock
     IOInterposer::MonitorAutoLock lock(mMonitor);
     while (true) {
       while (!mShutdownRequired && mObservations.empty()) {
         lock.Wait();
       }
       if (mShutdownRequired) {
         break;
       }
       // Pull events off the shared array onto a local one
       std::vector<ObservationWithStack> observationsToWrite;
       observationsToWrite.swap(mObservations);
       // Release the lock so that we're not holding anybody up during I/O
       IOInterposer::MonitorAutoUnlock unlock(mMonitor);
       // Now write the events.
       for (std::vector<ObservationWithStack>::iterator
              i = observationsToWrite.begin(), e = observationsToWrite.end();
            i != e; ++i) {
         if (i->mObservation.ObservedOperation() == OpNextStage) {
           PR_fprintf(fd, "%f,NEXT-STAGE\n",
                      (TimeStamp::Now() - mLogStartTime).ToMilliseconds());
           continue;
         }
         double durationMs = i->mObservation.Duration().ToMilliseconds();
         nsAutoCString nativeFilename;
         nativeFilename.AssignLiteral("(not available)");
         if (!i->mFilename.IsEmpty()) {
           if (NS_FAILED(NS_CopyUnicodeToNative(i->mFilename, nativeFilename))) {
             nativeFilename.AssignLiteral("(conversion failed)");
           }
         }
         /**
          * Format:
          * Start Timestamp (Milliseconds), Operation, Duration (Milliseconds), Event Source, Filename
          */
         if (PR_fprintf(fd, "%f,%s,%f,%s,%s\n",
                        (i->mObservation.Start() - mLogStartTime).ToMilliseconds(),
                        i->mObservation.ObservedOperationString(), durationMs,
                        i->mObservation.Reference(), nativeFilename.get()) > 0) {
           ProfilerBacktrace* stack = i->mStack;
           if (stack) {
             // TODO: Write out the callstack
             //       (This will be added in a later bug)
             profiler_free_backtrace(stack);
           }
         }
       }
     }
   }
   PR_Close(fd);
 }
 void
 MainThreadIOLoggerImpl::Observe(Observation& aObservation)
 {
   if (!mFileName || !IsMainThread()) {
     return;
   }
   IOInterposer::MonitorAutoLock lock(mMonitor);
   if (mShutdownRequired) {
     // The writer thread isn't running. Don't enqueue any more data.
     return;
   }
   // Passing nullptr as aStack parameter for now
   mObservations.push_back(ObservationWithStack(aObservation, nullptr));
   lock.Notify();
 }
 namespace MainThreadIOLogger {
 bool
 Init()
 {
   nsAutoPtr<MainThreadIOLoggerImpl> impl(new MainThreadIOLoggerImpl());
   if (!impl->Init()) {
     return false;
   }
   sImpl = impl.forget();
   IOInterposer::Register(IOInterposeObserver::OpAllWithStaging, sImpl);
   return true;
 }
 } // namespace MainThreadIOLogger
 } // namespace mozilla

The Tor Browser / annotate

xpcom/build/MainThreadIOLogger.cpp@b8a032363ba2 (annotated)

xpcom/build/MainThreadIOLogger.cpp