System.h

Go to the documentation of this file.

/*
 * $Revision: 2299 $
 * 
 * last checkin:
 *   $Author: gutwenger $ 
 *   $Date: 2012-05-07 15:57:08 +0200 (Mon, 07 May 2012) $ 
 ***************************************************************/
 
#ifdef _MSC_VER
#pragma once
#endif

#ifndef OGDF_SYSTEM_H
#define OGDF_SYSTEM_H


#include <ogdf/basic/basic.h>
#if defined(OGDF_SYSTEM_OSX)
#include <stdlib.h>
#elif defined(OGDF_SYSTEM_UNIX)
#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

// use SSE2 always if x64-platform or compiler option is set
#ifndef OGDF_USE_SSE2
#if defined(OGDF_ARCH_X64)
#define OGDF_USE_SSE2
#elif defined(_MSC_VER)
#if _M_IX86_FP >= 2
#define OGDF_USE_SSE2
#endif
#endif
#endif

// macros to check for using special cpu features
//
// OGDF_CHECK_SSE2   returns true if SSE2 can be used

#ifdef OGDF_USE_SSE2
#define OGDF_CHECK_SSE2 true
#elif defined(OGDF_ARCH_X86)
#define OGDF_CHECK_SSE2 ogdf::System::cpuSupports(ogdf::cpufSSE2)
#else
#define OGDF_USE_SSE2 false
#endif


namespace ogdf {


enum CPUFeature {
    cpufMMX,    
    cpufSSE,    
    cpufSSE2,   
    cpufSSE3,   
    cpufSSSE3,  
    cpufSSE4_1, 
    cpufSSE4_2, 
    cpufVMX,    
    cpufSMX,    
    cpufEST,    
    cpufMONITOR 
};

enum CPUFeatureMask {
    cpufmMMX     = 1 << cpufMMX,    
    cpufmSSE     = 1 << cpufSSE,    
    cpufmSSE2    = 1 << cpufSSE2,   
    cpufmSSE3    = 1 << cpufSSE3,   
    cpufmSSSE3   = 1 << cpufSSSE3,  
    cpufmSSE4_1  = 1 << cpufSSE4_1, 
    cpufmSSE4_2  = 1 << cpufSSE4_2, 
    cpufmVMX     = 1 << cpufVMX,    
    cpufmSMX     = 1 << cpufSMX,    
    cpufmEST     = 1 << cpufEST,    
    cpufmMONITOR = 1 << cpufMONITOR 
};



class OGDF_EXPORT System {

    //friend class ::OgdfInitialization;

public:

    static void *alignedMemoryAlloc16(size_t size) {
        size_t alignment = 16;
#ifdef OGDF_SYSTEM_WINDOWS
        return _aligned_malloc(size,alignment);
#elif defined(OGDF_SYSTEM_OSX)
        // malloc returns 16 byte aligned memory on OS X.
        return malloc(size);
#else
        return memalign(alignment,size);
#endif
    }

    static void alignedMemoryFree(void *p) {
#ifdef OGDF_SYSTEM_WINDOWS
        _aligned_free(p);
#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(LARGE_INTEGER &counter);

    static double elapsedSeconds(
        const LARGE_INTEGER &startCounter,
        const LARGE_INTEGER &endCounter);
#endif


    static __int64 usedRealTime(__int64 &t);




    static int cpuFeatures() { return s_cpuFeatures; }

    static bool cpuSupports(CPUFeature feature) {
        return (s_cpuFeatures & (1 << 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 LARGE_INTEGER s_HPCounterFrequency; 
#endif

public:
    static void init();
};


} // end namespace ogdf


#endif