mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-29 13:29:28 +00:00
wall time, user time, and system time since a process started. For walltime, we currently use TimeValue's interface and a global initializer to compute a close approximation of total process runtime. For user time, this adds support for an somewhat more precise timing mechanism -- clock_gettime with the CLOCK_PROCESS_CPUTIME_ID clock selected. For system time, we have to do a full getrusage call to extract the system time from the OS. This is expensive but unavoidable. In passing, clean up the implementation of the old APIs and fix some latent bugs in the Windows code. This might have manifested on Windows ARM systems or other systems with strange 64-bit integer behavior. The old API for this both user time and system time simultaneously from a single getrusage call. While this results in fewer system calls, it also results in a lower precision user time and if only user time is desired, it introduces a higher overhead. It may be worthwhile to switch some of the pass timers to not track system time and directly track user and wall time. The old API also tracked walltime in a confusing way -- it just set it to the current walltime rather than providing any measure of wall time since the process started the way buth user and system time are tracked. The new API is more consistent here. The plan is to eventually implement these methods for a *child* process by using the wait3(2) system call to populate an rusage struct representing the whole subprocess execution. That way, after waiting on a child process its stats will become accurate and cheap to query. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@171551 91177308-0d34-0410-b5e6-96231b3b80d8
90 lines
3.0 KiB
C++
90 lines
3.0 KiB
C++
//===-- Process.cpp - Implement OS Process Concept --------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This header file implements the operating system Process concept.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/Config/config.h"
|
|
#include "llvm/Support/ErrorHandling.h"
|
|
#include "llvm/Support/Process.h"
|
|
|
|
using namespace llvm;
|
|
using namespace sys;
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
//=== WARNING: Implementation here must contain only TRULY operating system
|
|
//=== independent code.
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Empty virtual destructor to anchor the vtable for the process class.
|
|
process::~process() {}
|
|
|
|
self_process *process::get_self() {
|
|
// Use a function local static for thread safe initialization and allocate it
|
|
// as a raw pointer to ensure it is never destroyed.
|
|
static self_process *SP = new self_process();
|
|
|
|
return SP;
|
|
}
|
|
|
|
#if defined(_MSC_VER)
|
|
// Visual Studio complains that the self_process destructor never exits. This
|
|
// doesn't make much sense, as that's the whole point of calling abort... Just
|
|
// silence this warning.
|
|
#pragma warning(push)
|
|
#pragma warning(disable:4722)
|
|
#endif
|
|
|
|
// The destructor for the self_process subclass must never actually be
|
|
// executed. There should be at most one instance of this class, and that
|
|
// instance should live until the process terminates to avoid the potential for
|
|
// racy accesses during shutdown.
|
|
self_process::~self_process() {
|
|
llvm_unreachable("This destructor must never be executed!");
|
|
}
|
|
|
|
/// \brief A helper function to compute the elapsed wall-time since the program
|
|
/// started.
|
|
///
|
|
/// Note that this routine actually computes the elapsed wall time since the
|
|
/// first time it was called. However, we arrange to have it called during the
|
|
/// startup of the process to get approximately correct results.
|
|
static TimeValue getElapsedWallTime() {
|
|
static TimeValue &StartTime = *new TimeValue(TimeValue::now());
|
|
return TimeValue::now() - StartTime;
|
|
}
|
|
|
|
/// \brief A special global variable to ensure we call \c getElapsedWallTime
|
|
/// during global initialization of the program.
|
|
///
|
|
/// Note that this variable is never referenced elsewhere. Doing so could
|
|
/// create race conditions during program startup or shutdown.
|
|
static volatile TimeValue DummyTimeValue = getElapsedWallTime();
|
|
|
|
// Implement this routine by using the static helpers above. They're already
|
|
// portable.
|
|
TimeValue self_process::get_wall_time() const {
|
|
return getElapsedWallTime();
|
|
}
|
|
|
|
|
|
#if defined(_MSC_VER)
|
|
#pragma warning(pop)
|
|
#endif
|
|
|
|
|
|
// Include the platform-specific parts of this class.
|
|
#ifdef LLVM_ON_UNIX
|
|
#include "Unix/Process.inc"
|
|
#endif
|
|
#ifdef LLVM_ON_WIN32
|
|
#include "Windows/Process.inc"
|
|
#endif
|