G3D::System Class Reference

OS and processor abstraction. More...

#include <System.h>

Public Types
typedef bool(*	OutOfMemoryCallback )(size_t size, bool recoverable)

Static Public Member Functions
static void	cleanup ()
static int	cpuSpeedMHz ()
static int	numCores ()
static bool	hasCPUID ()
static bool	hasRDTSC ()
static bool	hasSSE ()
static bool	hasSSE2 ()
static bool	hasSSE3 ()
static bool	hasMMX ()
static bool	has3DNow ()
static const std::string &	cpuVendor ()
static G3DEndian	machineEndian ()
static const std::string &	operatingSystem ()
static const std::string &	cpuArchitecture ()
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 ()
static const std::string &	version ()
static const std::string &	build ()
	The optimization status of the G3D library (not the program compiled against it) More...
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 ()
static void	setOutOfMemoryCallback (OutOfMemoryCallback c)
static OutOfMemoryCallback	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=true)
static void	setAppDataDir (const std::string &path)

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

Private Member Functions
	System ()
	Used for the singleton instance only. More...
void	getStandardProcessorExtensions ()
void	initTime ()
void	init ()

Static Private Member Functions
static System &	instance ()
	The singleton instance. More...
static void	cpuid (CPUIDFunction func, uint32 &areg, uint32 &breg, uint32 &creg, uint32 &dreg)

Private Attributes
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
struct timeval	m_start
std::string	m_version
OutOfMemoryCallback	m_outOfMemoryCallback
RealTime	m_realWorldGetTickTime0
uint32	m_highestCPUIDFunction

Detailed Description

OS and processor abstraction.

The first time any method is called the processor will be analyzed. Future calls are then fast.

Timing function overview: System::getCycleCount

• actual cycle count

System::getTick

• High-resolution time in seconds since program started

System::getLocalTime

• High-resolution time in seconds since Jan 1, 1970 (because it is stored in a double, this may be less accurate than getTick)

Member Typedef Documentation

typedef bool(* G3D::System::OutOfMemoryCallback)(size_t size, bool recoverable)

Parameters

size	Size of memory that the system was trying to allocate
recoverable	If true, the system will attempt to allocate again if the callback returns true. If false, malloc is going to return NULL and this invocation is just to notify the application.

Returns

Return true to force malloc to attempt allocation again if the error was recoverable.

Member Enumeration Documentation

enum G3D::System::CPUIDFunction

private

Enumerator
CPUID_VENDOR_ID
CPUID_PROCESSOR_FEATURES
CPUID_NUM_CORES
CPUID_GET_HIGHEST_FUNCTION
CPUID_EXTENDED_FEATURES

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

Constructor & Destructor Documentation

G3D::System::System ( )

private

Used for the singleton instance only.

 :
 m_initialized(false),
 m_cpuSpeed(0),
 m_hasCPUID(false),
 m_hasRDTSC(false),
 m_hasMMX(false),
 m_hasSSE(false),
 m_hasSSE2(false),
 m_hasSSE3(false),
 m_has3DNOW(false),
 m_has3DNOW2(false),
 m_hasAMDMMX(false),
 m_cpuVendor("Uninitialized"),
 m_numCores(1),
 m_machineEndian(G3D_LITTLE_ENDIAN),
 m_cpuArch("Uninitialized"),
 m_operatingSystem("Uninitialized"),
 m_version("Uninitialized"),
 m_outOfMemoryCallback(NULL),
 m_realWorldGetTickTime0(0),
 m_highestCPUIDFunction(0) {

 init();
}

Here is the call graph for this function:

Member Function Documentation

void G3D::System::alignedFree ( void *  ptr )

static

Frees memory allocated with alignedMalloc.

 {
 if (_ptr == NULL) {
 return;
 }

 size_t alignedPtr = (size_t)_ptr;

 // Back up one word from the pointer the user passed in.
 // We now have a pointer to a pointer to the true start
 // of the memory block.
 size_t* redirectPtr = (size_t*)(alignedPtr - sizeof(void *));

 // Dereference that pointer so that ptr = true start
 void* truePtr = (void*)redirectPtr[0];

 debugAssert(isValidHeapPointer((void*)truePtr));
 System::free(truePtr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void * G3D::System::alignedMalloc ( size_t  bytes, size_t  alignment  )

static

Guarantees that the start of the array is aligned to the specified number of bytes.

 {

 alwaysAssertM(isPow2((uint32)alignment), "alignment must be a power of 2");

 // We must align to at least a word boundary.
 alignment = max(alignment, sizeof(void *));

 // Pad the allocation size with the alignment size and the size of
 // the redirect pointer. This is the worst-case size we'll need.
 // Since the alignment size is at least teh word size, we don't
 // need to allocate space for the redirect pointer. We repeat the max here
 // for clarity.
 size_t totalBytes = bytes + max(alignment, sizeof(void*));

 size_t truePtr = (size_t)System::malloc(totalBytes);

 if (truePtr == 0) {
 // malloc returned NULL
 return NULL;
 }

 debugAssert(isValidHeapPointer((void*)truePtr));
 #ifdef G3D_WINDOWS
 // The blocks we return will not be valid Win32 debug heap
 // pointers because they are offset 
 // debugAssert(_CrtIsValidPointer((void*)truePtr, totalBytes, TRUE) );
 #endif


 // We want alignedPtr % alignment == 0, which we'll compute with a
 // binary AND because 2^n - 1 has the form 1111... in binary.
 const size_t bitMask = (alignment - 1);

 // The return pointer will be the next aligned location that is at
 // least sizeof(void*) after the true pointer. We need the padding
 // to have a place to write the redirect pointer.
 size_t alignedPtr = truePtr + sizeof(void*);

 const size_t remainder = alignedPtr & bitMask;
 
 // Add what we need to make it to the next alignment boundary, but
 // if the remainder was zero, let it wrap to zero and don't add
 // anything.
 alignedPtr += ((alignment - remainder) & bitMask);

 debugAssert((alignedPtr & bitMask) == 0);
 debugAssert((alignedPtr - truePtr + bytes) <= totalBytes);

 // Immediately before the aligned location, write the true array location
 // so that we can free it correctly.
 size_t* redirectPtr = (size_t *)(alignedPtr - sizeof(void *));
 redirectPtr[0] = truePtr;

 debugAssert(isValidHeapPointer((void*)truePtr));

 #if defined(G3D_WINDOWS) && defined(G3D_DEBUG)
 if (bytes < 0xFFFFFFFF) { 
 debugAssert( _CrtIsValidPointer((void*)alignedPtr, (int)bytes, TRUE) );
 }
 #endif
 return (void *)alignedPtr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::string & G3D::System::appName ( )

static

Name of this program. Note that you can mutate this string to set your app name explicitly.

 {
 static std::string n = computeAppName(filenameBase(currentProgramFilename()));
 return n;
}

Here is the call graph for this function:

void G3D::System::beginCycleCount ( uint64 &  cycleCount )

inlinestatic

To count the number of cycles a given operation takes:

unsigned long count;
System::beginCycleCount(count);
...
System::endCycleCount(count);
// count now contains the cycle count for the intervening operation.

 {
 cycleCount = getCycleCount();
}

Here is the call graph for this function:

Here is the caller graph for this function:

const std::string & G3D::System::build ( )

static

The optimization status of the G3D library (not the program compiled against it)

Either "Debug" or "Release", depending on whether _DEBUG was defined at compile-time for the library.

 {
 const static std::string b =
# ifdef _DEBUG
 "Debug";
# else 
 "Release";
# endif

 return b;
}

void * G3D::System::calloc ( size_t  n, size_t  x  )

static

 {
#ifndef NO_BUFFERPOOL
 void* b = System::malloc(n * x);
 debugAssertM(b != NULL, "System::malloc returned NULL");
 debugAssertM(isValidHeapPointer(b), "System::malloc returned an invalid pointer");
 System::memset(b, 0, n * x);
 return b;
#else
 return ::calloc(n, x);
#endif
}

Here is the call graph for this function:

void G3D::System::cleanup ( )

static

atexit handling code invoked from G3DCleanupHook.

 {
 lastFound.clear();
 directoryArray.clear();
}

Here is the call graph for this function:

void G3D::System::consoleClearScreen ( )

static

Clears the console. Console programs only.

 {
# ifdef G3D_WINDOWS
 (void)system("cls");
# else
 (void)system("clear");
# endif
}

bool G3D::System::consoleKeyPressed ( )

static

Returns true if a key is waiting. Console programs only.

 {
 #ifdef G3D_WINDOWS
 
 return _kbhit() != 0;

 #else
 
 static const int STDIN = 0;
 static bool initialized = false;

 if (! initialized) {
 // Use termios to turn off line buffering
 termios term;
 tcgetattr(STDIN, &term);
 term.c_lflag &= ~ICANON;
 tcsetattr(STDIN, TCSANOW, &term);
 setbuf(stdin, NULL);
 initialized = true;
 }

 #ifdef G3D_LINUX

 int bytesWaiting;
 ioctl(STDIN, FIONREAD, &bytesWaiting);
 return bytesWaiting;

 #else

 timeval timeout;
 fd_set rdset;

 FD_ZERO(&rdset);
 FD_SET(STDIN, &rdset);
 timeout.tv_sec = 0;
 timeout.tv_usec = 0;

 return select(STDIN + 1, &rdset, NULL, NULL, &timeout);
 #endif
 #endif
}

int G3D::System::consoleReadKey ( )

static

Blocks until a key is read (use consoleKeyPressed to determine if a key is waiting to be read) then returns the character code for that key.

 {
# ifdef G3D_WINDOWS
 return _getch();
# else
 char c;
 (void)read(0, &c, 1);
 return c;
# endif
}

static const std::string& G3D::System::cpuArchitecture ( )

inlinestatic

e.g., 80686

 {
 return instance().m_cpuArch;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::System::cpuid ( CPUIDFunction  func, uint32 &  areg, uint32 &  breg, uint32 &  creg, uint32 &  dreg  )

staticprivate

Helper macro to call cpuid functions and return all values

See http://software.intel.com/en-us/articles/intel-64-architecture-processor-topology-enumeration/ or http://www.amd.com/us-en/assets/content_type/white_papers_and_tech_docs/25481.pdf

for description of the arguments.

 {
#if ! defined(__PIC__) || defined(__x86_64__)
 // AT&T assembler syntax
 asm volatile(
 "movl $0, %%ecx \n\n" /* Wipe ecx */
 "cpuid \n\t"
 : "=a"(eax), "=b"(ebx), "=c"(ecx), "=d"(edx)
 : "a"(func));
#else
 // AT&T assembler syntax
 asm volatile(
 "pushl %%ebx \n\t" /* save ebx */
 "movl $0, %%ecx \n\n" /* Wipe ecx */
 "cpuid \n\t"
 "movl %%ebx, %1 \n\t" /* save what cpuid just put in %ebx */
 "popl %%ebx \n\t" /* restore the old ebx */
 : "=a"(eax), "=r"(ebx), "=c"(ecx), "=d"(edx)
 : "a"(func));
#endif
}

Here is the caller graph for this function:

static int G3D::System::cpuSpeedMHz ( )

inlinestatic

Returns the speed of processor 0 in MHz. Always returns 0 on linux.

 {
 return instance().m_cpuSpeed;
 }

Here is the call graph for this function:

static const std::string& G3D::System::cpuVendor ( )

inlinestatic

 {
 return instance().m_cpuVendor;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::string G3D::System::currentDateString ( )

static

Returns the current date as a string in the form YYYY-MM-DD

 {
 time_t t1;
 ::time(&t1);
 tm* t = localtime(&t1);
 return format("%d-%02d-%02d", t->tm_year + 1900, t->tm_mon + 1, t->tm_mday); 
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::string G3D::System::currentProgramFilename ( )

static

Returns the fully qualified filename for the currently running executable.

This is more reliable than arg[0], which may be intentionally set to an incorrect value by a calling program, relative to a now non-current directory, or obfuscated by sym-links.

[Linux] version written by Nicolai Haehnle prefe.[email protected]ct_@.[email protected]gmx.n.[email protected]et, http://www.flipcode.com/cgi-bin/msg.cgi?showThread=COTD-getexename&forum=cotd&id=-1

 {
 char filename[2048];

# ifdef G3D_WINDOWS
 {
 GetModuleFileNameA(NULL, filename, sizeof(filename));
 } 
# elif defined(G3D_OSX)
 {
 // Run the 'ps' program to extract the program name
 // from the process ID.
 int pid;
 FILE* fd;
 char cmd[80];
 pid = getpid();
 sprintf(cmd, "ps -p %d -o comm=\"\"", pid);

 fd = popen(cmd, "r");
 int s = fread(filename, 1, sizeof(filename), fd);
 // filename will contain a newline. Overwrite it:
 filename[s - 1] = '\0';
 pclose(fd);
 }
# else
 {
 int ret = readlink("/proc/self/exe", filename, sizeof(filename));
 
 // In case of an error, leave the handling up to the caller
 if (ret == -1) {
 return "";
 }
 
 debugAssert((int)sizeof(filename) > ret);
 
 // Ensure proper NULL termination
 filename[ret] = 0; 
 }
 #endif

 return filename;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::string G3D::System::currentTimeString ( )

static

Returns the current 24-hour local time as a string in the form HH:MM:SS

 {
 time_t t1;
 ::time(&t1);
 tm* t = localtime(&t1);
 return format("%02d:%02d:%02d", t->tm_hour, t->tm_min, t->tm_sec);
}

Here is the call graph for this function:

void G3D::System::describeSystem ( class TextOutput &  t )

static

Prints a human-readable description of this machine to the text output stream. Either argument may be NULL.

 {

 t.writeSymbols("App", "{");
 t.writeNewline();
 t.pushIndent();
 {
 var(t, "Name", System::currentProgramFilename());
 char cwd[1024];
 (void)getcwd(cwd, 1024);
 var(t, "cwd", std::string(cwd));
 }
 t.popIndent();
 t.writeSymbols("}");
 t.writeNewline();
 t.writeNewline();

 t.writeSymbols("OS", "{");
 t.writeNewline();
 t.pushIndent();
 {
 var(t, "Name", System::operatingSystem());
 }
 t.popIndent();
 t.writeSymbols("}");
 t.writeNewline();
 t.writeNewline();

 t.writeSymbols("CPU", "{");
 t.writeNewline();
 t.pushIndent();
 {
 var(t, "Vendor", System::cpuVendor());
 var(t, "Architecture", System::cpuArchitecture());
 var(t, "hasCPUID", System::hasCPUID());
 var(t, "hasMMX", System::hasMMX());
 var(t, "hasSSE", System::hasSSE());
 var(t, "hasSSE2", System::hasSSE2());
 var(t, "hasSSE3", System::hasSSE3());
 var(t, "has3DNow", System::has3DNow());
 var(t, "hasRDTSC", System::hasRDTSC());
 var(t, "numCores", System::numCores());
 }
 t.popIndent();
 t.writeSymbols("}");
 t.writeNewline();
 t.writeNewline();
 
 t.writeSymbols("G3D", "{");
 t.writeNewline();
 t.pushIndent();
 {
 const char* g3dPath = getenv("G3D9DATA");
 var(t, "Link version", G3D_VER);
 var(t, "Compile version", System::version());
 var(t, "G3D9DATA", std::string(g3dPath ? g3dPath : ""));
 }
 t.popIndent();
 t.writeSymbols("}");
 t.writeNewline();
 t.writeNewline();
}

Here is the call graph for this function:

void G3D::System::describeSystem ( std::string &  s )

static

 {

 TextOutput t;
 describeSystem(t);
 t.commitString(s);
}

Here is the call graph for this function:

void G3D::System::endCycleCount ( uint64 &  cycleCount )

inlinestatic

 {
#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
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::string G3D::System::findDataFile ( const std::string &  full, bool  exceptionIfNotFound = true, bool  caseSensitive = true  )

static

Tries to locate the resource by looking in related directories. If found, returns the full path to the resource, otherwise returns the empty string.

Looks in:

- Literal interpretation of full (i.e., if it contains a fully-qualified name)
- Last directory in which a file was found
- Current directory
- System::appDataDir (which is usually GApp::Settings.dataDir, which defaults to the directory containing the program binary)
- $G3D9DATA directory
- System::appDataDir() + "data/"  (note that this may be a zipfile named "data" with no extension)
- System::appDataDir() + "data.zip/"
- ../data-files/  (windows)
- ../../data-files/ (windows)
- ../../../data-files/ (windows)

Plus the following subdirectories of those:

• cubemap
• gui
• font
• icon
• models
• image
• sky
• md2
• md3
• ifs
• 3ds

Parameters

exceptionIfNotFound

If true and the file is not found, throws G3D::FileNotFound.

 {
MARK_LOG();

 const std::string full = FilePath::expandEnvironmentVariables(_full);

 // First check if the file exists as requested. This will go
 // through the FileSystemCache, so most calls do not touch disk.
 if (FileSystem::exists(full, true, caseSensitive)) {
 return full;
 }

MARK_LOG();
 // Now check where we previously found this file.
 std::string* last = lastFound.getPointer(full);
 if (last != NULL) {
 if (FileSystem::exists(*last, true, caseSensitive)) {
 // Even if cwd has changed the file is still present.
 // We won't notice if it has been deleted, however.
 return *last;
 } else {
 // Remove this from the cache it is invalid
 lastFound.remove(full);
 }
 }

MARK_LOG();

 const std::string initialAppDataDir(instance().m_appDataDir);
 const char* g3dPath = getenv("G3D9DATA");

 if (directoryArray.size() == 0) {
 // Initialize the directory array
 RealTime t0 = System::time();

 Array<std::string> baseDirArray;
 
 baseDirArray.append(FileSystem::currentDirectory());
MARK_LOG();
 if (! initialAppDataDir.empty()) {
MARK_LOG();
 baseDirArray.append(initialAppDataDir);
 baseDirArray.append(pathConcat(initialAppDataDir, "data"));
 baseDirArray.append(pathConcat(initialAppDataDir, "data.zip"));
 } else {
MARK_LOG();
 baseDirArray.append("data");
 baseDirArray.append("data.zip");
 }
MARK_LOG();

# ifdef G3D_WINDOWS
 if (g3dPath == NULL) {
 // If running the demos under visual studio from the G3D.sln file,
 // this will locate the data directory.
 const char* paths[] = {"../data-files/", "../../data-files/", "../../../data-files/", NULL};
 for (int i = 0; paths[i]; ++i) {
 if (FileSystem::exists(pathConcat(paths[i], "G3D-DATA-README.TXT"), true, caseSensitive)) {
 g3dPath = paths[i];
 break;
 }
 }
 }
# endif

 if (g3dPath && (initialAppDataDir != g3dPath)) {
 baseDirArray.append(g3dPath);
 }

 static const std::string subdirs[] = 
 {"font", "gui", "shader", "model", "cubemap", "icon", "material", "image", "md2", "md3", "ifs", "3ds", "sky", "music", "sound", "scene", ""};
 for (int j = 0; j < baseDirArray.size(); ++j) {
 std::string d = baseDirArray[j];
//logPrintf("%s", d.c_str());
 if ((d == "") || FileSystem::exists(d)) {
//logPrintf(" exists\n");
 directoryArray.append(d);
 for (int i = 0; ! subdirs[i].empty(); ++i) {
 const std::string& p = pathConcat(d, subdirs[i]);
 if (FileSystem::exists(p, true, caseSensitive)) {
 directoryArray.append(p);
 }
 }
 } else {
//logPrintf(" does not exist\n");
 }
 }

 logLazyPrintf("Initializing System::findDataFile took %fs\n", System::time() - t0);

 }
MARK_LOG();

 for (int i = 0; i < directoryArray.size(); ++i) {
 const std::string& p = pathConcat(directoryArray[i], full);
 if (FileSystem::exists(p, true, caseSensitive)) {
 lastFound.set(full, p);
 return p;
 }
 }
MARK_LOG();

 if (errorIfNotFound) {
 // Generate an error message. Delay this operation until we know that we need it;
 // otherwise all of the string concatenation would run on each successful find.
 std::string locations;
 for (int i = 0; i < directoryArray.size(); ++i) {
 locations += "\'" + pathConcat(directoryArray[i], full) + "'\n";
 }
MARK_LOG();

 std::string msg = "Could not find '" + full + "'.\n\n";
 msg += " cwd = '" + FileSystem::currentDirectory() + "'\n";
 if (g3dPath) {
 msg += " G3D9DATA = '" + std::string(g3dPath) + "'";
 if (! FileSystem::exists(g3dPath, true, caseSensitive)) {
 msg += " (illegal path!)";
 }
 msg += "\n";
 } else {
 msg += " G3D9DATA = (environment variable is not defined)\n";
 }
MARK_LOG();
 msg += " GApp::Settings.dataDir = '" + initialAppDataDir + "'";
 if (! FileSystem::exists(initialAppDataDir, true, caseSensitive)) {
 msg += " (illegal path!)";
 }
 msg += "\n";

 msg += "\nFilenames tested:\n" + locations;

MARK_LOG();
logPrintf("%s\n", msg.c_str());
 throw FileNotFound(full, msg);
 alwaysAssertM(false, msg);
 }
MARK_LOG();

 // Not found
 return "";
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::System::free ( void *  p )

static

Free data allocated with System::malloc.

Threadsafe on Win32.

 {
#ifndef NO_BUFFERPOOL
 bufferpool->free(p);
#else
 return ::free(p);
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

static uint64 G3D::System::getCycleCount ( )

static

Here is the caller graph for this function:

const char * G3D::System::getEnv ( const std::string &  name )

static

Get an environment variable for the current process. Returns NULL if the variable doesn't exist.

 {
 return getenv(name.c_str());
}

void G3D::System::getStandardProcessorExtensions ( )

private

Called from init()

 {
#if ! defined(G3D_OSX) || defined(G3D_OSX_INTEL)
 if (! m_hasCPUID) {
 return;
 }

 uint32 eaxreg = 0, ebxreg = 0, ecxreg = 0, features = 0;

 cpuid(CPUID_PROCESSOR_FEATURES, eaxreg, ebxreg, ecxreg, features);

# define checkBit(var, bit) ((var & (1 << bit)) ? true : false)

 m_hasRDTSC = checkBit(features, 4);
 m_hasMMX = checkBit(features, 23);
 m_hasSSE = checkBit(features, 25);
 m_hasSSE2 = checkBit(features, 26);
 // Bit 28 is HTT; not checked by G3D

 m_hasSSE3 = checkBit(ecxreg, 0);

 if (m_highestCPUIDFunction >= CPUID_EXTENDED_FEATURES) {
 cpuid(CPUID_EXTENDED_FEATURES, eaxreg, ebxreg, ecxreg, features);
 m_hasAMDMMX = checkBit(features, 22); // Only on AMD
 m_has3DNOW = checkBit(features, 31); // Only on AMD
 m_has3DNOW2 = checkBit(features, 30); // Only on AMD
 } else {
 m_hasAMDMMX = false;
 m_has3DNOW = false;
 m_has3DNOW2 = false;
 }

# undef checkBit
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bool G3D::System::has3DNow ( )

inlinestatic

 {
 return instance().m_has3DNOW;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool G3D::System::hasCPUID ( )

inlinestatic

 {
 return instance().m_hasCPUID;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool G3D::System::hasMMX ( )

inlinestatic

 {
 return instance().m_hasMMX;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool G3D::System::hasRDTSC ( )

inlinestatic

 {
 return instance().m_hasRDTSC;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool G3D::System::hasSSE ( )

inlinestatic

 {
 return instance().m_hasSSE;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool G3D::System::hasSSE2 ( )

inlinestatic

 {
 return instance().m_hasSSE2;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool G3D::System::hasSSE3 ( )

inlinestatic

 {
 return instance().m_hasSSE3;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::System::init ( )

private

 {
 // NOTE: Cannot use most G3D data structures or utility functions
 // in here because they are not initialized.

 if (m_initialized) {
 return;
 } else {
 m_initialized = true;
 }

 getG3DVersion(m_version);
 
 m_machineEndian = checkEndian();

 m_hasCPUID = checkForCPUID();
 // Process the CPUID information
 if (m_hasCPUID) {
 // We read the standard CPUID level 0x00000000 which should
 // be available on every x86 processor. This fills out
 // a string with the processor vendor tag.
 unsigned int eaxreg = 0, ebxreg = 0, ecxreg = 0, edxreg = 0;

 cpuid(CPUID_VENDOR_ID, eaxreg, ebxreg, ecxreg, edxreg);

 {
 char c[100];
 // Then we connect the single register values to the vendor string
 *((unsigned int*) c) = ebxreg;
 *((unsigned int*) (c + 4)) = edxreg;
 *((unsigned int*) (c + 8)) = ecxreg;
 c[12] = '\0';
 m_cpuVendor = c;
 }

 switch (ebxreg) {
 case 0x756E6547: // GenuineIntel
 m_cpuArch = "Intel Processor";
 break;
 
 case 0x68747541: // AuthenticAMD
 m_cpuArch = "AMD Processor";
 break;

 default:
 m_cpuArch = "Unknown Processor Vendor";
 break;
 }


 unsigned int highestFunction = eaxreg;
 if (highestFunction >= CPUID_NUM_CORES) {
 cpuid(CPUID_NUM_CORES, eaxreg, ebxreg, ecxreg, edxreg);
 // Number of cores is in (eax>>26) + 1
 m_numCores = (eaxreg >> 26) + 1;
 }

 cpuid(CPUID_GET_HIGHEST_FUNCTION, m_highestCPUIDFunction, ebxreg, ecxreg, edxreg);
 }


 // Get the operating system name (also happens to read some other information)
# ifdef G3D_WINDOWS
 HRESULT r = OleInitialize(NULL);
 // Note that this overrides some of the values computed above
 bool success = RegistryUtil::readInt32
 ("HKEY_LOCAL_MACHINE\\HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0", 
 "~MHz", m_cpuSpeed);
 HRESULT s = OleInitialize(NULL);
 SYSTEM_INFO systemInfo;
 GetSystemInfo(&systemInfo);
 const char* arch = NULL;
 switch (systemInfo.wProcessorArchitecture) {
 case PROCESSOR_ARCHITECTURE_INTEL:
 arch = "x86 Intel";
 break;
 
 case PROCESSOR_ARCHITECTURE_AMD64:
 arch = "x64 Intel/AMD";
 break;

 case PROCESSOR_ARCHITECTURE_ARM:
 arch = "ARM";
 break;

 default:
 arch = "Unknown";
 break;
 }

 m_numCores = systemInfo.dwNumberOfProcessors;
 uint64_t maxAddr = reinterpret_cast<uint64_t>(systemInfo.lpMaximumApplicationAddress);
 {
 char c[1024];
 sprintf(c, "%d - %s cores",
 systemInfo.dwNumberOfProcessors,
 arch);
 m_cpuArch = c;
 }

 OSVERSIONINFO osVersionInfo;
 osVersionInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
 success = GetVersionEx(&osVersionInfo) != 0;

 if (success) {
 char c[1000];
 sprintf(c, "Windows %d.%d build %d Platform %d %s",
 osVersionInfo.dwMajorVersion,
 osVersionInfo.dwMinorVersion,
 osVersionInfo.dwBuildNumber,
 osVersionInfo.dwPlatformId,
 osVersionInfo.szCSDVersion);
 m_operatingSystem = c;
 } else {
 m_operatingSystem = "Windows";
 }
 
# elif defined(G3D_LINUX) || defined(G3D_FREEBSD)

 {
 // Find the operating system using the 'uname' command
 FILE* f = popen("uname -a", "r");

 int len = 100;
 char* r = (char*)::malloc(len * sizeof(char));
 (void)fgets(r, len, f);
 // Remove trailing newline
 if (r[strlen(r) - 1] == '\n') {
 r[strlen(r) - 1] = '\0';
 }
 fclose(f);
 f = NULL;

 m_operatingSystem = r;
 ::free(r);
 }

# elif defined(G3D_OSX)

 // Operating System:
 SInt32 macVersion;
 Gestalt(gestaltSystemVersion, &macVersion);

 int major = (macVersion >> 8) & 0xFF;
 int minor = (macVersion >> 4) & 0xF;
 int revision = macVersion & 0xF;

 {
 char c[1000];
 sprintf(c, "OS X %x.%x.%x", major, minor, revision); 
 m_operatingSystem = c;
 }
 
 // Clock Cycle Timing Information:
 Gestalt('pclk', &m_OSXCPUSpeed);
 m_cpuSpeed = iRound((double)m_OSXCPUSpeed / (1024 * 1024));
 m_secondsPerNS = 1.0 / 1.0e9;
 
 // System Architecture:
 const NXArchInfo* pInfo = NXGetLocalArchInfo();
 
 if (pInfo) {
 m_cpuArch = pInfo->description;
 
 switch (pInfo->cputype) {
 case CPU_TYPE_POWERPC:
 switch(pInfo->cpusubtype){
 case CPU_SUBTYPE_POWERPC_750:
 case CPU_SUBTYPE_POWERPC_7400:
 case CPU_SUBTYPE_POWERPC_7450:
 m_cpuVendor = "Motorola";
 break;
 case CPU_SUBTYPE_POWERPC_970:
 m_cpuVendor = "IBM";
 break;
 }
 break;
 
 case CPU_TYPE_I386:
 m_cpuVendor = "Intel";
 break;
 }
 }
# endif

 initTime();

 getStandardProcessorExtensions();

 m_appDataDir = FilePath::parent(System::currentProgramFilename());
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::System::initTime ( )

private

Called from init()

                      {
    #ifdef G3D_WINDOWS
        if (QueryPerformanceFrequency(&m_counterFrequency)) {
            QueryPerformanceCounter(&m_start);
        }

        struct _timeb t;
        _ftime(&t);
        
        m_realWorldGetTickTime0 = (RealTime)t.time - t.timezone * G3D::MINUTE + (t.dstflag ? G3D::HOUR : 0);

    #else
        gettimeofday(&m_start, NULL);
        // "sse" = "seconds since epoch".  The time
        // function returns the seconds since the epoch
        // GMT (perhaps more correctly called UTC). 
        time_t gmt = ::time(NULL);
        
        // No call to free or delete is needed, but subsequent
        // calls to asctime, ctime, mktime, etc. might overwrite
        // local_time_vals. 
        tm* localTimeVals = localtime(&gmt);
    
        time_t local = gmt;
        
        if (localTimeVals) {
            // tm_gmtoff is already corrected for daylight savings.
            local = local + localTimeVals->tm_gmtoff;
        }
        
        m_realWorldGetTickTime0 = local;
    #endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

System & G3D::System::instance ( )

staticprivate

The singleton instance.

Used instead of a global variable to ensure that the order of intialization is correct, which is critical because other globals may allocate memory using System::malloc.

                         {
    static System thesystem;
    return thesystem;
}

Here is the caller graph for this function:

static G3DEndian G3D::System::machineEndian ( )

inlinestatic

Returns the endianness of this machine.

                                            {
        return instance().m_machineEndian;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

void * G3D::System::malloc ( size_t  bytes )

static

Uses pooled storage to optimize small allocations (1 byte to 5 kilobytes). Can be 10x to 100x faster than calling malloc or new.

The result must be freed with free.

Threadsafe on Win32.

See also

calloc realloc OutOfMemoryCallback free

                                 {
#ifndef NO_BUFFERPOOL
    initMem();
    return bufferpool->malloc(bytes);
#else
    return ::malloc(bytes);
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::string G3D::System::mallocPerformance ( )

static

Returns a string describing how well System::malloc is using its internal pooled storage. "heap" memory was slow to allocate; the other data sizes are comparatively fast.

                                    {    
#ifndef NO_BUFFERPOOL
    return bufferpool->performance();
#else
    return "NO_BUFFERPOOL";
#endif
}

Here is the call graph for this function:

std::string G3D::System::mallocStatus ( )

static

Returns a string describing the current usage of the buffer pools used for optimizing System::malloc.

                               {    
#ifndef NO_BUFFERPOOL
    return bufferpool->status();
#else
    return "NO_BUFFERPOOL";
#endif
}

Here is the call graph for this function:

void G3D::System::memcpy ( void *  dst, const void *  src, size_t  numBytes  )

static

An implementation of memcpy that may be up to 2x as fast as the C library one on some processors. Guaranteed to have the same behavior as memcpy in all cases.

                                                               {
#if defined(G3D_WINDOWS) && defined(_M_IX86) && !defined(__MINGW32__) /* G3DFIX: Don't check if on 64-bit Windows platforms or using MinGW */
    // The overhead of our memcpy seems to only be worthwhile on large arrays
    if (((size_t)dst % 16 == 0) && ((size_t)src % 16 == 0) && (numBytes > 3400000)) {
        memcpyMMX(dst, src, numBytes);
    } else {
        ::memcpy(dst, src, numBytes);
    }
#else
    ::memcpy(dst, src, numBytes);
#endif
}

Here is the caller graph for this function:

void G3D::System::memset ( void *  dst, uint8  value, size_t  numBytes  )

static

An implementation of memset that may be up to 2x as fast as the C library one on some processors. Guaranteed to have the same behavior as memset in all cases.

Michael Herf's fastest memset. n32 must be filled with the same character repeated.

                                                           {
    alwaysAssertM(dst != NULL, "Cannot memset NULL address.");
#if defined(G3D_WINDOWS) && defined(_M_IX86) && !defined(__MINGW32__) /* G3DFIX: Don't check if on 64-bit Windows platforms or using MinGW */
    if ((((size_t)dst % 16) == 0) && (numBytes >= 512*1024)) {
        uint32 v = value;
        v = v + (v << 8) + (v << 16) + (v << 24); 
        G3D::memfill(dst, v, numBytes);
    } else {
        ::memset(dst, value, numBytes);
    }
#else
    ::memset(dst, value, numBytes);
#endif
}

Here is the caller graph for this function:

static int G3D::System::numCores ( )

inlinestatic

Returns the number of logical processor cores (i.e., the number of execution units for threads)

                                 {
        return instance().m_numCores;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

static const std::string& G3D::System::operatingSystem ( )

inlinestatic

e.g., "Windows", "GNU/Linux"

                                                     {
        return instance().m_operatingSystem;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

static OutOfMemoryCallback G3D::System::outOfMemoryCallback ( )

inlinestatic

When System::malloc fails to allocate memory because the system is out of memory, it invokes this handler (if it is not NULL). The argument to the callback is the amount of memory that malloc was trying to allocate when it ran out. If the callback returns true, System::malloc will attempt to allocate the memory again. If the callback returns false, then System::malloc will return NULL.

You can use outOfMemoryCallback to free data structures or to register the failure.

                                                            {
        return instance().m_outOfMemoryCallback;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

void * G3D::System::realloc ( void *  block, size_t  bytes  )

static

Version of realloc that works with System::malloc.

                                               {
#ifndef NO_BUFFERPOOL
    initMem();
    return bufferpool->realloc(block, bytes);
#else
    return ::realloc(block, bytes);
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::System::resetMallocPerformanceCounters ( )

static

                                            {
#ifndef NO_BUFFERPOOL
    bufferpool->totalMallocs         = 0;
    bufferpool->mallocsFromMedPool   = 0;
    bufferpool->mallocsFromSmallPool = 0;
    bufferpool->mallocsFromTinyPool  = 0;
#endif
}

void G3D::System::setAppDataDir ( const std::string &  path )

static

Sets the path that the application is using as its data directory. Used by findDataDir as an initial search location. GApp sets this upon constrution.

                                                {
    instance().m_appDataDir = path;

    // Wipe the findDataFile cache
    lastFound.clear();
    directoryArray.clear();
}

Here is the call graph for this function:

void G3D::System::setEnv ( const std::string &  name, const std::string &  value  )

static

Set an environment variable for the current process

                                                                 {
    std::string cmd = name + "=" + value;
#   ifdef G3D_WINDOWS
        _putenv(cmd.c_str());
#   else
        // Many linux implementations of putenv expect char*
        putenv(const_cast<char*>(cmd.c_str()));
#   endif
}

static void G3D::System::setOutOfMemoryCallback ( OutOfMemoryCallback  c )

inlinestatic

                                                                     {
        instance().m_outOfMemoryCallback = c;
    }

Here is the call graph for this function:

void G3D::System::sleep ( RealTime  t )

static

Causes the current thread to yield for the specified duration and consume almost no CPU. The sleep will be extremely precise; it uses System::time() to calibrate the exact yeild time.

{
    ::Sleep( ms );
}

Here is the caller graph for this function:

RealTime G3D::System::time ( )

static

The actual time (measured in seconds since Jan 1 1970 midnight).

Adjusted for local timezone and daylight savings time. This is as accurate and fast as getCycleCount().

                      { 
#   ifdef G3D_WINDOWS
        LARGE_INTEGER now;
        QueryPerformanceCounter(&now);

        return ((RealTime)(now.QuadPart - instance().m_start.QuadPart) /
                instance().m_counterFrequency.QuadPart) + instance().m_realWorldGetTickTime0;
#   else
        // Linux resolution defaults to 100Hz.
        // There is no need to do a separate RDTSC call as gettimeofday
        // actually uses RDTSC when on systems that support it, otherwise
        // it uses the system clock.
        struct timeval now;
        gettimeofday(&now, NULL);

        return (now.tv_sec  - instance().m_start.tv_sec) +
            (now.tv_usec - instance().m_start.tv_usec) / 1e6
            + instance().m_realWorldGetTickTime0;
#   endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

static const std::string& G3D::System::version ( )

inlinestatic

G3D Version string

                                             {
        return instance().m_version;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

std::string G3D::System::m_appDataDir

private

this holds the data directory set by the application (currently GApp) for use by findDataFile

std::string G3D::System::m_cpuArch

private

int G3D::System::m_cpuSpeed

private

std::string G3D::System::m_cpuVendor

private

bool G3D::System::m_has3DNOW

private

bool G3D::System::m_has3DNOW2

private

bool G3D::System::m_hasAMDMMX

private

bool G3D::System::m_hasCPUID

private

bool G3D::System::m_hasMMX

private

bool G3D::System::m_hasRDTSC

private

bool G3D::System::m_hasSSE

private

bool G3D::System::m_hasSSE2

private

bool G3D::System::m_hasSSE3

private

uint32 G3D::System::m_highestCPUIDFunction

private

bool G3D::System::m_initialized

private

G3DEndian G3D::System::m_machineEndian

private

int G3D::System::m_numCores

private

std::string G3D::System::m_operatingSystem

private

OutOfMemoryCallback G3D::System::m_outOfMemoryCallback

private

RealTime G3D::System::m_realWorldGetTickTime0

private

The Real-World time of System::getTick() time 0. Set by initTime

struct timeval G3D::System::m_start

private

std::string G3D::System::m_version

private

---

The documentation for this class was generated from the following files:

• dep/g3dlite/include/G3D/System.h
• dep/efsw/src/efsw/platform/win/SystemImpl.cpp
• dep/efsw/src/efsw/System.cpp