OOLogHeader.m File Reference

import "OOLogHeader.h"
import "OOCPUInfo.h"
import "OOLogging.h"
import "OOOXPVerifier.h"
import "Universe.h"
import "OOStellarBody.h"
import "OOJavaScriptEngine.h"
import "OOSound.h"
#include <sys/sysctl.h>

Include dependency graph for OOLogHeader.m:

Go to the source code of this file.

Macros
#define	CPU_TYPE_STRING   "<unknown architecture with unknown byte order>"
#define	OS_TYPE_STRING   "Mac OS X"
#define	RELEASE_VARIANT_STRING   " test release"
#define	CPUFAMILY_INTEL_MEROM   0x426f69ef
#define	CPUFAMILY_INTEL_HASWELL   0x10b282dc
#define	CPUFAMILY_INTEL_BROADWELL   0x582ed09c
#define	CPUFAMILY_INTEL_SKYLAKE   0x37fc219f

Functions
static NSString *	AdditionalLogHeaderInfo (void)
NSString *	OOPlatformDescription (void)
void	OOPrintLogHeader (void)
static NSString *	GetSysCtlString (const char *name)
static unsigned long long	GetSysCtlInt (const char *name)
static NSString *	GetCPUDescription (void)

Macro Definition Documentation

CPU_TYPE_STRING

#define CPU_TYPE_STRING   "<unknown architecture with unknown byte order>"

CPUFAMILY_INTEL_BROADWELL

#define CPUFAMILY_INTEL_BROADWELL   0x582ed09c

Definition at line 226 of file OOLogHeader.m.

Referenced by GetCPUDescription().

CPUFAMILY_INTEL_HASWELL

#define CPUFAMILY_INTEL_HASWELL   0x10b282dc

Definition at line 222 of file OOLogHeader.m.

Referenced by GetCPUDescription().

CPUFAMILY_INTEL_MEROM

#define CPUFAMILY_INTEL_MEROM   0x426f69ef

Definition at line 218 of file OOLogHeader.m.

Referenced by GetCPUDescription().

CPUFAMILY_INTEL_SKYLAKE

#define CPUFAMILY_INTEL_SKYLAKE   0x37fc219f

Definition at line 230 of file OOLogHeader.m.

Referenced by GetCPUDescription().

OS_TYPE_STRING

#define OS_TYPE_STRING   "Mac OS X"

RELEASE_VARIANT_STRING

#define RELEASE_VARIANT_STRING   " test release"

Function Documentation

AdditionalLogHeaderInfo()

static NSString * AdditionalLogHeaderInfo ( void )

static

Definition at line 206 of file OOLogHeader.m.

{
    NSString                *sysModel = nil;
    unsigned long long      sysPhysMem;
    
    sysModel = GetSysCtlString("hw.model");
    sysPhysMem = GetSysCtlInt("hw.memsize");
    
    return [NSString stringWithFormat:@"Machine type: %@, %llu MiB memory, %@.", sysModel, sysPhysMem >> 20, GetCPUDescription()];
}

References GetSysCtlInt(), GetSysCtlString(), and nil.

Here is the call graph for this function:

GetCPUDescription()

static NSString * GetCPUDescription ( void )

static

Definition at line 234 of file OOLogHeader.m.

{
    NSString            *typeStr = nil, *subTypeStr = nil;
    
    unsigned long long sysCPUType = GetSysCtlInt("hw.cputype");
    unsigned long long sysCPUFamily = GetSysCtlInt("hw.cpufamily");
    unsigned long long sysCPUFrequency = GetSysCtlInt("hw.cpufrequency");
    unsigned long long sysCPUCount = GetSysCtlInt("hw.physicalcpu");
    unsigned long long sysLogicalCPUCount = GetSysCtlInt("hw.logicalcpu");
    
    /*  Note: CPU_TYPE_STRING tells us the build architecture. This gets the
        physical CPU type. They may differ, for instance, when running under
        Rosetta. The code is written for flexibility, although ruling out
        x86 code running on PPC would be entirely reasonable.
    */
    switch (sysCPUType)
    {
        case CPU_TYPE_POWERPC:
            typeStr = @"PowerPC";
            break;
            
        case CPU_TYPE_I386:
            typeStr = @"x86";
            switch (sysCPUFamily)
            {
                case CPUFAMILY_INTEL_MEROM:
                    subTypeStr = @" (Core 2/Merom)";
                    break;
                    
                case CPUFAMILY_INTEL_PENRYN:
                    subTypeStr = @" (Penryn)";
                    break;
                    
                case CPUFAMILY_INTEL_NEHALEM:
                    subTypeStr = @" (Nehalem)";
                    break;
                    
                case CPUFAMILY_INTEL_WESTMERE:
                    subTypeStr = @" (Westmere)";
                    break;
                    
                case CPUFAMILY_INTEL_SANDYBRIDGE:
                    subTypeStr = @" (Sandy Bridge)";
                    break;
                    
                case CPUFAMILY_INTEL_IVYBRIDGE:
                    subTypeStr = @" (Ivy Bridge)";
                    break;
                    
                case CPUFAMILY_INTEL_HASWELL:
                    subTypeStr = @" (Haswell)";
                    break;
                    
                case CPUFAMILY_INTEL_BROADWELL:
                    subTypeStr = @" (Broadwell)";
                    break;
                    
                case CPUFAMILY_INTEL_SKYLAKE:
                    subTypeStr = @" (Skylake)";
                    break;
                    
                default:
                    subTypeStr = [NSString stringWithFormat:@" (family 0x%llx)", sysCPUFamily];
            }
            break;
        
        case CPU_TYPE_ARM:
            typeStr = @"ARM";
    }
    
    if (typeStr == nil)  typeStr = [NSString stringWithFormat:@"CPU type %llu", sysCPUType];
    
    NSString *countStr = nil;
    if (sysCPUCount == sysLogicalCPUCount)  countStr = [NSString stringWithFormat:@"%llu", sysCPUCount];
    else countStr = [NSString stringWithFormat:@"%llu (%llu logical)", sysCPUCount, sysLogicalCPUCount];
    
    return [NSString stringWithFormat:@"%@ x %@%@ @ %llu MHz", countStr, typeStr, subTypeStr, (sysCPUFrequency + 500000) / 1000000];
}

References CPUFAMILY_INTEL_BROADWELL, CPUFAMILY_INTEL_HASWELL, CPUFAMILY_INTEL_MEROM, CPUFAMILY_INTEL_SKYLAKE, GetSysCtlInt(), and nil.

Here is the call graph for this function:

GetSysCtlInt()

static unsigned long long GetSysCtlInt ( const char * name )

static

Definition at line 329 of file OOLogHeader.m.

{
    unsigned long long      llresult = 0;
    unsigned int            intresult = 0;
    size_t                  size;
    
    size = sizeof llresult;
    if (sysctlbyname(name, &llresult, &size, NULL, 0) != 0)  return 0;
    if (size == sizeof llresult)  return llresult;
    
    size = sizeof intresult;
    if (sysctlbyname(name, &intresult, &size, NULL, 0) != 0)  return 0;
    if (size == sizeof intresult)  return intresult;
    
    return 0;
}

Referenced by AdditionalLogHeaderInfo(), and GetCPUDescription().

Here is the caller graph for this function:

GetSysCtlString()

static NSString * GetSysCtlString ( const char * name )

static

Definition at line 314 of file OOLogHeader.m.

{
    char                    *buffer = NULL;
    size_t                  size = 0;
    
    // Get size
    sysctlbyname(name, NULL, &size, NULL, 0);
    if (size == 0)  return nil;
    
    buffer = alloca(size);
    if (sysctlbyname(name, buffer, &size, NULL, 0) != 0)  return nil;
    return [NSString stringWithUTF8String:buffer];
}

References nil.

Referenced by AdditionalLogHeaderInfo().

Here is the caller graph for this function:

OOPlatformDescription()

NSString * OOPlatformDescription

(

void

)

Definition at line 185 of file OOLogHeader.m.

{
    #if OOLITE_MAC_OS_X
        NSString *systemString = [NSString stringWithFormat:@OS_TYPE_STRING " %@", [[NSProcessInfo processInfo] operatingSystemVersionString]];
    #else
        #define systemString @OS_TYPE_STRING
    #endif
    
    return [NSString stringWithFormat:@"%@ ("CPU_TYPE_STRING RELEASE_VARIANT_STRING")", systemString];
}

Referenced by ConsoleGetProperty().

Here is the caller graph for this function:

OOPrintLogHeader()

void OOPrintLogHeader

(

void

)

Definition at line 60 of file OOLogHeader.m.

{
    // Bunch of string literal macros which are assembled into a CPU info string.
    #if defined (__ppc__)
        #define CPU_TYPE_STRING "PPC-32"
    #elif defined (__ppc64__)
        #define CPU_TYPE_STRING "PPC-64"
    #elif defined (__i386__)
        #define CPU_TYPE_STRING "x86-32"
    #elif defined (__x86_64__)
        #define CPU_TYPE_STRING "x86-64"
    #else
        #if OOLITE_BIG_ENDIAN
            #define CPU_TYPE_STRING "<unknown big-endian architecture>"
        #elif OOLITE_LITTLE_ENDIAN
            #define CPU_TYPE_STRING "<unknown little-endian architecture>"
        #else
            #define CPU_TYPE_STRING "<unknown architecture with unknown byte order>"
        #endif
    #endif
    
    #if OOLITE_MAC_OS_X
        #define OS_TYPE_STRING "Mac OS X"
    #elif OOLITE_WINDOWS
        #define OS_TYPE_STRING "Windows"
    #elif OOLITE_LINUX
        #define OS_TYPE_STRING "Linux"  // Hmm, what about other unices?
    #elif OOLITE_SDL
        #define OS_TYPE_STRING "unknown SDL system"
    #else
        #define OS_TYPE_STRING "unknown system"
    #endif
    
    #if OO_DEBUG
        #define RELEASE_VARIANT_STRING " debug"
    #elif !defined (NDEBUG)
        #define RELEASE_VARIANT_STRING " test release"
    #else
        #define RELEASE_VARIANT_STRING ""
    #endif
    
    NSArray *featureStrings = [NSArray arrayWithObjects:
    // User features
    #if OOLITE_OPENAL
        @"OpenAL",
    #endif
 
    #if OO_SHADERS
        @"GLSL shaders",
    #endif
    
    #if NEW_PLANETS
        @"new planets",
    #endif
    
    // Debug features
    #if OO_CHECK_GL_HEAVY
        @"heavy OpenGL error checking",
    #endif
    
    #ifndef OO_EXCLUDE_DEBUG_SUPPORT
        @"JavaScript console support",
        #if OOLITE_MAC_OS_X
            // Under Mac OS X, Debug.oxp adds more than console support.
            @"Debug plug-in support",
        #endif
    #endif
    
    #if OO_OXP_VERIFIER_ENABLED
        @"OXP verifier",
    #endif
    
    #if OO_LOCALIZATION_TOOLS
        @"localization tools",
    #endif
    
    #if DEBUG_GRAPHVIZ
        @"debug GraphViz support",
    #endif
    
    #if OOJS_PROFILE
        #ifdef MOZ_TRACE_JSCALLS
            @"JavaScript profiling",
        #else
            @"JavaScript native callback profiling",
        #endif
    #endif
    
    #if OO_FOV_INFLIGHT_CONTROL_ENABLED
        @"FOV in-flight control",
    #endif
    
        nil];
    
    // systemString: NSString with system type and possibly version.
    #if (OOLITE_MAC_OS_X || (OOLITE_GNUSTEP_1_20 && !OOLITE_WINDOWS))
        NSString *systemString = [NSString stringWithFormat:@OS_TYPE_STRING " %@", [[NSProcessInfo processInfo] operatingSystemVersionString]];
    #elif OOLITE_WINDOWS
        NSString *systemString = [NSString stringWithFormat:@OS_TYPE_STRING " %@ %@-bit", operatingSystemFullVersion(), is64BitSystem() ? @"64":@"32"];
    #else
        #define systemString @OS_TYPE_STRING
    #endif
    
    NSString *versionString = nil;
    #if (defined (SNAPSHOT_BUILD) && defined (OOLITE_SNAPSHOT_VERSION))
        versionString = @"development version " OOLITE_SNAPSHOT_VERSION;
    #else
        versionString = [NSString stringWithFormat:@"version %@", [[[NSBundle mainBundle] infoDictionary] objectForKey:@"CFBundleVersion"]];
    #endif
    if (versionString == nil)  versionString = @"<unknown version>";
    
    NSMutableString *miscString = [NSMutableString stringWithFormat:@"Opening log for Oolite %@ (" CPU_TYPE_STRING RELEASE_VARIANT_STRING ") under %@ at %@.\n", versionString, systemString, [NSDate date]];
    
    [miscString appendString:AdditionalLogHeaderInfo()];
    
    NSString *featureDesc = [featureStrings componentsJoinedByString:@", "];
    if ([featureDesc length] == 0)  featureDesc = @"none";
    [miscString appendFormat:@"\nBuild options: %@.\n", featureDesc];
    
    [miscString appendString:@"\nNote that the contents of the log file can be adjusted by editing logcontrol.plist."];
    
    OOLog(@"log.header", @"%@\n", miscString);
}

References nil, and OOLog.

Referenced by OOLoggingInit().

Here is the caller graph for this function: