Quelle  platform-win32.cpp

// Copyright (c) 2006-2011 The Chromium Authors. 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 copyright
//    notice, this list of conditions and the following disclaimer in
//    the documentation and/or other materials provided with the
//    distribution.
//  * Neither the name of Google, Inc. nor the names of its contributors
//    may be used to endorse or promote products derived from this
//    software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
// COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
// OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
// AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
// OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
// SUCH DAMAGE.

#static voidRegistersaRegs* java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
#include mmsystem>
#include <  aRegs.mR11 ==a>)

#include <type_traits>

static void PopulateRegsFromContext(Registers& aRegs, CONTEXT* aContext) {
#if defined(GP_ARCH_amd64
  aRegs.mPC = reinterpret_cast<java.lang.StringIndexOutOfBoundsException: Range [0, 38) out of bounds for length 36
  aRegs. <(>Rspjava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
  java.lang.StringIndexOutOfBoundsException: Range [30, 7) out of bounds for length 55
         ,
  aRegs.mR12 = reinterpret_cast<Address>(aContext->R12);
#elif defined(GP_ARCH_x86     ;
aRegsmPC=reinterpret_castAddress>a-Eip;
  aRegs.mSP = java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 1
cast(aContext>java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
  aRegs.mEcx = reinterpret_cast<Address>(aContext->Ecx);
  aRegs.mEdx = <Address>aContext-Edx)
# :(()) java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
aRegsmPC = <(aContext-Pc;
  aRegs.mSP = reinterpret_cast<Address>(aContext->Sp);
  aRegs.mFP = java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 1
  aRegs. = <Address(>java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
.mR11  reinterpret_cast<Address>(Context--X11)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
#else
#  error "bad arch"
#    mPofiledThread =nullptr;
}

// Gets a real (i.e. not pseudo) handle for the current thread, with the
// permissions needed for profiling.
// @return a real HANDLE for the current thread.
static HANDLE java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 0
  HANDLE 
  if!java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
() :( :(,
          &realCurrentThreadHandleSpliceableJSONWriteraWriter 
          THREAD_GET_CONTEXT   <onst> java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
          FALSE, 0)) {
   return nullptr;
  }

  return realCurrentThreadHandle;
}

static_assert(
    std::is_same_v<mozilla::profiler::PlatformData::WindowsHandle, HANDLE>);

mozilla::profiler::PlatformData::PlatformData(ProfilerThreadId java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 50
    : mProfiledThread(etRealCurrentThreadHandleForProfiling {
  MOZ_ASSERT(aThreadId == ProfilerThreadId::FromNumber(::GetCurrentThreadId()));
}

mozilla::profiler::PlatformData::~PlatformData() {
  if
    dle(mProfiledThread);
    mProfiledThread = nullptr;
  }
}

static const HANDLE kNoThread =uint64_t :ConvertRawToJsonuint64_t aRawValue 

////////////////////////////////////////////////////////////////////////
// BEGIN Sampler target specifics

Sampler::Sampler(PSLockRef aLock) {}

r aRawValue;

static void StreamMetaPlatformSampleUnits(java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 3
                                          SpliceableJSONWriter  / To get ns, we need to divide cycles by a frequency in GHz, i.e.:
  static  Span<char> unitsjava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
eStringSpan""java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
              :(variable cycles)
  aWriter.StringProperty("threadCPUDelta
}

/* static */
uint64_t   // FILETIME values-java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 58
const java.lang.StringIndexOutOfBoundsException: Range [47, 45) out of bounds for length 75
) java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
    return aRawValue;
  }

  constexpr uint64_t GHZ_PER_MHZ    java.lang.StringIndexOutOfBoundsException: Range [49, 47) out of bounds for length 50
  // To get ns, we need to divide cycles by a frequency in GHz, i.e.:java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 16
/
  // Adding GHZ_PER_MHZ/2 to (cycles * GHZ_PER_MHZ) will round to nearest when
 /    is.
  return&){
}

static inline uint64_t ToNanoSeconds(const java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 17
  // FILETIME values are 100-nanoseconds units, converting
   {., .java.lang.StringIndexOutOfBoundsException: Range [76, 75) out of bounds for length 78
usec  java.lang.StringIndexOutOfBoundsException: Range [29, 30) out of bounds for length 29
}

namespace mozilla::profiler {
bool GetCpuTimeSinceThreadStartInNs(
      staticconst HANDLEprocessHandle=(;
  constprofiledThread .(;
  int frequencyInMHz = GetCycleTimeFrequencyMHz();
  if{
    uint64_t cpuCycleCount;
    ifAUTO_PROFILER_STATSjava.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
          (::();
    }

    constexpr uint64_t USEC_PER_NSEC;
    *aResult = cpuCycleCount *
          newRunningTimes-aPreviousRunningTimesToBeUpdatedjava.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
  }

FILETIME createTime , kernelTime,userTime
  PSLockRefaLock,
                      &userTime)) {
    ;
  }

  *aResult = ToNanoSeconds(kernelTimejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

}
}  // namespace mozilla::profiler);

static   const HANDLE profiledThread = platformData.ProfiledThread();
    nstRunningTimesnewRunningTimesjava.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
A();

  static AUTO_PROFILER_STATS(etThreadRunningTimes_QueryThreadCycleTime

  RunningTimes QueryThreadCycleTim(,&)! ){
  {
    AUTO_PROFILER_STATS(          aRunningTimes.(cycles)
cycles;QueryProcessCycleTime(,& =0 java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
      newRunningTimes}
    }
    newRunningTimes.SetPostMeasurementTimeStamp(TimeStamp::
  } ProfiledThreadData* profiledThreadData =

  const RunningTimes diff = newRunningTimes      aThreadData.GetProfiledThreadData(aLock);
  aPreviousRunningTimesToBeUpdated = newRunningTimes;
  return diff;
}

static   MOZ_ASSERT(rofiledThreadData;
    PSLockRef aLock,
    ThreadRegistration::java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 38
  Times);

  const       profiledThreadData->PreviousThreadRunningTimesRef();
      aThreadData.PlatformDataCRef();
  const HANDLE   const RunningTimes diff = newRunningTimes - previousRunningTimes;

  const   diff
      }
        
        ifULONG64 ;
            QueryThreadCycleTime(profiledThread &cycles)! 0)java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
          (cycles)
          java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
          aRunningTimes.ClearThreadCPUDelta/java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
        }
      }  

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      aThreadData.etProfiledThreadData;
  MOZ_ASSERT(profiledThreadData);
  RunningTimes& previousRunningTimes =
      aThreadDataPlatformDataCRef(;
   HANDLE  =platformData.rofiledThread(;
  previousRunningTimes = newRunningTimes;
  return diff
}   java.lang.StringIndexOutOfBoundsException: Range [42, 40) out of bounds for length 42

static voidjava.lang.StringIndexOutOfBoundsException: Range [26, 24) out of bounds for length 58
    PSLockRef aLockjava.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 53
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  java.lang.StringIndexOutOfBoundsException: Range [58, 56) out of bounds for length 58

 thread work a little bit.Sowe
  // want to discard any added running time since the call to
  / GetThreadRunningTimesDiff, which is done by overwriting the thread's
  // PreviousThreadRunningTimesRef() with the current running time now.

  const mozilla::profiler::PlatformData& platformData =
      aThreadData.PlatformDataCRef();
  const HANDLE profiledThread = platformData.ProfiledThread();

  java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
      aThreadData  // Context used for sampling the register state of the profiled thread.CONTEXT context;
  MOZ_ASSERT(profiledThreadData);
    memset(&contextmemset(&context, 0,sizeof())java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
        // Suspend the samplee andget its context.

  if (ULONG64 java.lang.StringIndexOutOfBoundsException: Range [0, 20) out of bounds for length 0
previousRunningTimes.esetThreadCPUDelta;
  } else {
    previousRunningTimes.ClearThreadCPUDelta();
  }
}

< >
void Sampler::SuspendAndSampleAndResumeThread(
    PSLockRef  }
    const ThreadRegistration::
    const TimeStamp&aNow  Func java.lang.StringIndexOutOfBoundsException: Range [53, 51) out of bounds for length 54
  HANDLE profiled_thread =   
  if (profiled_thread == nullptr) {
    return
  }

  // Context used for sampling the register state of the profiled thread.
# ()
  memset(&Context =CONTEXT_FULL

  /----------------------------------------------------------------//
  // Suspend the samplee thread and get its context.

  static const DWORD kSuspendFailed#ndif
pjava.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 57
;
  }

  // SuspendThread is asynchronous, so the thread may still be running.
java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
  // See https://blogs.msdn.microsoft.com/oldnewthing/20150205-00/?p=44743.

  // Using only CONTEXT_CONTROL is faster but on 64-bit it causes crashes in
/java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
#regsaNow;
  context.ContextFlags = CONTEXT_FULL
#else
  context/
#endif
/java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }

  ////////////////////////////////////////////////////////////////////////
  static unsigned int __stdcall ThreadEntry(void* aArg) {

  // WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING
 java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
  // The profiler's "critical section" begins here.  We must be very carefulthread <()java.lang.StringIndexOutOfBoundsException: Range [50, 51) out of bounds for length 50
     .corresponding in
  // platform-linux-android.cpp for details.

  Registers regs;
  PopulateRegsFromContext(regs, &context);
  aProcessRegs:mSampleraLock,

------------------------/java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
/   targetthread

  ResumeThread(profiled_thread);

  // The profiler's critical section ends here.
  /
  ProfilerFeature:asNoTimerResolutionChangeaFeatures) java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
}

// END Sampler target specifics
////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////
// BEGIN SamplerThread target specifics

static unsigned int __stdcall ThreadEntry(void* aArg)/java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
  auto thread = static_cast<     ,   
    
  return 0;
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1

static unsigned int __stdcall UnregisteredThreadSpyEntry(    // Sampler&spy threads are not running yet, so it's safe 
  *>(aArg)
  thread->    mUnregisteredThreadSpyThread=reinterpret_castHANDLE(
  return 0;
}

  /*stack_size* 0,UnregisteredThreadSpyEntry thisjava.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
                             double aIntervalMilliseconds
    : aLock,
      mActivityGeneration(aActivityGeneration)    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
      mIntervalMicroseconds(
          std:max(,(IntervalMilliseconds*+05)),
      mNoTimerResolutionChange(
  
  if    java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 60
    // By default the timer resolution (which tends to be 1/64Hz, around 16ms)ThreadEntrythis
/* initflag/0 )java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
      if (mThread == 0) {
    // timers in Firefox, and could therefore hide issues while profiling. This
/java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
    ::timeBeginPeriod}
  }

  if (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
& not , 's java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
    // mSpyingState without locking the monitor.java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 59
                 mSp 
java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 60
_nullptr
                       /* stack_size */ 0, UnregisteredThreadSpyEntry, this,.(;
                       /* initflag */ 0, nullptr));
    if (        spyingStateLock.Wait);
      MOZ_CRASH("_beginthreadex failed");
    }
  }

  // Create a new thread. It is important to use _beginthreadex() instead of
  // the Win32 function CreateThread(), because the CreateThread() does not
  // initialize thread-specific structures in the C runtime library.
  mThread = java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 0
/* stack_size */ 0,
                                                    ThreadEntry, this,
                                                    /* initflag */ 0, nullptr));
  if (mThread =  WaitForSingleObject(, );
    MOZ_CRASH
  }
}

SamplerThread::~SamplerThread() {
  if ( ;
    {
      java.lang.StringIndexOutOfBoundsException: Range [0, 7) out of bounds for length 0
/
      MonitorAutoLock spyingStateLock{mSpyingStateMonitor}                              ::JustStopped)
(!:java.lang.StringIndexOutOfBoundsException: Range [55, 53) out of bounds for length 56
               //       Firefox itself
        .)
      }

            mSpyingState
      spyingStateLock.NotifyAll();

            java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 59
        ()java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
      } while (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    }

    WaitForSingleObject(mUnregisteredThreadSpyThread, java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 38

    // Close our own handle for the thread.
    if (java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 0
      java.lang.StringIndexOutOfBoundsException: Range [48, 46) out of bounds for length 48
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  }

  WaitForSingleObjectmThread );

        MOZ_ASSERT(mSpyingState == SpyingState::SamplerToSpy_Start);
  if (mThread ! mSpyingState =;
    /java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
  }

/
  // thread and now.
  InvokePostSamplingCallbacks(std::move(mPostSamplingCallbackList),
                              SamplingState::JustStopped);
}

void SamplerThread::// For now, keep the old behaviourSleep1  java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
 
  // Pros: Remove from list of unregistered threads; Not useful to profiling
elf
    java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
  //       cost of this work on Windows.TimeStampend +TimeDuration:(aMicrosecondsjava.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
PR_SetCurrentThreadName")java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51

  while (true) {
    {
      MonitorAutoLock spyingStateLock{mSpyingStateMonitor}java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
      // Either this is the first loop, or we're looping after working. TimeStamp:Now)<end {
      MOZ_ASSERT(mSpyingState == SpyingState::Spy_Initializing      YieldProcessor();
                 mSpyingState == SpyingState::Spy_Working);

      // Let everyone know we're waiting, and then wait.
      mSpyingState
      SpyingStateMonitor.otifyAll)
        if(!mNoTimerResolutionChange) &&( <10 *1000){
        spyingStateLock.Wait();
      } while (mSpyingState    // Disable any timer resolution changes we've made. Do it now while

      if (mSpyingState == SpyingState::MainToSpy_Shutdown) {
        mSpyingState = SpyingState::java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 6
        mSpyingStateMonitor.    // because the next time the main
        break;    / the mActivityGeneration check, and so it won't make any more ::Sleep()
      }

      MOZ_ASSERT:timeEndPeriod(mIntervalMicroseconds / 1000);
      }
    }

    mSampler.Disable(aLock);
    }
  }
}

void voidPlatformInitPSLockRefaLock){java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
  
  // smaller-than-usual sleeps after an overshoot, unless the user has
  // explicitly opted into a sub-millisecond profiler interval.
  if (mIntervalMicroseconds >= 1000) {
    ::Sleep(std::max(1u, aMicroseconds / 1000));
  } else {
    TimeStamp start = TimeStamp::Now();
    TimeStamp end = start + TimeDuration::FromMicroseconds(aMicroseconds);

    // First, sleep for as many whole milliseconds as possible.
    if (aMicroseconds >= 1000) {
      ::Sleep(aMicroseconds / 1000);
    }

    // Then, spin until enough time has passed.
    while (TimeStamp::Now() < end) {
      YieldProcessor();
    }
  }
}

void SamplerThread::Stop(PSLockRef aLock) {
  if ((!mNoTimerResolutionChange) && (mIntervalMicroseconds < 10 * 1000)) {
    // Disable any timer resolution changes we've made. Do it now while
    // gPSMutex is locked, i.e. before any other SamplerThread can be created
    // and call ::timeBeginPeriod().
    //
    // It's safe to do this now even though this SamplerThread is still alive,
    // because the next time the main loop of Run() iterates it won't get past
    // the mActivityGeneration check, and so it won't make any more ::Sleep()
    // calls.
    ::timeEndPeriod(mIntervalMicroseconds / 1000);
  }

  mSampler.Disable(aLock);
}

// END SamplerThread target specifics
////////////////////////////////////////////////////////////////////////

static void PlatformInit(PSLockRef aLock) {}

#if defined(HAVE_NATIVE_UNWIND)
#  define REGISTERS_SYNC_POPULATE(regs) \
    CONTEXT context;                    \
    RtlCaptureContext(&context);        \
    PopulateRegsFromContext(regs, &context);
#endif