maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Remove dead code. NFC. 

This interface was added 2 years ago but users never developed.

llvm-svn: 223368
This commit is contained in:
Rafael Espindola 2014-12-04 16:59:36 +00:00
parent a4e55f4d1e
commit c0610bf4e0
9 changed files with 14 additions and 208 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

102
llvm/include/llvm/Support/Process.h
View File

@ -38,111 +38,13 @@ class StringRef;
namespace sys {
class self_process;
/// \brief Generic base class which exposes information about an operating
/// system process.
///
/// This base class is the core interface behind any OS process. It exposes
/// methods to query for generic information about a particular process.
///
/// Subclasses implement this interface based on the mechanisms available, and
/// can optionally expose more interfaces unique to certain process kinds.
class process {
protected:
/// \brief Only specific subclasses of process objects can be destroyed.
virtual ~process();
public:
/// \brief Operating system specific type to identify a process.
///
/// Note that the windows one is defined to 'unsigned long' as this is the
/// documented type for DWORD on windows, and we don't want to pull in the
/// Windows headers here.
#if defined(LLVM_ON_UNIX)
typedef pid_t id_type;
#elif defined(LLVM_ON_WIN32)
typedef unsigned long id_type; // Must match the type of DWORD.
#else
#error Unsupported operating system.
#endif
/// \brief Get the operating system specific identifier for this process.
virtual id_type get_id() = 0;
/// \brief Get the user time consumed by this process.
///
/// Note that this is often an approximation and may be zero on platforms
/// where we don't have good support for the functionality.
virtual TimeValue get_user_time() const = 0;
/// \brief Get the system time consumed by this process.
///
/// Note that this is often an approximation and may be zero on platforms
/// where we don't have good support for the functionality.
virtual TimeValue get_system_time() const = 0;
/// \brief Get the wall time consumed by this process.
///
/// Note that this is often an approximation and may be zero on platforms
/// where we don't have good support for the functionality.
virtual TimeValue get_wall_time() const = 0;
/// \name Static factory routines for processes.
/// @{
/// \brief Get the process object for the current process.
static self_process *get_self();
/// @}
};
/// \brief The specific class representing the current process.
///
/// The current process can both specialize the implementation of the routines
/// and can expose certain information not available for other OS processes.
class self_process : public process {
friend class process;
/// \brief Private destructor, as users shouldn't create objects of this
/// type.
virtual ~self_process();
public:
id_type get_id() override;
TimeValue get_user_time() const override;
TimeValue get_system_time() const override;
TimeValue get_wall_time() const override;
/// \name Process configuration (sysconf on POSIX)
/// @{
/// \brief Get the virtual memory page size.
///
/// Query the operating system for this process's page size.
size_t page_size() const { return PageSize; };
/// @}
private:
/// \name Cached process state.
/// @{
/// \brief Cached page size, this cannot vary during the life of the process.
size_t PageSize;
/// @}
/// \brief Constructor, used by \c process::get_self() only.
self_process();
};
/// \brief A collection of legacy interfaces for querying information about the
/// current executing process.
class Process {
public:
static unsigned getPageSize();
/// \brief Return process memory usage.
/// This static function will return the total amount of memory allocated
/// by the process. This only counts the memory allocated via the malloc,

2
llvm/lib/Support/MemoryBuffer.cpp
View File

@ -330,7 +330,7 @@ static ErrorOr<std::unique_ptr<MemoryBuffer>>
getOpenFileImpl(int FD, const Twine &Filename, uint64_t FileSize,
uint64_t MapSize, int64_t Offset, bool RequiresNullTerminator,
bool IsVolatileSize) {
static int PageSize = sys::process::get_self()->page_size();
static int PageSize = sys::Process::getPageSize();
// Default is to map the full file.
if (MapSize == uint64_t(-1)) {

25
llvm/lib/Support/Process.cpp
View File

@ -26,25 +26,6 @@ using namespace sys;
//=== 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;
}
// 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.
///
@ -63,12 +44,6 @@ static TimeValue getElapsedWallTime() {
/// 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();
}
Optional<std::string> Process::FindInEnvPath(const std::string& EnvName,
const std::string& FileName)
{

4
llvm/lib/Support/Unix/Memory.inc
View File

@ -88,7 +88,7 @@ Memory::allocateMappedMemory(size_t NumBytes,
if (NumBytes == 0)
return MemoryBlock();
static const size_t PageSize = process::get_self()->page_size();
static const size_t PageSize = Process::getPageSize();
const size_t NumPages = (NumBytes+PageSize-1)/PageSize;
int fd = -1;
@ -181,7 +181,7 @@ Memory::AllocateRWX(size_t NumBytes, const MemoryBlock* NearBlock,
std::string *ErrMsg) {
if (NumBytes == 0) return MemoryBlock();
size_t PageSize = process::get_self()->page_size();
size_t PageSize = Process::getPageSize();
size_t NumPages = (NumBytes+PageSize-1)/PageSize;
int fd = -1;

2
llvm/lib/Support/Unix/Path.inc
View File

@ -550,7 +550,7 @@ const char *mapped_file_region::const_data() const {
}
int mapped_file_region::alignment() {
return process::get_self()->page_size();
return Process::getPageSize();
}
std::error_code detail::directory_iterator_construct(detail::DirIterState &it,

34
llvm/lib/Support/Unix/Process.inc
View File

@ -57,10 +57,6 @@
using namespace llvm;
using namespace sys;
process::id_type self_process::get_id() {
return getpid();
}
static std::pair<TimeValue, TimeValue> getRUsageTimes() {
#if defined(HAVE_GETRUSAGE)
struct rusage RU;
@ -80,43 +76,19 @@ static std::pair<TimeValue, TimeValue> getRUsageTimes() {
#endif
}
TimeValue self_process::get_user_time() const {
#if _POSIX_TIMERS > 0 && _POSIX_CPUTIME > 0
// Try to get a high resolution CPU timer.
struct timespec TS;
if (::clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &TS) == 0)
return TimeValue(static_cast<TimeValue::SecondsType>(TS.tv_sec),
static_cast<TimeValue::NanoSecondsType>(TS.tv_nsec));
#endif
// Otherwise fall back to rusage based timing.
return getRUsageTimes().first;
}
TimeValue self_process::get_system_time() const {
// We can only collect system time by inspecting the results of getrusage.
return getRUsageTimes().second;
}
// On Cygwin, getpagesize() returns 64k(AllocationGranularity) and
// offset in mmap(3) should be aligned to the AllocationGranularity.
static unsigned getPageSize() {
unsigned Process::getPageSize() {
#if defined(HAVE_GETPAGESIZE)
const int page_size = ::getpagesize();
static const int page_size = ::getpagesize();
#elif defined(HAVE_SYSCONF)
long page_size = ::sysconf(_SC_PAGE_SIZE);
static long page_size = ::sysconf(_SC_PAGE_SIZE);
#else
#warning Cannot get the page size on this machine
#endif
return static_cast<unsigned>(page_size);
}
// This constructor guaranteed to be run exactly once on a single thread, and
// sets up various process invariants that can be queried cheaply from then on.
self_process::self_process() : PageSize(getPageSize()) {
}
size_t Process::GetMallocUsage() {
#if defined(HAVE_MALLINFO)
struct mallinfo mi;

31
llvm/lib/Support/Windows/Process.inc
View File

@ -49,10 +49,6 @@
using namespace llvm;
using namespace sys;
process::id_type self_process::get_id() {
return GetCurrentProcessId();
}
static TimeValue getTimeValueFromFILETIME(FILETIME Time) {
ULARGE_INTEGER TimeInteger;
TimeInteger.LowPart = Time.dwLowDateTime;
@ -65,28 +61,10 @@ static TimeValue getTimeValueFromFILETIME(FILETIME Time) {
(TimeInteger.QuadPart % 10000000) * 100));
}
TimeValue self_process::get_user_time() const {
FILETIME ProcCreate, ProcExit, KernelTime, UserTime;
if (GetProcessTimes(GetCurrentProcess(), &ProcCreate, &ProcExit, &KernelTime,
&UserTime) == 0)
return TimeValue();
return getTimeValueFromFILETIME(UserTime);
}
TimeValue self_process::get_system_time() const {
FILETIME ProcCreate, ProcExit, KernelTime, UserTime;
if (GetProcessTimes(GetCurrentProcess(), &ProcCreate, &ProcExit, &KernelTime,
&UserTime) == 0)
return TimeValue();
return getTimeValueFromFILETIME(KernelTime);
}
// This function retrieves the page size using GetNativeSystemInfo() and is
// present solely so it can be called once to initialize the self_process member
// below.
static unsigned getPageSize() {
static unsigned computePageSize() {
// GetNativeSystemInfo() provides the physical page size which may differ
// from GetSystemInfo() in 32-bit applications running under WOW64.
SYSTEM_INFO info;
@ -96,12 +74,11 @@ static unsigned getPageSize() {
return static_cast<unsigned>(info.dwPageSize);
}
// This constructor guaranteed to be run exactly once on a single thread, and
// sets up various process invariants that can be queried cheaply from then on.
self_process::self_process() : PageSize(getPageSize()) {
unsigned Process::getPageSize() {
static unsigned Ret = computePageSize();
return Ret;
}
size_t
Process::GetMallocUsage()
{

2
llvm/unittests/Support/MemoryTest.cpp
View File

@ -21,7 +21,7 @@ class MappedMemoryTest : public ::testing::TestWithParam<unsigned> {
public:
MappedMemoryTest() {
Flags = GetParam();
PageSize = sys::process::get_self()->page_size();
PageSize = sys::Process::getPageSize();
}
protected:

20
llvm/unittests/Support/ProcessTest.cpp
View File

@ -19,26 +19,6 @@ namespace {
using namespace llvm;
using namespace sys;
TEST(ProcessTest, SelfProcess) {
EXPECT_TRUE(process::get_self());
EXPECT_EQ(process::get_self(), process::get_self());
#if defined(LLVM_ON_UNIX)
EXPECT_EQ(getpid(), process::get_self()->get_id());
#elif defined(LLVM_ON_WIN32)
EXPECT_EQ(GetCurrentProcessId(), process::get_self()->get_id());
#endif
EXPECT_LT(1u, process::get_self()->page_size());
EXPECT_LT(TimeValue::MinTime(), process::get_self()->get_user_time());
EXPECT_GT(TimeValue::MaxTime(), process::get_self()->get_user_time());
EXPECT_LT(TimeValue::MinTime(), process::get_self()->get_system_time());
EXPECT_GT(TimeValue::MaxTime(), process::get_self()->get_system_time());
EXPECT_LT(TimeValue::MinTime(), process::get_self()->get_wall_time());
EXPECT_GT(TimeValue::MaxTime(), process::get_self()->get_wall_time());
}
TEST(ProcessTest, GetRandomNumberTest) {
const unsigned r1 = Process::GetRandomNumber();
const unsigned r2 = Process::GetRandomNumber();