System.h

Go to the documentation of this file.

#ifndef G3D_System_h
#define G3D_System_h

#include "G3D/platform.h"
#include "G3D/g3dmath.h"
#include "G3D/G3DGameUnits.h"
#include "G3D/BinaryFormat.h"
#include "G3D/FileNotFound.h"
#include <string>

#ifdef G3D_OSX
#define Zone OSX_Zone
# include <CoreServices/CoreServices.h>
#endif

namespace G3D {
 
std::string license();

enum G3DEndian {
 G3D_BIG_ENDIAN, 
 G3D_LITTLE_ENDIAN
};

class System {
public:
 typedef bool (*OutOfMemoryCallback)(size_t size, bool recoverable);

private:

 bool m_initialized;
 int m_cpuSpeed;
 bool m_hasCPUID;
 bool m_hasRDTSC;
 bool m_hasMMX;
 bool m_hasSSE;
 bool m_hasSSE2;
 bool m_hasSSE3;
 bool m_has3DNOW;
 bool m_has3DNOW2;
 bool m_hasAMDMMX;
 std::string m_cpuVendor;
 int m_numCores;

 std::string m_appDataDir;

 G3DEndian m_machineEndian;
 std::string m_cpuArch;
 std::string m_operatingSystem;

# ifdef G3D_WINDOWS

 LARGE_INTEGER m_start;
 LARGE_INTEGER m_counterFrequency;
#else
 struct timeval m_start;
#endif

 std::string m_version;
 OutOfMemoryCallback m_outOfMemoryCallback;

#ifdef G3D_OSX

 SInt32 m_OSXCPUSpeed;
 double m_secondsPerNS;
#endif

 RealTime m_realWorldGetTickTime0;

 uint32 m_highestCPUIDFunction;

 System();

 static System& instance();

 enum CPUIDFunction {
 CPUID_VENDOR_ID = 0x00000000,
 CPUID_PROCESSOR_FEATURES = 0x00000001,
 CPUID_NUM_CORES = 0x00000004,
 CPUID_GET_HIGHEST_FUNCTION = 0x80000000,
 CPUID_EXTENDED_FEATURES = 0x80000001};

 static void cpuid(CPUIDFunction func, uint32& areg, uint32& breg, uint32& creg, uint32& dreg);


 void getStandardProcessorExtensions();

 void initTime();
 
 void init();

public:
 
 static void cleanup();

 inline static int cpuSpeedMHz() {
 return instance().m_cpuSpeed;
 }

 inline static int numCores() {
 return instance().m_numCores;
 }

 inline static bool hasCPUID() {
 return instance().m_hasCPUID;
 }

 inline static bool hasRDTSC() {
 return instance().m_hasRDTSC;
 }

 inline static bool hasSSE() {
 return instance().m_hasSSE;
 }

 inline static bool hasSSE2() {
 return instance().m_hasSSE2;
 }

 inline static bool hasSSE3() {
 return instance().m_hasSSE3;
 }

 inline static bool hasMMX() {
 return instance().m_hasMMX;
 }

 inline static bool has3DNow() {
 return instance().m_has3DNOW;
 }

 inline static const std::string& cpuVendor() {
 return instance().m_cpuVendor;
 }

 inline static G3DEndian machineEndian() {
 return instance().m_machineEndian;
 }

 inline static const std::string& operatingSystem() {
 return instance().m_operatingSystem;
 }
 
 inline static const std::string& cpuArchitecture() {
 return instance().m_cpuArch;
 }

 static std::string currentDateString();

 static std::string currentTimeString();

 static void* malloc(size_t bytes);
 
 static void* calloc(size_t n, size_t x);

 static void* realloc(void* block, size_t bytes);

 static std::string mallocPerformance();
 static void resetMallocPerformanceCounters();

 static std::string mallocStatus();

 static void free(void* p);

 static void* alignedMalloc(size_t bytes, size_t alignment);
 
 static void alignedFree(void* ptr);

 static void memcpy(void* dst, const void* src, size_t numBytes);
 
 static void memset(void* dst, uint8 value, size_t numBytes);
 
 static std::string currentProgramFilename();

 static std::string& appName();

 inline static const std::string& version() {
 return instance().m_version;
 }

 static const std::string& build();

 static void sleep(RealTime t);

 static void consoleClearScreen();

 static bool consoleKeyPressed();
 
 static int consoleReadKey();

 static RealTime time();

 static void beginCycleCount(uint64& cycleCount);
 static void endCycleCount(uint64& cycleCount);

 static uint64 getCycleCount();

 inline static void setOutOfMemoryCallback(OutOfMemoryCallback c) {
 instance().m_outOfMemoryCallback = c;
 }

 inline static OutOfMemoryCallback outOfMemoryCallback() {
 return instance().m_outOfMemoryCallback;
 }

 static void setEnv(const std::string& name, const std::string& value);
 
 static const char* getEnv(const std::string& name);

 static void describeSystem
 (class TextOutput& t);

 static void describeSystem
 (std::string& s);

 static std::string findDataFile(const std::string& full, bool exceptionIfNotFound = true, bool caseSensitive =
#ifdef G3D_WINDOWS
 false
#else
 true
#endif
 );

 static void setAppDataDir(const std::string& path);

};


#ifdef _MSC_VER
# ifdef _M_IX86
 // 32-bit
 inline uint64 System::getCycleCount() {
 uint32 timehi, timelo;

 // Use the assembly instruction rdtsc, which gets the current
 // cycle count (since the process started) and puts it in edx:eax.
 __asm
 {
 rdtsc;
 mov timehi, edx;
 mov timelo, eax;
 }

 return ((uint64)timehi << 32) + (uint64)timelo;
 }
# else
 // 64-bit
 inline uint64 System::getCycleCount() {
 LARGE_INTEGER now;
 QueryPerformanceCounter(&now);
 return now.QuadPart;
 }

# endif

#elif defined(G3D_LINUX)

 inline uint64 System::getCycleCount() {
 uint32 timehi, timelo;

 __asm__ __volatile__ (
 "rdtsc "
 : "=a" (timelo),
 "=d" (timehi)
 : );

 return ((uint64)timehi << 32) + (uint64)timelo;
 }

#elif defined(G3D_OSX)

 inline uint64 System::getCycleCount() {
 //Note: To put off extra processing until the end, this does not 
 //return the actual clock cycle count. It is a bus cycle count.
 //When endCycleCount() is called, it converts the two into a difference
 //of clock cycles
 
 return (uint64) UnsignedWideToUInt64(UpTime());
 //return (uint64) mach_absolute_time();
 }

#endif

inline void System::beginCycleCount(uint64& cycleCount) {
 cycleCount = getCycleCount();
}


inline void System::endCycleCount(uint64& cycleCount) {
#ifndef G3D_OSX
 cycleCount = getCycleCount() - cycleCount;
#else
 AbsoluteTime end = UpTime();
 Nanoseconds diffNS = 
 AbsoluteDeltaToNanoseconds(end, UInt64ToUnsignedWide(cycleCount));
 cycleCount = 
 (uint64) ((double) (instance().m_OSXCPUSpeed) * 
 (double) UnsignedWideToUInt64(diffNS) * instance().m_secondsPerNS);
#endif
}


} // namespace


#ifdef G3D_OSX
#undef Zone
#endif

#endif