System.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/basic.h>
 
#if defined(OGDF_SYSTEM_OSX)
#   include <stdlib.h>
#elif defined(OGDF_SYSTEM_UNIX) || defined(__MINGW32__)
#   include <malloc.h>
#endif
 
// detect processor architecture we're compiling for
//
// OGDF_ARCH_X86       Intel / AMD x86 32-bit processors
// OGDF_ARCH_X64       Intel / AMD x86 64-bit processors
// OGDF_ARCH_IA64      Intel Itanium
// OGDF_ARCH_PPC       PowerPC
// OGDF_ARCH_SPARC     SUN SPARC
// OGDF_ARCH_SPARC_V9  SUN SPARC V9
 
#if defined(_M_X64) || defined(__x86_64__)
#   define OGDF_ARCH_X64
#elif defined(_M_IX86) || defined(__i386__)
#   define OGDF_ARCH_X86
#elif defined(_M_IA64) || defined(__ia64__)
#   define OGDF_ARCH_IA64
#elif defined(_M_MPPC) || defined(_M_PPC) || defined(__powerpc__)
#   define OGDF_ARCH_PPC
#elif defined(__sparc__)
#   define OGDF_ARCH_SPARC
#elif defined(__sparc_v9__)
#   define OGDF_ARCH_SPARC_V9
#endif
 
namespace ogdf {
 
 
enum class CPUFeature {
    MMX, 
    SSE, 
    SSE2, 
    SSE3, 
    SSSE3, 
    SSE4_1, 
    SSE4_2, 
    VMX, 
    SMX, 
    EST, 
    MONITOR 
};
 
 
enum class CPUFeatureMask : unsigned int {
    MMX = 1 << static_cast<int>(CPUFeature::MMX), 
    SSE = 1 << static_cast<int>(CPUFeature::SSE), 
    SSE2 = 1 << static_cast<int>(CPUFeature::SSE2), 
    SSE3 = 1 << static_cast<int>(CPUFeature::SSE3), 
    SSSE3 = 1 << static_cast<int>(CPUFeature::SSSE3), 
    SSE4_1 = 1 << static_cast<int>(CPUFeature::SSE4_1), 
    SSE4_2 = 1 << static_cast<int>(CPUFeature::SSE4_2), 
    VMX = 1 << static_cast<int>(CPUFeature::VMX), 
    SMX = 1 << static_cast<int>(CPUFeature::SMX), 
    EST = 1 << static_cast<int>(CPUFeature::EST), 
    MONITOR = 1 << static_cast<int>(CPUFeature::MONITOR) 
};
 
OGDF_EXPORT unsigned int operator|=(unsigned int& i, CPUFeatureMask fm);
 
 
class OGDF_EXPORT System {
public:
 
    static void* alignedMemoryAlloc16(size_t size) {
#ifdef OGDF_SYSTEM_WINDOWS
#   ifdef __MINGW64__
        return __mingw_aligned_malloc(size, 16);
#   else
        return _aligned_malloc(size, 16);
#   endif
#elif defined(OGDF_SYSTEM_OSX)
        // malloc returns 16 byte aligned memory on OS X.
        return malloc(size);
#else
        return memalign(16, size);
#endif
    }
 
    static void alignedMemoryFree(void* p) {
#ifdef OGDF_SYSTEM_WINDOWS
#   ifdef __MINGW64__
        __mingw_aligned_free(p);
#   else
        _aligned_free(p);
#   endif
#else
        free(p);
#endif
    }
 
    static int pageSize() { return s_pageSize; }
 
    static long long physicalMemory();
 
    static long long availablePhysicalMemory();
 
    static size_t memoryUsedByProcess();
 
#if defined(OGDF_SYSTEM_WINDOWS) || defined(__CYGWIN__)
    static size_t peakMemoryUsedByProcess();
#endif
 
 
    static size_t memoryAllocatedByMemoryManager();
 
    static size_t memoryInGlobalFreeListOfMemoryManager();
 
    static size_t memoryInThreadFreeListOfMemoryManager();
 
 
    static size_t memoryAllocatedByMalloc();
 
 
    static size_t memoryInFreelistOfMalloc();
 
#if defined(OGDF_SYSTEM_WINDOWS) || defined(__CYGWIN__)
 
 
    static void getHPCounter(int64_t& counter);
 
    static double elapsedSeconds(const int64_t& startCounter, const int64_t& endCounter);
#endif
 
 
    static int64_t usedRealTime(int64_t& t);
 
 
    static int64_t realTime();
 
 
 
 
    static int getProcessID();
 
 
 
    static int cpuFeatures() { return s_cpuFeatures; }
 
    static bool cpuSupports(CPUFeature feature) {
        return (s_cpuFeatures & (1 << static_cast<int>(feature))) != 0;
    }
 
    static int cacheSizeKBytes() { return s_cacheSize; }
 
    static int cacheLineBytes() { return s_cacheLine; }
 
    static int numberOfProcessors() { return s_numberOfProcessors; }
 
 
private:
    static unsigned int s_cpuFeatures; 
    static int s_cacheSize; 
    static int s_cacheLine; 
    static int s_numberOfProcessors; 
    static int s_pageSize; 
 
#if defined(OGDF_SYSTEM_WINDOWS) || defined(__CYGWIN__)
    static int64_t s_HPCounterFrequency; 
#endif
 
public:
    static void init();
};
 
}