name: Machine

synopsis:


g++ [flags ...] file ... -l /isip/tools/lib/$ISIP_BINARY/lib_mmedia.a

#include <Machine.h>

static boolean diagnose(Integral::DEBUG debug_level);
PROTOCOL getProtocol();
boolean setProtocol(PROTOCOL arg);
String& getNodeName();
boolean setNodeName(String& arg);
String& getArchitecture();
boolean setArchitecture(String& arg);
long getNumProcessors();
boolean setNumProcessors(long arg);
VectorDouble& getProcessorSpeed();
boolean setProcessorSpeed(VectorDouble& arg);
double getMainMemory();
boolean setMainMemory(double arg);
double getSwapMemory();
boolean setSwapMemory(double arg);
String& getOS();
boolean setOS(String& arg);
String& getOSVersion();
boolean setOSVersion(String& arg);

quick start:


String tmp_str;
Machine mach_00;

tmp_str.assign(L"isip004");
mach_00.setNodeName(tmp_str);
mach_00.getNodeName().eq(tmp_str);

description:

This class is used to represent a machine and its corresponding attributes.

dependencies:

String.h

public constants:

define the class name:

static const String CLASS_NAME = L"Machine";

define the protocol choices:

enum PROTOCOL { REMOTE_SHELL = 0, SECURE_SHELL, DEF_PROTOCOL = REMOTE_SHELL };

define i/o related constants:

static const String DEF_PARAM;

static const String PARAM_PROTOCOL;

static const String PARAM_NODE_NAME;

static const String PARAM_ARCHITECTURE;

static const String PARAM_NUM_PROCESSORS;

static const String PARAM_PROCESSOR_SPEED;

static const String PARAM_MAIN_MEMORY;

static const String PARAM_SWAP_MEMORY;

static const String PARAM_OS_NAME;

static const String PARAM_OS_VERSION;

define default values and arguments:

static const long DEF_NUM_PROCESSORS = 1;

static const double DEF_PROCESSOR_SPEED = 3.0e8;

static const double DEF_MAIN_MEMORY = 0.0;

static const double DEF_SWAP_MEMORY = 0.0;

define NameMap objects:
```
static const NameMap PROTOCOL_MAP;
```

error codes:

error codes indicating general errors:

protected data:

declare the preferred connection protocol for the machine (rsh/ssh):

PROTOCOL protocol_d;

declare the nodename of the machine (isip100.isip.msstate.edu):

String node_name_d;

declare the machine architecture (pentium/sparc):

String architecture_d;

declare the number of processors on the machine (single/dual):

Long num_processors_d;

declare the speed of the processor on the machine (8.0e08/1.0e09):

VectorDouble speed_d;

declare the amount of main memory on the machine (1.0e09/2.0e09):

Double main_memory_d;

declare the amount of swap space on the machine (1.0e06/2.0e06):

Double swap_memory_d;

declare the operating system on the machine (solaris/linux):

String os_d;

declare the operating system version on the machine (v_7.0/v_8.0):

String os_version_d;

declare the debugging parameters:
```
static Integral::DEBUG debug_level_d;
```
declare the memory manager:
```
static MemoryManager mgr_d;
```

required public methods:

static methods:
```
static const String& name();
```

debug methods:

boolean debug(const unichar* msg) const;

static boolean setDebug(Integral::DEBUG arg);

static boolean diagnose(Integral::DEBUG debug_level);

destructor/constructor(s):

~Machine();

Machine();

Machine(const Machine& arg);

assign methods:
```
boolean assign(const Machine& arg);
```
operator= method:
```
not present.
```

i/o methods:

long sofSize() const;

boolean read(Sof& sof, long tag);

boolean read(Sof& sof, long tag, const String& name);

boolean write(Sof& sof, long tag) const;

boolean write(Sof& sof, long tag, const String& name) const;

boolean readData(Sof& sof, const String& pname = DEF_PARAM, long size = SofParser::FULL_OBJECT, boolean param = true, boolean nested = false);

boolean writeData(Sof& sof, const String& pname =  DEF_PARAM) const;

equality methods:
```
boolean eq(const Machine& arg) const;
```

memory management methods:

static void* operator new(size_t arg);

static void* operator new[](size_t arg);

static void operator delete(void* arg);

static void operator delete[](void* arg);

static boolean setGrowSize(long arg);

boolean clear(Integral::CMODE cmode = Integral::DEF_CMODE);

class-specific public methods:

declare protocol related methods:

PROTOCOL getProtocol();

boolean setProtocol(PROTOCOL arg);

declare node name related methods:

String& getNodeName();

boolean setNodeName(String& arg);

declare architecture related methods:

String& getArchitecture();

boolean setArchitecture(String& arg);

declare number of processors related methods:

long getNumProcessors();

boolean setNumProcessors(long arg);

declare processor speed related methods:

VectorDouble& getProcessorSpeed();

boolean setProcessorSpeed(VectorDouble& arg);

declare main memory related methods:

double getMainMemory();

boolean setMainMemory(double arg);

declare swap memory related methods:

double getSwapMemory();

boolean setSwapMemory(double arg);

declare operating system related methods:

String& getOS();

boolean setOS(String& arg);

declare operating system version related methods:

String& getOSVersion();

boolean setOSVersion(String& arg);

private methods:

declare private methods:

examples:

This example shows how to use the Machine object.

notes:

none.