9cbaa08be7
git-svn-id: svn://opensvn.adaptivecomputing.com/maui/trunk@108 3f5042e3-fb1d-0410-be18-d6ca2573e517
2104 lines
42 KiB
C
2104 lines
42 KiB
C
/*
|
|
*/
|
|
|
|
#if !defined(__MOAB_H)
|
|
#define __MOAB_H
|
|
|
|
#include "moab-local.h"
|
|
#include "mcom.h"
|
|
|
|
#define MOAB_VERSION "3.2.6p20"
|
|
|
|
/* elemental objects */
|
|
|
|
typedef struct {
|
|
long UpdateTime;
|
|
void *Updates;
|
|
|
|
int IsSynced; /* boolean */
|
|
} msync_t;
|
|
|
|
typedef struct {
|
|
long MTime;
|
|
int FailureCount;
|
|
int QCount;
|
|
int JCount;
|
|
int RCount;
|
|
int CCount;
|
|
|
|
int SIsInitialized;
|
|
int IIsInitialized;
|
|
|
|
char *Messages;
|
|
} mgrid_t;
|
|
|
|
typedef struct
|
|
{
|
|
char *Data;
|
|
char *Owner;
|
|
char *Source;
|
|
long ExpireTime;
|
|
long CTime;
|
|
int Type;
|
|
|
|
int Priority;
|
|
int Count;
|
|
|
|
void *Next;
|
|
} mmb_t;
|
|
|
|
enum MValModEnum {
|
|
mvmByte = 0,
|
|
mvmWord,
|
|
mvmKilo,
|
|
mvmMega,
|
|
mvmGiga,
|
|
mvmTera };
|
|
|
|
enum MTimeModeEnum {
|
|
mtmNONE = 0,
|
|
mtmInit,
|
|
mtmRefresh
|
|
};
|
|
|
|
/* resource limit policies */
|
|
|
|
enum MResLimitResourceEnum {
|
|
mrlrNONE = (1 << 0),
|
|
mrlrNode = (1 << 1),
|
|
mrlrProc = (1 << 2),
|
|
mrlrMem = (1 << 3),
|
|
mrlrSwap = (1 << 4),
|
|
mrlrDisk = (1 << 5)
|
|
};
|
|
|
|
enum MResLimitPolicyEnum {
|
|
mrlpNONE = 0,
|
|
mrlpAlways,
|
|
mrlpExtendedViolation,
|
|
mrlpBlockedWorkloadOnly };
|
|
|
|
enum MResLimitVActionEnum {
|
|
mrlaNONE = 0,
|
|
mrlaCancel,
|
|
mrlaRequeue,
|
|
mrlaSuspend };
|
|
|
|
enum MActivePolicyTypeEnum {
|
|
mptNONE = 0,
|
|
mptMaxJob,
|
|
mptMaxNode,
|
|
mptMaxPE,
|
|
mptMaxProc,
|
|
mptMaxPS,
|
|
mptMaxWC,
|
|
mptMaxMem,
|
|
mptMinProc
|
|
};
|
|
|
|
/* NAT RM interface definitions */
|
|
|
|
#define MNAT_GETLOADCMD "/usr/bin/vmstat | /usr/bin/tail -1 | /bin/awk '{ print \\$16 }'"
|
|
#define MNAT_CANCELCMD "/bin/kill"
|
|
#define MNAT_CANCELSIG "-15"
|
|
#define MNAT_RCMD "/usr/bin/ssh"
|
|
|
|
#ifndef mbool_t
|
|
# define mbool_t unsigned char
|
|
#endif /* mbool_t */
|
|
|
|
/* 64 bit values */
|
|
|
|
#define M64INTBITS 64
|
|
#define M64INTLBITS 6
|
|
#define M64INTSIZE 8
|
|
#define M64INTSHIFT 3
|
|
#define M64UINT4 unsigned int
|
|
#define M64UINT8 unsigned long
|
|
|
|
/* 32 bit values */
|
|
|
|
#define M32INTBITS 32
|
|
#define M32INTLBITS 5
|
|
#define M32INTSIZE 4
|
|
#define M32INTSHIFT 2
|
|
#define M32UINT4 unsigned long
|
|
#define M32UINT8 unsigned long long
|
|
|
|
/* ints on x86_64 are still 4 bytes */
|
|
#ifdef __M64
|
|
#define MINTBITS 64
|
|
#define MINTLBITS 6
|
|
#define MINTSIZE 8
|
|
#define MINTSHIFT 3
|
|
|
|
#define MUINT4 unsigned int
|
|
#define MUINT8 unsigned long
|
|
#else /* __M64 */
|
|
#define MINTBITS 32
|
|
#define MINTLBITS 5
|
|
#define MINTSIZE 4
|
|
#define MINTSHIFT 2
|
|
|
|
#define MUINT4 unsigned long
|
|
#define MUINT8 unsigned long long
|
|
#endif /* __M64 */
|
|
|
|
typedef struct {
|
|
mbool_t Is64;
|
|
int INTBITS;
|
|
int INTLBITS;
|
|
int INTSIZE;
|
|
int INTSHIFT;
|
|
} m64_t;
|
|
|
|
#define MMOVEPTR(SPTR,DPTR) \
|
|
DPTR = SPTR;SPTR = (char *)0;
|
|
|
|
#define MAX_MNAME 64
|
|
#define MMAX_NAME 64
|
|
|
|
#ifndef mulong
|
|
# define mulong unsigned long
|
|
#endif /* mulong */
|
|
|
|
#ifndef mutime
|
|
# define mutime unsigned long
|
|
#endif /* mutime */
|
|
|
|
#ifndef MAX_MPAR
|
|
# define MAX_MPAR 4
|
|
#endif /* MAX_MPAR */
|
|
|
|
#define MMAX_PAR 4
|
|
|
|
#define MAX_MPALSIZE 1
|
|
|
|
#ifndef MAX_MUSER
|
|
# define MAX_MUSER 1024
|
|
# define MMAX_USER 1024
|
|
#endif /* MAX_MUSER */
|
|
|
|
#ifndef MAX_MGROUP
|
|
# define MAX_MGROUP 1024
|
|
#endif /* MAX_MGROUP */
|
|
|
|
#ifndef MAX_MACCT
|
|
# define MAX_MACCT 1024
|
|
#endif /* MAX_MACCT */
|
|
|
|
#ifndef MAX_MINDEX
|
|
# define MAX_MINDEX 128
|
|
#endif /* MAX_MINDEX */
|
|
|
|
#ifndef MAX_MQOS
|
|
# define MAX_MQOS 128
|
|
#endif /* MAX_MQOS */
|
|
|
|
#define MMAX_QOS 128
|
|
|
|
#define MAX_MQALSIZE 5
|
|
|
|
#ifndef MAX_MATTR
|
|
# define MAX_MATTR 128
|
|
#endif /* MAX_MATTR */
|
|
|
|
#ifndef MAX_MRES
|
|
# define MAX_MRES 1024
|
|
#endif /* MAX_MRES */
|
|
|
|
#ifndef MMAX_RSV
|
|
# define MMAX_RSV MAX_MRES
|
|
#endif
|
|
|
|
#ifndef MAX_MFSDEPTH
|
|
# define MAX_MFSDEPTH 24
|
|
#endif /* MAX_MFSDEPTH */
|
|
|
|
#define MAX_MPOLICY 9
|
|
|
|
typedef struct {
|
|
int Usage[MAX_MPOLICY][MAX_MPAR];
|
|
int SLimit[MAX_MPOLICY][MAX_MPAR];
|
|
int HLimit[MAX_MPOLICY][MAX_MPAR];
|
|
} mpu_t;
|
|
|
|
typedef struct {
|
|
mpu_t AP;
|
|
mpu_t *IP;
|
|
mpu_t *JP;
|
|
|
|
mpu_t *OAP; /* override active usage policies */
|
|
mpu_t *OIP; /* override idle usage policies */
|
|
mpu_t *OJP;
|
|
|
|
mpu_t *APU; /* active policy (per user) */
|
|
mpu_t *APC; /* active policy (per class) */
|
|
mpu_t *APG; /* active policy (per group) */
|
|
mpu_t *APQ; /* active policy (per QOS) */
|
|
|
|
void *JDef; /* job defaults */
|
|
void *JMax; /* job maximums */
|
|
void *JMin; /* job minimums */
|
|
} mcredl_t;
|
|
|
|
typedef struct {
|
|
unsigned long JobFlags; /* default job flags associated w/cred */
|
|
|
|
long Priority;
|
|
char IsLocalPriority; /* priority is locally specified (boolean) */
|
|
|
|
long Overrun; /* duration job may overrun wclimit */
|
|
|
|
void *ADef; /* default account */
|
|
int *AAL; /* account access list */
|
|
|
|
void *QDef; /* default QOS */
|
|
int QAL[MAX_MQALSIZE]; /* QOS access list */
|
|
int QALType;
|
|
|
|
void *PDef; /* default partition */
|
|
int PAL[MAX_MPALSIZE];
|
|
int PALType;
|
|
|
|
double FSTarget; /* credential fs usage target */
|
|
int FSMode; /* fs target type */
|
|
|
|
double FSFactor; /* effective decayed fs factor */
|
|
double FSUsage[MAX_MFSDEPTH]; /* FS Usage History */
|
|
|
|
int IsInitialized; /* (boolean) */
|
|
} mfs_t;
|
|
|
|
#define DEFAULT_MRESOURCELIMITPOLICY mrlpNONE
|
|
#define DEFAULT_MRESOURCELIMITRESOURCES mrlrProcs|mrlrMem
|
|
#define DEFAULT_MRESOURCELIMITVIOLATIONACTION mrlaRequeue
|
|
|
|
#define MDEF_SPVJOBISPREEMPTIBLE TRUE
|
|
#define MDEF_MINSUSPENDTIME 10
|
|
|
|
/* node access policy */
|
|
|
|
#define MDEF_GNNAME "GLOBAL"
|
|
|
|
enum MNodeAccessPolicyEnum {
|
|
mnacNONE = 0, /* DEFAULT: shared */
|
|
mnacShared, /* any combination of workload allowed */
|
|
mnacSingleJob, /* peer tasks from a single job may utilize node */
|
|
mnacSingleTask, /* only a single task may utilize node */
|
|
mnacSingleUser /* any number of tasks from the same user may utilize node */
|
|
};
|
|
|
|
#define DEFAULT_MNACCESSPOLICY mnacShared
|
|
|
|
|
|
enum MJobNameEnum {
|
|
mjnNONE = 0,
|
|
mjnFullName,
|
|
mjnRMName,
|
|
mjnShortName,
|
|
mjnSpecName };
|
|
|
|
enum MJobDependEnum {
|
|
mjdNONE = 0,
|
|
mjdJobStart,
|
|
mjdJobCompletion,
|
|
mjdJobSuccessfulCompletion,
|
|
mjdJobFailedCompletion };
|
|
|
|
typedef struct mjdepend_s {
|
|
enum MJobDependEnum Type;
|
|
char *Value;
|
|
struct mjdepend_s *Next;
|
|
} mjdepend_t;
|
|
|
|
|
|
/* reservation types */
|
|
|
|
enum MResType {
|
|
mrtNONE = 0,
|
|
mrtJob,
|
|
mrtUser,
|
|
mrtMeta };
|
|
|
|
enum MJResSubTypeEnum {
|
|
mjrNone = 0,
|
|
mjrActiveJob,
|
|
mjrPriority,
|
|
mjrQOSReserved,
|
|
mjrDeadline,
|
|
mjrMeta,
|
|
mjrUser };
|
|
|
|
/* hold reasons */
|
|
|
|
enum MHoldReasonEnum {
|
|
mhrNONE = 0,
|
|
mhrAdmin,
|
|
mhrNoResources,
|
|
mhrSystemLimits,
|
|
mhrAMFailure,
|
|
mhrNoFunds,
|
|
mhrAPIFailure,
|
|
mhrRMReject,
|
|
mhrPolicyViolation,
|
|
mhrQOSAccess,
|
|
mhrCredAccess };
|
|
|
|
/* node states */
|
|
|
|
enum MNodeStateEnum {
|
|
mnsNONE = 0, /* not set */
|
|
mnsNone, /* set to 'none' by RM */
|
|
mnsDown,
|
|
mnsIdle,
|
|
mnsBusy,
|
|
mnsActive, /* node is executing workload */
|
|
mnsDrained,
|
|
mnsDraining,
|
|
mnsFlush,
|
|
mnsReserved, /* node is reserved (internal) */
|
|
mnsUnknown }; /* node is up, usage must be determined */
|
|
|
|
#define DEFAULT_MCSALGO mcsaDES
|
|
|
|
/* scheduler services */
|
|
|
|
enum MSvcEnum {
|
|
svcNONE = 0,
|
|
svcClusterShow,
|
|
svcSetJobSystemPrio,
|
|
svcSetJobUserPrio,
|
|
svcShowQ,
|
|
svcSetJobHold,
|
|
svcReleaseJobHold,
|
|
svcShowJobHold,
|
|
svcShowStats,
|
|
svcResetStats,
|
|
svcResCreate,
|
|
svcResDestroy,
|
|
svcResShow,
|
|
svcSched,
|
|
svcDiagnose,
|
|
svcSetJobDeadline,
|
|
svcReleaseJobDeadline,
|
|
svcShowJobDeadline,
|
|
svcShowEarliestDeadline,
|
|
svcSetJobQOS,
|
|
svcShowGrid,
|
|
svcShowBackfillWindow,
|
|
svcShowConfig,
|
|
svcJobShow,
|
|
svcNodeShow,
|
|
svcRunJob,
|
|
svcCancelJob,
|
|
svcChangeParameter,
|
|
svcMigrateJob,
|
|
svcShowEstimatedStartTime,
|
|
svcBNFQuery,
|
|
svcMJobCtl,
|
|
svcMGridCtl,
|
|
svcMNodeCtl,
|
|
svcMResCtl,
|
|
svcMSchedCtl,
|
|
svcMStat,
|
|
svcMDiagnose,
|
|
svcMShow,
|
|
svcMBal };
|
|
|
|
|
|
typedef struct {
|
|
char Name[MMAX_NAME];
|
|
char Host[MMAX_NAME]; /* ??? */
|
|
char RemoteHost[MMAX_NAME];
|
|
int RemotePort;
|
|
char *URI;
|
|
|
|
long Flags;
|
|
mulong Timeout;
|
|
|
|
enum MSvcEnum SIndex; /* requested service type */
|
|
|
|
int SvcType; /* requested service type */
|
|
long StatusCode; /* return code of service request */
|
|
char *RID; /* requestor UID */
|
|
|
|
/* base config */
|
|
|
|
long Version;
|
|
int sd;
|
|
char *RBuffer;
|
|
long RBufSize;
|
|
char *SBuffer;
|
|
|
|
mulong State;
|
|
|
|
mbool_t IsLoaded;
|
|
mbool_t IsNonBlocking;
|
|
mbool_t SBIsDynamic;
|
|
|
|
long SBufSize;
|
|
char *RPtr;
|
|
char *SPtr;
|
|
|
|
void *SE; /* xml to send - full (alloc,w/header) */
|
|
void *SDE; /* xml to send (alloc,optional) */
|
|
|
|
char *SData; /* text to send (alloc,optional) */
|
|
|
|
char *SMsg; /* (alloc) */
|
|
|
|
char *ClientName; /* (alloc) */
|
|
void *Cred; /* possibly a suclcred_t (ptr) */
|
|
|
|
void *RE; /* incoming message - full (alloc) */
|
|
void *RDE; /* incoming message (alloc) */
|
|
|
|
/* comm config */
|
|
|
|
enum MWireProtocolEnum WireProtocol;
|
|
enum MSocketProtocolEnum SocketProtocol;
|
|
enum MChecksumAlgoEnum CSAlgo;
|
|
|
|
mbool_t DoEncrypt;
|
|
|
|
char CSKey[MMAX_NAME];
|
|
} msocket_t;
|
|
|
|
|
|
/* peer service interface */
|
|
|
|
typedef struct {
|
|
enum MPeerServiceEnum Type;
|
|
|
|
enum MWireProtocolEnum WireProtocol;
|
|
enum MSocketProtocolEnum SocketProtocol;
|
|
enum MChecksumAlgoEnum CSAlgo;
|
|
|
|
char *CSKey;
|
|
|
|
char *HostName;
|
|
int Port;
|
|
char *Version;
|
|
|
|
mulong Timeout;
|
|
|
|
void *Data;
|
|
|
|
msocket_t *S;
|
|
} mpsi_t;
|
|
|
|
/* NOTE: sync with MXO[] */
|
|
|
|
enum MXMLOType {
|
|
mxoNONE = 0,
|
|
mxoAcct,
|
|
mxoAM,
|
|
mxoClass,
|
|
mxoCluster,
|
|
mxoCP,
|
|
mxoFrame,
|
|
mxoFS,
|
|
mxoGroup,
|
|
mxoJob,
|
|
mxoLimits,
|
|
mxoNode,
|
|
mxoPar,
|
|
mxoPriority,
|
|
mxoQOS,
|
|
mxoQueue,
|
|
mxoRange,
|
|
mxoReq,
|
|
mxoRsv,
|
|
mxoRM,
|
|
mxoSched,
|
|
mxoSim,
|
|
mxoSRes,
|
|
mxoStats,
|
|
mxoSys,
|
|
mxoUser,
|
|
mxoLAST };
|
|
|
|
enum MRMStateEnum {
|
|
mrmsNONE = 0,
|
|
mrmsActive,
|
|
mrmsDown,
|
|
mrmsCorrupt };
|
|
|
|
enum MRMTypeEnum {
|
|
mrmtNONE = 0,
|
|
mrmtLL,
|
|
mrmtOther,
|
|
mrmtPBS,
|
|
mrmtSGE,
|
|
mrmtSSS,
|
|
mrmtWiki,
|
|
mrmtRMS,
|
|
mrmtLSF,
|
|
mrmtNative };
|
|
|
|
#define MAX_MRMTYPE 10
|
|
|
|
enum MJobSearchEnum {
|
|
mjsmBasic = 0,
|
|
mjsmExtended,
|
|
mjsmInternal };
|
|
|
|
enum MRMSubTypeEnum {
|
|
mrmstNONE = 0,
|
|
mrmstRMS };
|
|
|
|
#ifndef __M_H
|
|
#define __M_H
|
|
#endif /* !__M_H */
|
|
|
|
#ifdef __M_H
|
|
#include "msched.h"
|
|
#endif /* __M_H */
|
|
|
|
#if defined (__MMEMTEST)
|
|
#ifndef MEMWATCH
|
|
# define MEMWATCH
|
|
# include "memwatch.h"
|
|
#endif /* MEMWATCH */
|
|
|
|
#ifndef MEMWATCH_STDIO
|
|
# define MEMWATCH_STDIO
|
|
#endif /* MEMWATCH_STDIO */
|
|
#endif /* __MMEMTEST */
|
|
|
|
#ifndef __M_H
|
|
#define __M_H
|
|
#endif /* !__M_H */
|
|
|
|
#ifndef mulong
|
|
# define mulong unsigned long
|
|
#endif /* mulong */
|
|
|
|
#ifndef mutime
|
|
# define mutime unsigned long
|
|
#endif /* mutime */
|
|
|
|
#if !defined(DEFAULT_MSERVERHOST)
|
|
# define DEFAULT_MSERVERHOST ""
|
|
#endif /* !DEFAULT_MSERVERHOST */
|
|
|
|
#if !defined(DEFAULT_MSERVERPORT)
|
|
# define DEFAULT_MSERVERPORT 40559
|
|
#endif /* !DEFAULT_MSERVERPORT */
|
|
|
|
#define DEFAULT_MSERVERMODE msmNormal
|
|
|
|
#define DEFAULT_MREJECTNEGPRIOJOBS FALSE
|
|
#define DEFAULT_MENABLENEGJOBPRIORITY FALSE
|
|
#define DEFAULT_MENABLEMULTINODEJOBS TRUE
|
|
#define DEFAULT_MENABLEMULTIREQJOBS FALSE
|
|
|
|
#define MAX_MSPSLOT 16
|
|
|
|
/* scheduling policies */
|
|
|
|
enum MAllocLocalityPolicyEnum {
|
|
malpNONE = 0,
|
|
malpBestEffort,
|
|
malpForce,
|
|
malpRMSpecific };
|
|
|
|
enum MLimitTypes {
|
|
mlNONE = 0,
|
|
mlActive,
|
|
mlIdle,
|
|
mlSystem };
|
|
|
|
enum MJobNonEType {
|
|
mjneNONE = 0,
|
|
mjneIdlePolicy };
|
|
|
|
enum MEventFlagsEnum {
|
|
mefNONE = 0,
|
|
mefExternal };
|
|
|
|
enum MTimePolicyEnum {
|
|
mtpNONE = 0,
|
|
mtpReal };
|
|
|
|
|
|
/* server checkpointing object */
|
|
|
|
typedef struct {
|
|
char CPFileName[MAX_MLINE];
|
|
|
|
char *Buffer;
|
|
|
|
int CPInterval; /* seconds between subsequent checkpoints */
|
|
int CPExpirationTime; /* seconds stale checkpoint data will be kept */
|
|
mulong LastCPTime; /* time of most recent checkpoint */
|
|
|
|
char DVersion[MAX_MNAME]; /* detected data version */
|
|
char SVersionList[MAX_MLINE]; /* supported versions */
|
|
char WVersion[MAX_MNAME]; /* write version */
|
|
|
|
FILE *fp;
|
|
|
|
char *OBuffer;
|
|
} mckpt_t;
|
|
|
|
/* CP types */
|
|
|
|
enum MCkPtTypeEnum {
|
|
mcpSched = 0,
|
|
mcpJob,
|
|
mcpRes,
|
|
mcpSRes,
|
|
mcpNode,
|
|
mcpUser,
|
|
mcpGroup,
|
|
mcpAcct,
|
|
mcpTotal,
|
|
mcpRTotal,
|
|
mcpCTotal,
|
|
mcpGTotal,
|
|
mcpSysStats,
|
|
mcpRM,
|
|
mcpAM,
|
|
mcpSys };
|
|
|
|
|
|
|
|
/* general objects */
|
|
|
|
/* reasons for requirements rejection */
|
|
|
|
/* sync with MAllocRejType */
|
|
|
|
enum MAllocRejEnum {
|
|
marFeatures = 0,
|
|
marClass,
|
|
marPartition,
|
|
marCPU,
|
|
marMemory,
|
|
marDisk,
|
|
marSwap,
|
|
marAdapter,
|
|
marState,
|
|
marEState,
|
|
marOpsys,
|
|
marArch,
|
|
marRelease,
|
|
marTime,
|
|
marNodeCount,
|
|
marHold,
|
|
marPolicy,
|
|
marLocality,
|
|
marDepend,
|
|
marShortPool,
|
|
marSystemLimits,
|
|
marPartitionAccess,
|
|
marCorruption,
|
|
marFairShare,
|
|
marHostList,
|
|
marPool,
|
|
marPriority };
|
|
|
|
#define MAX_MREJREASON 27 /* NOTE: sync with MRejReasonEnum */
|
|
|
|
|
|
enum MAccessModeEnum {
|
|
macmNONE = 0,
|
|
macmRead,
|
|
macmWrite };
|
|
|
|
/* BNF commands */
|
|
|
|
enum {
|
|
bnfNone = 0,
|
|
bnfQuery,
|
|
bnfStatus,
|
|
bnfMessage,
|
|
bnfSet
|
|
};
|
|
|
|
enum MStatusCodeEnum {
|
|
mscNoError = 0,
|
|
mscFuncFailure,
|
|
mscBadParam, /* invalid parameters */
|
|
mscNoAuth, /* request not authorized */
|
|
mscNoEnt, /* entity does not exist */
|
|
mscNoFile, /* file does not exist */
|
|
mscNoMemory, /* inadequate memory */
|
|
mscRemoteFailure, /* remote service failed */
|
|
mscSysFailure, /* system call failed */
|
|
mscTimeout,
|
|
mscBadRequest, /* request is corrupt */
|
|
mscNoData, /* data not yet available */
|
|
mscLAST };
|
|
|
|
/* cred object */
|
|
|
|
enum MCredAttrType {
|
|
mcaNONE,
|
|
mcaPriority,
|
|
mcaMaxJob,
|
|
mcaMaxNode,
|
|
mcaMaxPE,
|
|
mcaMaxProc,
|
|
mcaMinProc,
|
|
mcaMaxPS,
|
|
mcaMaxWC, /* max total wclimit */
|
|
mcaMaxMem,
|
|
mcaMaxIJob,
|
|
mcaMaxINode,
|
|
mcaMaxIPE,
|
|
mcaMaxIProc,
|
|
mcaMaxIPS,
|
|
mcaMaxIWC,
|
|
mcaMaxIMem,
|
|
mcaOMaxJob,
|
|
mcaOMaxNode,
|
|
mcaOMaxPE,
|
|
mcaOMaxProc,
|
|
mcaOMaxPS,
|
|
mcaOMaxWC,
|
|
mcaOMaxMem,
|
|
mcaOMaxIJob,
|
|
mcaOMaxINode,
|
|
mcaOMaxIPE,
|
|
mcaOMaxIProc,
|
|
mcaOMaxIPS,
|
|
mcaOMaxIWC,
|
|
mcaOMaxIMem,
|
|
mcaOMaxJNode,
|
|
mcaOMaxJPE,
|
|
mcaOMaxJProc,
|
|
mcaOMaxJPS,
|
|
mcaOMaxJWC,
|
|
mcaOMaxJMem,
|
|
mcaFSTarget,
|
|
mcaQList,
|
|
mcaQDef,
|
|
mcaPList,
|
|
mcaPDef,
|
|
mcaAList,
|
|
mcaADef,
|
|
mcaJobFlags,
|
|
mcaMaxJobPerUser,
|
|
mcaMaxNodePerUser,
|
|
mcaMaxProcPerUser,
|
|
mcaMaxProcPerNodePerQueue,
|
|
mcaOverrun,
|
|
mcaID,
|
|
mcaDefWCLimit,
|
|
mcaMaxWCLimit, /* max wclimit per job */
|
|
mcaMaxProcPerNode,
|
|
mcaMaxNodePerJob,
|
|
mcaMaxProcPerJob
|
|
};
|
|
|
|
enum MOServiceAttrType {
|
|
mosaNONE = 0,
|
|
mosaCSAlgo,
|
|
mosaCSKey,
|
|
mosaHost,
|
|
mosaPort,
|
|
mosaProtocol,
|
|
mosaVersion };
|
|
|
|
|
|
/* group object */
|
|
|
|
enum MGroupAttrType {
|
|
mgaNONE = 0,
|
|
mgaClassWeight };
|
|
|
|
/* user object */
|
|
|
|
enum MUserAttrType {
|
|
muaNONE = 0,
|
|
muaMaxWCLimit };
|
|
|
|
/* qos object */
|
|
|
|
enum MQOSAttrType {
|
|
mqaNONE = 0,
|
|
mqaPriority,
|
|
mqaMaxJob,
|
|
mqaMaxProc,
|
|
mqaMaxNode,
|
|
mqaXFWeight,
|
|
mqaQTWeight,
|
|
mqaXFTarget,
|
|
mqaQTTarget,
|
|
mqaFlags,
|
|
mqaFSTarget };
|
|
|
|
|
|
enum MQOSFlagEnum {
|
|
mqfignJobPerUser = 0,
|
|
mqfignProcPerUser,
|
|
mqfignNodePerUser,
|
|
mqfignPSPerUser,
|
|
mqfignJobQueuedPerUser,
|
|
mqfignMaxProc,
|
|
mqfignMaxTime,
|
|
mqfignMaxPS,
|
|
mqfignSRMaxTime,
|
|
mqfignUser,
|
|
mqfignSystem,
|
|
mqfignAll,
|
|
mqfpreemptor,
|
|
mqfpreemptee,
|
|
mqfdedicated,
|
|
mqfreserved,
|
|
mqfusereservation,
|
|
mqfnobf,
|
|
mqfnoreservation,
|
|
mqfrestartpreempt,
|
|
mqfNTR,
|
|
mqfRunNow,
|
|
mqfPreemptSPV,
|
|
mqfignHostList };
|
|
|
|
#define QFUSER ((1 << mqfignJobPerUser) | (1 << mqfignNodePerUser) \
|
|
| (1 << mqfignPSPerUser) | (1 << mqfignJobQueuedPerUser))
|
|
#define QFSYSTEM ((1 << mqfignMaxProc) | (1 << mqfignMaxTime) | (1 << mqfignMaxPS))
|
|
#define QFALL (QFUSER | QFSYSTEM | (1 << mqfignSRMaxTime))
|
|
|
|
|
|
|
|
#define MUBMCheck(I,M) (M[(I) >> 5] & (1 << ((I) % 32)))
|
|
#define MUBMSet(I,M) ((M[(I) >> 5]) |= (1 << ((I) % 32)))
|
|
#define MUBMClear(M,S) memset(M,0,sizeof(int) * ((S >> 5) + 1))
|
|
#define MUBMCopy(Dst,Src,S) memcpy(Dst,Src,sizeof(int) * ((S >> 5) + 1))
|
|
|
|
|
|
|
|
/* class object */
|
|
|
|
enum MClassAttrType {
|
|
mclaNONE = 0,
|
|
mclaOCNode,
|
|
mclaDefReqFeature,
|
|
mclaHostList,
|
|
mclaName,
|
|
mclaNAPolicy,
|
|
mclaMaxProcPerNode,
|
|
mclaOCDProcFactor,
|
|
mclaState,
|
|
mclaWCOverrun
|
|
};
|
|
|
|
|
|
/* res object */
|
|
|
|
enum MResAttrEnum {
|
|
mraNONE = 0,
|
|
mraAAccount, /* accountable account */
|
|
mraACL,
|
|
mraAGroup, /* accountable group */
|
|
mraAUser, /* accountable user */
|
|
mraCreds,
|
|
mraDuration,
|
|
mraEndTime,
|
|
mraFlags,
|
|
mraHostExp,
|
|
mraJState,
|
|
mraMaxTasks,
|
|
mraMessages,
|
|
mraName,
|
|
mraNodeCount,
|
|
mraNodeList,
|
|
mraOwner,
|
|
mraResources,
|
|
mraStartTime,
|
|
mraStatCAPS,
|
|
mraStatCIPS,
|
|
mraStatTAPS,
|
|
mraStatTIPS,
|
|
mraTaskCount,
|
|
mraType,
|
|
mraXAttr };
|
|
|
|
/* nres object */
|
|
|
|
enum MNResAttrType {
|
|
mnraNONE = 0,
|
|
mnraDRes,
|
|
mnraEnd,
|
|
mnraName,
|
|
mnraState,
|
|
mnraStart,
|
|
mnraTC,
|
|
mnraType
|
|
};
|
|
|
|
/* NOTE: sync with external systems */
|
|
|
|
enum MResFlagEnum {
|
|
mrfNONE = 0,
|
|
mrfStandingRes,
|
|
mrfSingleUse,
|
|
mrfByName,
|
|
mrfMeta,
|
|
mrfPreemptible,
|
|
mrfTimeFlex,
|
|
mrfSpaceFlex,
|
|
mrfDedicatedNode, /* only on active reservation on node */
|
|
mrfDedicatedResource, /* reservation does not share reserved resources */
|
|
mrfAdvRes, /* may only utilize reserved resources */
|
|
mrfForce, /* force res onto nodes regardless of other res */
|
|
mrfOwnerPreempt };
|
|
|
|
/* stat object */
|
|
|
|
enum MStatAttrType {
|
|
mstaNONE = 0,
|
|
mstaTJobCount,
|
|
mstaTNJobCount,
|
|
mstaTQueueTime,
|
|
mstaMQueueTime,
|
|
mstaTReqWTime,
|
|
mstaTExeWTime,
|
|
mstaTMSAvl,
|
|
mstaTMSDed,
|
|
mstaTPSReq,
|
|
mstaTPSExe,
|
|
mstaTPSDed,
|
|
mstaTPSUtl,
|
|
mstaTJobAcc,
|
|
mstaTNJobAcc,
|
|
mstaTXF,
|
|
mstaTNXF,
|
|
mstaMXF,
|
|
mstaTBypass,
|
|
mstaMBypass,
|
|
mstaTQOSAchieved,
|
|
mstaInitTime,
|
|
mstaGCEJobs, /* current eligible jobs */
|
|
mstaGCIJobs, /* current idle jobs */
|
|
mstaGCAJobs, /* current active jobs */
|
|
mstaGPHAvl,
|
|
mstaGPHUtl,
|
|
mstaGPHSuc,
|
|
mstaGMinEff,
|
|
mstaGMinEffIteration,
|
|
mstaTPHPreempt,
|
|
mstaTJPreempt,
|
|
mstaTJEval,
|
|
mstaTPHQueued,
|
|
mstaSchedDuration,
|
|
mstaSchedCount };
|
|
|
|
#define MMAX_JOBATTR 4
|
|
|
|
typedef struct
|
|
{
|
|
int AIndex; /* generic attribute index */
|
|
enum MXMLOType OType; /* object type */
|
|
char *AName[MMAX_JOBATTR]; /* XML attribute name */
|
|
} mobjattr_t;
|
|
|
|
|
|
/* limit object */
|
|
|
|
enum MLimitAttrType {
|
|
mlaNONE = 0,
|
|
mlaAJobs,
|
|
mlaAProcs,
|
|
mlaAPS
|
|
};
|
|
|
|
|
|
/* rm object */
|
|
|
|
enum MRMAttrType {
|
|
mrmaNONE = 0,
|
|
mrmaAuthType,
|
|
mrmaConfigFile,
|
|
mrmaCSAlgo,
|
|
mrmaCSKey,
|
|
mrmaEPort,
|
|
mrmaHost,
|
|
mrmaLocalDiskFS,
|
|
mrmaMinETime,
|
|
mrmaName,
|
|
mrmaNMPort,
|
|
mrmaNMServer,
|
|
mrmaPort,
|
|
mrmaSocketProtocol,
|
|
mrmaSuspendSig,
|
|
mrmaTimeout,
|
|
mrmaType,
|
|
mrmaVersion,
|
|
mrmaWireProtocol
|
|
};
|
|
|
|
typedef struct
|
|
{
|
|
int AIndex;
|
|
int OType;
|
|
char *S02; /* SSS RM0.2 */
|
|
char *Other;
|
|
} mjobattr_t;
|
|
|
|
|
|
enum {
|
|
mjfNONE = 0,
|
|
mjfAllocLocal,
|
|
mjfBackfill,
|
|
mjfSpan,
|
|
mjfAdvReservation,
|
|
mjfNoQueue,
|
|
mjfHostList,
|
|
mjfResMap,
|
|
mjfSharedResource,
|
|
mjfByName,
|
|
mjfBestEffort,
|
|
mjfRestartable,
|
|
mjfPreemptee,
|
|
mjfPreemptor,
|
|
mjfNASingleJob,
|
|
mjfPreload,
|
|
mjfRemote,
|
|
mjfNASingleTask,
|
|
mjfSPViolation,
|
|
mjfIgnNodePolicies,
|
|
mjfNoRMStart,
|
|
mjfGlobalQueue,
|
|
mjfIsExiting };
|
|
|
|
enum {
|
|
mjifNONE = 0,
|
|
mjifIsExiting };
|
|
|
|
enum MHoldTypeEnum {
|
|
mhNONE = 0,
|
|
mhUser,
|
|
mhSystem,
|
|
mhBatch,
|
|
mhDefer,
|
|
mhAll };
|
|
|
|
/* sync w/MRMFuncType */
|
|
|
|
enum MRMFuncEnum {
|
|
mrmNONE = 0,
|
|
mrmClusterQuery,
|
|
mrmCycleFinalize,
|
|
mrmJobCancel,
|
|
mrmJobCheckpoint,
|
|
mrmJobGetProximateTasks,
|
|
mrmJobMigrate,
|
|
mrmJobModify,
|
|
mrmJobQuery,
|
|
mrmJobRequeue,
|
|
mrmJobResume,
|
|
mrmJobStart,
|
|
mrmJobSubmit,
|
|
mrmJobSuspend,
|
|
mrmQueueQuery,
|
|
mrmResourceModify,
|
|
mrmResourceQuery,
|
|
mrmRMEventQuery,
|
|
mrmRMGetData,
|
|
mrmRMInitialize,
|
|
mrmRMQuery,
|
|
mrmWorkloadQuery };
|
|
|
|
typedef struct {
|
|
int (*ClusterQuery)(mrm_t *, int *,char *,int *);
|
|
int (*CycleFinalize)(mrm_t *,int *);
|
|
int (*Initialize)();
|
|
int (*JobCancel)(mjob_t *,mrm_t *,char *,char *,int *);
|
|
int (*JobCheckpoint)(mjob_t *, mrm_t *,mbool_t,char *,int *);
|
|
int (*JobGetProximateTasks)(mjob_t *,mrm_t *,mnodelist_t,mnodelist_t,long,int,char *,int *);
|
|
int (*JobMigrate)(mjob_t *,mrm_t *,mnalloc_t *,char *,int *);
|
|
int (*JobModify)(mjob_t *,mrm_t *,char *,char *,char *,char *,int *);
|
|
int (*JobQuery)();
|
|
int (*JobRequeue)(mjob_t *,mrm_t *,mjob_t **,char *,int *);
|
|
int (*JobResume)(mjob_t *,mrm_t *,char *,int *);
|
|
int (*JobStart)(mjob_t *, mrm_t *, char *, int *);
|
|
int (*JobSubmit)(char *,mrm_t *,mjob_t **,char *,char *,int *);
|
|
int (*JobSuspend)(mjob_t *,mrm_t *,char *,int *);
|
|
int (*QueueQuery)(mrm_t *, int *, int *);
|
|
int (*ResourceModify)();
|
|
int (*ResourceQuery)(mnode_t *,mrm_t *,char *,int *);
|
|
int (*RMEventQuery)(mrm_t *,int *);
|
|
int (*RMGetData)(mrm_t *,int *);
|
|
int (*RMInitialize)(mrm_t *,int *);
|
|
int (*RMQuery)(void);
|
|
int (*WorkloadQuery)(mrm_t *,int *,int *);
|
|
|
|
mbool_t IsInitialized;
|
|
} mrmfunc_t;
|
|
|
|
#define DEFAULT_MRMPORT 0
|
|
#define DEFAULT_MRMSERVER ""
|
|
#define DEFAULT_MRMTYPE mrmtPBS
|
|
#define DEFAULT_MRMTIMEOUT 9
|
|
#define DEFAULT_MRMAUTHTYPE rmaCheckSum
|
|
|
|
#define MMAX_AMFUNC 20
|
|
|
|
/* am object */
|
|
|
|
enum MJFActionEnum {
|
|
mamjfaNONE = 0,
|
|
mamjfaCancel,
|
|
mamjfaDefer };
|
|
|
|
#define MDEF_AMJFACTION mamjfaNONE
|
|
|
|
typedef struct {
|
|
char Name[MAX_MNAME];
|
|
int Index;
|
|
|
|
enum MRMStateEnum State;
|
|
|
|
char ClientName[MAX_MNAME];
|
|
|
|
/* interface specification */
|
|
|
|
enum MWireProtocolEnum WireProtocol;
|
|
enum MSocketProtocolEnum SocketProtocol;
|
|
|
|
enum MChecksumAlgoEnum CSAlgo;
|
|
|
|
char CSKey[MAX_MNAME];
|
|
|
|
char Host[MAX_MNAME]; /* active AM server host */
|
|
int Port; /* active AM service port */
|
|
|
|
char SpecHost[MAX_MNAME]; /* specified AM server host */
|
|
int SpecPort; /* specified AM service port */
|
|
|
|
int UseDirectoryService; /* boolean */
|
|
|
|
int Type; /* type of AM server */
|
|
int Version;
|
|
|
|
int Timeout; /* in ms */
|
|
|
|
/* policies */
|
|
|
|
int ChargePolicy; /* allocation charge policy */
|
|
|
|
mulong FlushInterval; /* AM flush interval */
|
|
mulong FlushTime;
|
|
|
|
int DeferJobOnFailure; /* boolean */
|
|
int AppendMachineName; /* boolean */
|
|
|
|
char FallbackAccount[MAX_MNAME]; /* account to use if primary account is unavailable */
|
|
|
|
long FailTime[MAX_MRMFAILURE];
|
|
int FailType[MAX_MRMFAILURE];
|
|
char *FailMsg[MAX_MRMFAILURE];
|
|
int FailIndex;
|
|
|
|
long RespTotalTime[MMAX_AMFUNC];
|
|
long RespMaxTime[MMAX_AMFUNC];
|
|
int RespTotalCount[MMAX_AMFUNC];
|
|
long RespStartTime[MMAX_AMFUNC];
|
|
|
|
msocket_t *S;
|
|
FILE *FP;
|
|
|
|
mpsi_t P;
|
|
|
|
enum MJFActionEnum JFAction;
|
|
} mam_t;
|
|
|
|
enum MAMAttrType {
|
|
mamaNONE = 0,
|
|
mamaAppendMachineName,
|
|
mamaChargePolicy,
|
|
mamaConfigFile,
|
|
mamaCSAlgo,
|
|
mamaCSKey,
|
|
mamaDeferJobOnFailure,
|
|
mamaFallbackAccount,
|
|
mamaFlushInterval,
|
|
mamaHost,
|
|
mamaJFAction,
|
|
mamaPort,
|
|
mamaServer,
|
|
mamaSocketProtocol,
|
|
mamaTimeout,
|
|
mamaType,
|
|
mamaWireProtocol
|
|
};
|
|
|
|
/* AM types */
|
|
|
|
enum {
|
|
mamtNONE,
|
|
mamtQBANK,
|
|
mamtRESD,
|
|
mamtFILE,
|
|
mamtGOLD
|
|
};
|
|
|
|
/* AM consumption policies */
|
|
|
|
enum {
|
|
mamcpNONE = 0,
|
|
mamcpDebitAllWC,
|
|
mamcpDebitAllCPU,
|
|
mamcpDebitAllPE,
|
|
mamcpDebitSuccessfulWC,
|
|
mamcpDebitSuccessfulCPU,
|
|
mamcpDebitSuccessfulPE
|
|
};
|
|
|
|
#define DEFAULT_MAMTYPE mamtNONE
|
|
#define DEFAULT_MAMVERSION 0
|
|
#define DEFAULT_MAMCHARGEPOLICY mamcpDebitSuccessfulWC
|
|
#define DEFAULT_MAMHOST ""
|
|
#define DEFAULT_MAMPORT 40560
|
|
#define MAX_MAMFLUSHINTERVAL 86400
|
|
#define DEFAULT_MAMFLUSHINTERVAL 3600
|
|
#define DEFAULT_MAMAUTHTYPE rmaCheckSum
|
|
#define DEFAULT_MAMWIREPROTOCOL mwpAVP
|
|
#define DEFAULT_MAMSOCKETPROTOCOL mspSingleUseTCP
|
|
|
|
#define DEFAULT_MAMDEFERONJOBFAILURE FALSE
|
|
#define DEFAULT_MAMAPPENDMACHINENAME FALSE
|
|
|
|
#define DEFAULT_MAMTIMEOUT 9
|
|
|
|
#define MMAX_PRIO_VAL 1000000000
|
|
|
|
#define MDEF_AMTYPE mamtNONE
|
|
#define MDEF_AMVERSION 0
|
|
#define MDEF_AMCHARGEPOLICY mamcpDebitSuccessfulWC
|
|
#define MDEF_AMHOST ""
|
|
#define MDEF_AMPORT 40560
|
|
#define MMAX_AMFLUSHINTERVAL 86400
|
|
#define MDEF_AMFLUSHINTERVAL 3600
|
|
#define MDEF_AMAUTHTYPE rmaCheckSum
|
|
#define MDEF_AMWIREPROTOCOL mwpAVP
|
|
#define MDEF_AMSOCKETPROTOCOL mspSingleUseTCP
|
|
|
|
#define MDEF_AMDEFERONJOBFAILURE FALSE
|
|
#define MDEF_AMAPPENDMACHINENAME FALSE
|
|
|
|
#define MDEF_AMTIMEOUT 9
|
|
|
|
#define MCONST_EFFINF 50000000 /* ~ 1.5 years */
|
|
|
|
|
|
/* sim object */
|
|
|
|
/* sim flag types */
|
|
|
|
enum {
|
|
msimfNONE = 0,
|
|
msimfIgnHostList,
|
|
msimfIgnClass,
|
|
msimfIgnQOS,
|
|
msimfIgnMode,
|
|
msimfIgnFeatures,
|
|
msimfIgnFrame,
|
|
msimfIgnAll };
|
|
|
|
typedef struct {
|
|
char WorkloadTraceFile[MAX_MLINE + 1]; /* File Containing Workload Traces */
|
|
char ResourceTraceFile[MAX_MLINE + 1]; /* File Containing Resource Traces */
|
|
|
|
/* general config */
|
|
|
|
int SimulationInterval; /* Time Step Used in Simulation */
|
|
int WCScalingPercent; /* Mult. Factor for WC Limit */
|
|
int InitialQueueDepth; /* depth of queue at start time */
|
|
double WCAccuracy; /* Accuracy of User Specified Limits */
|
|
double WCAccuracyChange; /* Percent Offset to Original WC Accuracy */
|
|
int JobSubmissionPolicy; /* Job submission policy */
|
|
int LocalityMargin; /* number of frames allowed beyond optimal */
|
|
int NCPolicy; /* node config policy */
|
|
int NodeCount; /* Number of Nodes in Simulated System */
|
|
char StatFileName[MAX_MLINE]; /* Name of simulation statistics file */
|
|
mulong DefaultCheckpointInterval;
|
|
|
|
mulong StartTime; /* epoch time to start simulation */
|
|
int StopIteration; /* iteration to schedule before stop */
|
|
int ExitIteration; /* iteration to schedule before exit */
|
|
|
|
long Flags;
|
|
long TraceIgnoreJobFlags;
|
|
long TraceDefaultJobFlags;
|
|
|
|
/* config booleans */
|
|
|
|
int ScaleJobRunTime; /* scale job execution time */
|
|
int AutoShutdown; /* shutdown when queues are empty */
|
|
int ForceNodeLocality; /* require node localization */
|
|
int RandomizeJobSize; /* randomize job size distribution */
|
|
|
|
/* general status */
|
|
|
|
long RMFailureTime;
|
|
int TraceOffset; /* offset to next trace in tracefile */
|
|
|
|
/* status booleans */
|
|
|
|
int QueueChanged;
|
|
|
|
/* IPC cost analysis */
|
|
|
|
int CommunicationType; /* Communication Pattern being Simulated */
|
|
double IntraFrameCost; /* Cost of IntraFrame Communication */
|
|
double InterFrameCost; /* Cost of InterFrame Communication */
|
|
double ComRate; /* Percent of Instructions that are Comm */
|
|
} msim_t;
|
|
|
|
enum MSimNodeConfigPolicyEnum {
|
|
msncNormal = 0,
|
|
msncHomogeneous,
|
|
msncPartitioned };
|
|
|
|
enum MSimJobSubmissionPolicyEnum {
|
|
msjsTraceSubmit = 0,
|
|
msjsConstantJob,
|
|
msjsConstantPS };
|
|
|
|
/* default sim values */
|
|
|
|
#define DEFAULT_MSIMWCSCALINGPERCENT 100
|
|
#define DEFAULT_MSIMINITIALQUEUEDEPTH 16
|
|
#define DEFAULT_MSIMWCACCURACY 0.0 /* 0 to use trace execution time */
|
|
#define DEFAULT_MSIMWCACCURACYCHANGE 0.0
|
|
#define DEFAULT_MSIMFLAGS 0
|
|
#define DEFAULT_MSIMTRACEIGNFLAGS (1 << mjfAllocLocal)
|
|
#define DEFAULT_MSIMSTATFILENAME "simstat.out"
|
|
#define DEFAULT_MSIMJSPOLICY msjsConstantJob
|
|
#define DEFAULT_MSIMNCPOLICY msncNormal
|
|
#define DEFAULT_MSIMNODECOUNT 0 /* 0 Means Use Trace Node Count */
|
|
#define DEFAULT_MSCHEDALLOCLOCALITYPOLICY malpNONE
|
|
|
|
#define DEFAULT_MSIMCOMMUNICATIONTYPE comRoundRobin
|
|
#define DEFAULT_MSIMINTRAFRAMECOST 0.3
|
|
#define DEFAULT_MSIMINTERFRAMECOST 0.3
|
|
#define DEFAULT_MSIMCOMRATE 0.1
|
|
|
|
#define DEFAULT_MSIMRANDOMIZEJOBSIZE FALSE
|
|
#define DEFAULT_MSIMAUTOSHUTDOWNMODE TRUE
|
|
|
|
#define DEFAULT_MSIMWORKLOADTRACEFILE "workload"
|
|
#define DEFAULT_MSIMRESOURCETRACEFILE "resource"
|
|
|
|
#define MSCHED_KEYFILE ".moab.key"
|
|
|
|
|
|
/* sr object */
|
|
|
|
enum MSRAttrType {
|
|
msraNone,
|
|
msraAccess,
|
|
msraAccountList,
|
|
msraChargeAccount,
|
|
msraClassList,
|
|
msraDays,
|
|
msraDepth,
|
|
msraEndTime,
|
|
msraFlags,
|
|
msraGroupList,
|
|
msraHostList,
|
|
msraIdleTime,
|
|
msraJobAttrList,
|
|
msraMaxTime,
|
|
msraName,
|
|
msraNodeFeatures,
|
|
msraOwner,
|
|
msraPartition,
|
|
msraPeriod,
|
|
msraPriority,
|
|
msraProcLimit,
|
|
msraQOSList,
|
|
msraResources,
|
|
msraStartTime,
|
|
msraStIdleTime,
|
|
msraStTotalTime,
|
|
msraTaskCount,
|
|
msraTaskLimit,
|
|
msraTimeLimit,
|
|
msraTPN,
|
|
msraUserList,
|
|
msraWEndTime,
|
|
msraWStartTime };
|
|
|
|
|
|
|
|
/* fs object */
|
|
|
|
enum MFSAttrType {
|
|
mfsaNONE = 0,
|
|
mfsaTarget
|
|
};
|
|
|
|
|
|
|
|
/* node object */
|
|
|
|
enum MNodeAttrEnum {
|
|
mnaNONE = 0,
|
|
mnaAccess,
|
|
mnaArch,
|
|
mnaGRes,
|
|
mnaAvlClass,
|
|
mnaAvlMemW,
|
|
mnaAvlProcW,
|
|
mnaCfgClass,
|
|
mnaCfgDisk,
|
|
mnaCfgMem,
|
|
mnaCfgMemW,
|
|
mnaCfgProcW,
|
|
mnaCfgSwap,
|
|
mnaExtLoad,
|
|
mnaFeatures,
|
|
mnaFrame,
|
|
mnaLoad,
|
|
mnaLoadW,
|
|
mnaMaxJob,
|
|
mnaMaxJobPerUser,
|
|
mnaMaxLoad,
|
|
mnaMaxPEPerJob,
|
|
mnaMaxProc,
|
|
mnaMaxProcPerClass,
|
|
mnaMaxProcPerUser,
|
|
mnaNetwork,
|
|
mnaNodeID,
|
|
mnaNodeState,
|
|
mnaNodeType,
|
|
mnaOS,
|
|
mnaPartition,
|
|
mnaPrioF,
|
|
mnaPriority,
|
|
mnaPrioW,
|
|
mnaProcSpeed,
|
|
mnaRADisk,
|
|
mnaRAMem,
|
|
mnaRAProc,
|
|
mnaRASwap,
|
|
mnaRCDisk,
|
|
mnaRCMem,
|
|
mnaRCProc,
|
|
mnaRCSwap,
|
|
mnaResource,
|
|
mnaSize,
|
|
mnaSlot,
|
|
mnaSpeed,
|
|
mnaSpeedW,
|
|
mnaStatATime,
|
|
mnaStatTTime,
|
|
mnaStatUTime,
|
|
mnaTaskCount,
|
|
mnaUsageW
|
|
};
|
|
|
|
|
|
|
|
enum MJobAttrEnum {
|
|
mjaNONE = 0,
|
|
mjaAccount,
|
|
mjaAllocNodeList,
|
|
mjaArgs,
|
|
mjaAWDuration, /* active wall time consumed */
|
|
mjaCalendar,
|
|
mjaCmdFile,
|
|
mjaCompletionTime,
|
|
mjaCPULimit,
|
|
mjaDepend,
|
|
mjaDRMJID,
|
|
mjaEEWDuration, /* effective eligible wall duration: duration job has been eligible for scheduling */
|
|
mjaEnv,
|
|
mjaExcHList,
|
|
mjaExecutable,
|
|
mjaFlags,
|
|
mjaGAttr,
|
|
mjaGroup,
|
|
mjaHold,
|
|
mjaHostList,
|
|
mjaIsInteractive,
|
|
mjaIsRestartable,
|
|
mjaIsSuspendable,
|
|
mjaIWD,
|
|
mjaJobID, /* job batch id */
|
|
mjaJobName, /* user specified job name */
|
|
mjaMasterHost,
|
|
mjaMessages,
|
|
mjaNotification,
|
|
mjaPAL,
|
|
mjaPriority,
|
|
mjaQOS,
|
|
mjaQOSReq,
|
|
mjaReqAWDuration, /* req active walltime duration */
|
|
mjaReqCMaxTime, /* req latest allowed completion time */
|
|
mjaReqNodes,
|
|
mjaReqProcs,
|
|
mjaReqReservation, /* req reservation */
|
|
mjaReqSMinTime, /* req earliest start time */
|
|
mjaRMJID, /* RM job ID */
|
|
mjaRMXString, /* RM extension string */
|
|
mjaRsvAccess,
|
|
mjaSRMJID,
|
|
mjaStartCount,
|
|
mjaStartTime, /* most recent time job started execution */
|
|
mjaState,
|
|
mjaStatMSUtl,
|
|
mjaStatPSDed,
|
|
mjaStatPSUtl,
|
|
mjaStdErr,
|
|
mjaStdIn,
|
|
mjaStdOut,
|
|
mjaStepID,
|
|
mjaSubmitLanguage,
|
|
mjaSubmitString,
|
|
mjaSubmitTime,
|
|
mjaSuspendDuration, /* duration job has been suspended */
|
|
mjaSysPrio,
|
|
mjaSysSMinTime,
|
|
mjaUser,
|
|
mjaUserPrio,
|
|
mjaUtlMem,
|
|
mjaUtlProcs };
|
|
|
|
enum MXAttrType {
|
|
mxaNONE,
|
|
mxaAdvRes,
|
|
mxaDDisk,
|
|
mxaDistPolicy,
|
|
mxaDMem,
|
|
mxaFlags,
|
|
mxaGeometry,
|
|
mxaHostList,
|
|
mxaMasterFeature,
|
|
mxaMasterMem,
|
|
mxaNAccessPolicy,
|
|
mxaNAllocPolicy,
|
|
mxaNodeSet,
|
|
mxaPMask,
|
|
mxaPref,
|
|
mxaQOS,
|
|
mxaQueueJob,
|
|
mxaSGE,
|
|
mxaSID,
|
|
mxaSJID,
|
|
mxaTPN,
|
|
mxaTRL };
|
|
|
|
enum MauiAppSimCommandEnum {
|
|
mascNONE,
|
|
mascConfig,
|
|
mascCreate,
|
|
mascDestroy,
|
|
mascQuery,
|
|
mascShow,
|
|
mascUpdate
|
|
};
|
|
|
|
enum MetaCtlCmdEnum {
|
|
mcNONE = 0,
|
|
mcInitialize,
|
|
mcCommit,
|
|
mcList,
|
|
mcSet,
|
|
mcRemove,
|
|
mcQuery,
|
|
mcSubmit,
|
|
mcModify,
|
|
mcResetStats,
|
|
mcRegister };
|
|
|
|
enum MJobCtlCmdEnum {
|
|
mjcmNONE = 0,
|
|
mjcmCancel,
|
|
mjcmCheckpoint,
|
|
mjcmDiagnose,
|
|
mjcmModify,
|
|
mjcmQuery,
|
|
mjcmRequeue,
|
|
mjcmResume,
|
|
mjcmShow,
|
|
mjcmStart,
|
|
mjcmSubmit,
|
|
mjcmSuspend,
|
|
mjcmTerminate };
|
|
|
|
enum MResCtlEnum {
|
|
mrcmNONE = 0,
|
|
mrcmCreate,
|
|
mrcmDestroy,
|
|
mrcmModify,
|
|
mrcmQuery };
|
|
|
|
enum MBalEnum {
|
|
mccmNONE = 0,
|
|
mccmExecute,
|
|
mccmQuery };
|
|
|
|
|
|
/* req object */
|
|
|
|
enum MReqAttrEnum {
|
|
mrqaNONE = 0,
|
|
mrqaAllocNodeList,
|
|
mrqaReqArch,
|
|
mrqaReqClass,
|
|
mrqaReqDiskPerTask,
|
|
mrqaReqMemPerTask,
|
|
mrqaReqNodeDisk,
|
|
mrqaReqNodeFeature,
|
|
mrqaReqNodeMem,
|
|
mrqaReqNodeProc,
|
|
mrqaReqNodeSwap,
|
|
mrqaReqOpsys,
|
|
mrqaPartition,
|
|
mrqaReqSwapPerTask,
|
|
mrqaNCReqMax,
|
|
mrqaNCReqMin,
|
|
mrqaTCReqMax,
|
|
mrqaTCReqMin,
|
|
mrqaTPN };
|
|
|
|
|
|
|
|
/* sched object */
|
|
|
|
enum MSchedAttrEnum {
|
|
msaNONE = 0,
|
|
msaCPVersion,
|
|
msaFBServer,
|
|
msaHomeDir,
|
|
msaMode,
|
|
msaName,
|
|
msaServer
|
|
};
|
|
|
|
enum MClientAttrEnum {
|
|
mcltaNONE = 0,
|
|
mcltaCSAlgo,
|
|
mcltaTimeout,
|
|
mcltaFlags };
|
|
|
|
enum MWCVioActEnum {
|
|
mwcvaNONE = 0,
|
|
mwcvaCancel,
|
|
mwcvaPreempt
|
|
};
|
|
|
|
enum MPreemptPolicyEnum {
|
|
mppNONE = 0,
|
|
mppRequeue,
|
|
mppSuspend,
|
|
mppCheckpoint,
|
|
mppOvercommit };
|
|
|
|
#define DEFAULT_MPREEMPTPOLICY mppRequeue
|
|
|
|
|
|
|
|
/* sys object */
|
|
|
|
enum MSysAttrType {
|
|
msysaNONE = 0,
|
|
msysaPresentTime,
|
|
msysaStatInitTime,
|
|
msysaSyncTime,
|
|
msysaVersion
|
|
};
|
|
|
|
|
|
/* priority mode */
|
|
|
|
enum MJobPrioEnum {
|
|
mjpNONE = 0,
|
|
mjpRelative,
|
|
mjpAbsolute };
|
|
|
|
|
|
/* checkpoint modes */
|
|
|
|
enum MCKPtModeEnum {
|
|
mckptResOnly = 0,
|
|
mckptNonRes
|
|
};
|
|
|
|
|
|
/* cluster object */
|
|
|
|
enum MClusterAttrType {
|
|
mcluaNONE = 0,
|
|
mcluaMaxSlot,
|
|
mcluaName,
|
|
mcluaPresentTime
|
|
};
|
|
|
|
|
|
/* frame object */
|
|
|
|
enum MFrameAttrType {
|
|
mfraNONE = 0,
|
|
mfraIndex,
|
|
mfraName
|
|
};
|
|
|
|
#define DEFAULT_MHSERVER "supercluster.org"
|
|
#define DEFAULT_MHPORT 80
|
|
#define DEFAULT_MHSYNCLOCATION "/maui/syncdir/326/update.html"
|
|
|
|
#define MAX_MCFG 512
|
|
|
|
typedef struct {
|
|
char *Name;
|
|
int PIndex;
|
|
int Format;
|
|
int OType;
|
|
void *OPtr;
|
|
} mcfg_t;
|
|
|
|
|
|
|
|
/* node allocation policies */
|
|
|
|
enum MNodeAllocationPolicies {
|
|
mnalNONE2 = 0,
|
|
mnalFirstAvailable,
|
|
mnalLastAvailable,
|
|
mnalMinLocal,
|
|
mnalMinGlobal,
|
|
mnalMinResource,
|
|
mnalMachinePrio,
|
|
mnalCPULoad,
|
|
mnalFirstSet,
|
|
mnalLocal,
|
|
mnalContiguous,
|
|
mnalMaxBalance,
|
|
mnalFastest
|
|
};
|
|
|
|
#define DEFAULT_MNALLOCPOLICY mnalLastAvailable
|
|
|
|
|
|
|
|
/* RM objects */
|
|
|
|
#define MMIN_LLCFGDISK 1 /* (in MB) */
|
|
|
|
|
|
|
|
/* client object */
|
|
|
|
typedef struct {
|
|
char Name[MAX_MNAME];
|
|
char CSKey[MAX_MNAME];
|
|
} mclient_t;
|
|
|
|
typedef struct {
|
|
char ServerHost[MAX_MNAME];
|
|
int ServerPort;
|
|
long Timeout;
|
|
|
|
int Format;
|
|
|
|
int SocketProtocol;
|
|
|
|
char ServerCSKey[MAX_MNAME];
|
|
|
|
enum MChecksumAlgoEnum ServerCSAlgo;
|
|
|
|
char ConfigFile[MAX_MLINE];
|
|
char HomeDir[MAX_MLINE];
|
|
|
|
char SchedulerMode[MAX_MNAME];
|
|
|
|
char BuildDir[MAX_MLINE];
|
|
char BuildHost[MAX_MLINE];
|
|
char BuildDate[MAX_MLINE];
|
|
|
|
long DisplayFlags;
|
|
} mccfg_t;
|
|
|
|
|
|
|
|
/* extension support */
|
|
|
|
typedef struct {
|
|
/* base functions */
|
|
|
|
int (*JobAllocateResources)(mjob_t *, mnodelist_t, char *, mnodelist_t, int, long int);
|
|
int (*JobCheckPolicies)(mjob_t *,int,int,mpar_t *,int *,char *,long int);
|
|
int (*JobDistributeTasks)(mjob_t *,mrm_t *,mnalloc_t *,short int *);
|
|
int (*JobFind)(char *, mjob_t **, int);
|
|
int (*JobGetFeasibleTasks)(mjob_t *,mreq_t *,mpar_t *,nodelist_t,nodelist_t,int *,int *,long int,long unsigned int);
|
|
int (*JobGetStartPriority)(mjob_t *,int,double *,int,char **,int *);
|
|
int (*JobGetTasks)(mjob_t *,mpar_t *,nodelist_t,mnodelist_t,char *,int);
|
|
int (*JobSetCreds)(mjob_t *, char *, char *, char *);
|
|
int (*JobSetQOS)(mjob_t *, mqos_t *, int);
|
|
int (*JobBuildACL)(mjob_t *);
|
|
int (*JobBuildCL)(mjob_t *);
|
|
char *(*JobNameAdjust)(mjob_t *,char *,mrm_t *,char *,int,enum MJobNameEnum);
|
|
int (*JobStart)(mjob_t *);
|
|
int (*JobValidate)(mjob_t *,char *,int);
|
|
int (*JobDetermineCreds)(mjob_t *);
|
|
int (*QOSGetAccess)(mjob_t *,mqos_t *,int *,mqos_t **);
|
|
|
|
int (*QueuePrioritizeJobs)(mjob_t **,int *);
|
|
int (*QueueScheduleJobs)(int *,mpar_t *);
|
|
|
|
int (*ReservationCreate)(int,macl_t *,char *,long unsigned int,mnalloc_t *,long int,long int,int,int,char *,mres_t **, char *,mcres_t *);
|
|
int (*ReservationDestroy)(mres_t **);
|
|
int (*ReservationJCreate)(mjob_t *, mnodelist_t, long int, int, mres_t **);
|
|
int (*ResFind)(char *, mres_t **);
|
|
int (*AcctFind)(char *,mgcred_t **);
|
|
int (*JobGetRange)(mjob_t *,mreq_t *,mpar_t *,long int,mrange_t *,mnodelist_t,int *,char *,int,mrange_t *);
|
|
int (*BackFill)(int *, int, mpar_t *);
|
|
int (*DoWikiCommand)(char *,int,long,int,char *,char **,long int *,int *);
|
|
int (*JobGetSNRange)(mjob_t *,mreq_t *,mnode_t *,mrange_t *,int,char *,int *,mrange_t *,mcres_t *,char *);
|
|
int (*LL2ShowError)(int,mjob_t *);
|
|
int (*PBSInitialize)();
|
|
int (*RMCancelJob)(mjob_t *,char *,int *);
|
|
int (*RMJobStart)(mjob_t *,char *,int *);
|
|
int (*SimJobSubmit)(long int,mjob_t **,void *,int);
|
|
int (*SRCreate)(sres_t *, int, int);
|
|
int (*WikiLoadJob)(char *,char *,mjob_t *,short int *,mrm_t *);
|
|
int (*QBankDoTransaction)(mam_t *,int,char *,void **,int *,char *);
|
|
int (*JobSetAttr)(mjob_t *,enum MJobAttrEnum,void **,int,int);
|
|
int (*ResSetAttr)(mres_t *,enum MResAttrEnum,void *,int,int);
|
|
|
|
/* extension functions */
|
|
|
|
int (*XInitializeMauiInterface)();
|
|
int (*XShowConfig)(void *,int,char *,long);
|
|
|
|
int (*XPBSNMGetData)(void *,mnode_t *,mrm_t *);
|
|
|
|
int (*XAllocateNodes)();
|
|
int (*XBackfill)();
|
|
int (*XPrioritizeJobs)();
|
|
int (*XDiagnoseJobs)();
|
|
|
|
int (*XRMInitialize)(void *,mrm_t *);
|
|
int (*XRMResetState)(void *,mrm_t *);
|
|
int (*XRMVerifyData)(void *,mrm_t *,char *);
|
|
int (*XRMDataIsStaging)(void *,void *);
|
|
int (*XRMGetData)(void *,int);
|
|
int (*XUpdateState)();
|
|
int (*XRMJobSuspend)();
|
|
int (*XRMJobResume)();
|
|
int (*XRMJobSubmit)(void *,char *,mrm_t *,mjob_t **,char *,char *,int *);
|
|
|
|
int (*XQueueScheduleJobs)();
|
|
|
|
int (*XLLInitialize)();
|
|
int (*XLL2JobLoad)();
|
|
int (*XLL2JobUpdate)();
|
|
int (*XLL2NodeLoad)();
|
|
int (*XLL2NodeUpdate)();
|
|
|
|
int (*XJobProcessWikiAttr)(void *,mjob_t *,char *);
|
|
int (*XJobGetStartPriority)(void *,mjob_t *,double *,char *);
|
|
int (*XPBSInitialize)(void *, mrm_t *);
|
|
int (*XPBSJobLoad)();
|
|
int (*XWikiDoCommand)();
|
|
int (*XWikiJobLoad)();
|
|
|
|
int (*XMetaStoreCompletedJobInfo)(void *,mjob_t *);
|
|
|
|
int (*XAllocMachinePrio)();
|
|
int (*XAllocLoadBased)();
|
|
|
|
int (*XUIHandler)(void *,msocket_t *,char *,int);
|
|
|
|
int (*XGetClientInfo)(void *,msocket_t *,char *);
|
|
int (*XGetTime)(void *,long *,int);
|
|
int (*XSleep)(void *,long);
|
|
|
|
int (*XResInit)();
|
|
int (*XResUpdate)(void *,mres_t *);
|
|
int (*XResDestroy)(void *,mres_t *);
|
|
int (*XResShow)(void *,mres_t *,char *);
|
|
char *(*XResCPCreate)(void *,mres_t *);
|
|
int (*XResCPLoad)(void *,char *,mres_t *);
|
|
|
|
int (*XJobPreInit)(void *,mjob_t *);
|
|
int (*XJobPostInit)(void *,mjob_t *,int);
|
|
int (*XJobUpdate)(void *,mjob_t *);
|
|
int (*XJobDestroy)(void *,mjob_t **,int);
|
|
int (*XJobShow)(void *,mjob_t *,char *);
|
|
int (*XJobProcessRMXString)(void *,mjob_t *,char *);
|
|
int (*XJobAllocateResources)(mjob_t *,mnodelist_t,char *,mnodelist_t,int,long);
|
|
|
|
/* base scheduler data */
|
|
|
|
mgcred_t **User;
|
|
mgcred_t *Group;
|
|
mgcred_t *Acct;
|
|
mqos_t *MQOS;
|
|
|
|
mattrlist_t *AttrList;
|
|
msched_t *Sched;
|
|
long *CREndTime;
|
|
char *CurrentHostName;
|
|
mlog_t *dlog;
|
|
mfsc_t *FS;
|
|
mjob_t **Job;
|
|
mnode_t **MNode;
|
|
mrange_t *MRange;
|
|
mpar_t *MPar;
|
|
mulong *PresentTime;
|
|
sres_t *OSRes;
|
|
mres_t **Res;
|
|
mrm_t *RM;
|
|
mam_t *AM;
|
|
sres_t *SRes;
|
|
mstat_t *Stat;
|
|
|
|
/* extension data */
|
|
|
|
void *xd;
|
|
} mx_t;
|
|
|
|
|
|
typedef struct {
|
|
long MTime;
|
|
long ETime;
|
|
long WallTime;
|
|
|
|
long WCLimit;
|
|
|
|
int JobSwapLimit;
|
|
int JobMemLimit;
|
|
|
|
int NCPUs;
|
|
int NodesRequested;
|
|
int ProcsRequested;
|
|
|
|
long ProcCPULimit;
|
|
long JobCPULimit;
|
|
|
|
long UtlJobCPUTime;
|
|
} tpbsa_t;
|
|
|
|
enum MFormatModeEnum {
|
|
mfmNONE = 0,
|
|
mfmHuman,
|
|
mfmHTTP,
|
|
mfmXML,
|
|
mfmAVP,
|
|
mfmVerbose };
|
|
|
|
enum MauiObjectSetModeEnum {
|
|
mosNONE = 0,
|
|
mVerify,
|
|
mSet,
|
|
mAdd,
|
|
mClear,
|
|
mUnset };
|
|
|
|
#define MMAX_NODE_PER_FRAG 1024
|
|
|
|
|
|
/* macros */
|
|
|
|
#define MOINITLOOP(OP,OI,OS,OE) \
|
|
*(OP)=MSched.T[OI]; \
|
|
*(OS)=MSched.S[OI]; \
|
|
*(OE)=MSched.E[OI];
|
|
|
|
#define MNODEISUP(N) \
|
|
(((N->State == mnsIdle) || (N->State == mnsActive) || (N->State == mnsBusy) \
|
|
|| (N->State == mnsDraining) || (N->State == mnsReserved)) ? TRUE : FALSE)
|
|
|
|
#define MNODEISACTIVE(N) \
|
|
(((N->State == mnsBusy) || (N->State == mnsActive) || (N->State == mnsDraining)) ? TRUE : FALSE)
|
|
|
|
#define MJOBISACTIVE(J) \
|
|
(((J->State == mjsStarting) || (J->State == mjsRunning)) ? TRUE : FALSE)
|
|
|
|
#define MJOBISALLOC(J) \
|
|
(((J->State == mjsStarting) || (J->State == mjsRunning) || (J->State == mjsSuspended)) ? TRUE : FALSE)
|
|
|
|
#define MJOBISSUSPEND(J) \
|
|
(((J)->State == mjsSuspended) ? TRUE : FALSE)
|
|
|
|
#define MJOBISCOMPLETE(J) \
|
|
(((J->State == mjsCompleted) || (J->State == mjsRemoved) || (J->State == mjsVacated)) ? TRUE : FALSE)
|
|
|
|
#define MJOBISSCOMPLETE(J) \
|
|
(((J->State == mjsCompleted)) ? TRUE : FALSE)
|
|
|
|
#define MJOBISFCOMPLETE(J) \
|
|
(((J->State == mjsRemoved) || (J->State == mjsVacated)) ? TRUE : FALSE)
|
|
|
|
#define MISSET(B,F) \
|
|
(((B) & (1 << (F))) ? TRUE : FALSE)
|
|
|
|
#define MSET(B,F) \
|
|
(B) |= (1 << (F))
|
|
|
|
#define MUNSET(B,F) \
|
|
(B) &= ~(1 << (F))
|
|
|
|
#define MMAX_PID 32
|
|
|
|
/* ended processes */
|
|
|
|
typedef struct {
|
|
int PID;
|
|
int StatLoc;
|
|
} mpid_t;
|
|
|
|
/* sync w/MSAN[] */
|
|
|
|
enum MSSSAttrNameEnum {
|
|
msanNONE = 0,
|
|
msanAction,
|
|
msanArgs,
|
|
msanFlags,
|
|
msanName,
|
|
msanObject,
|
|
msanOp,
|
|
msanOption,
|
|
msanValue,
|
|
msanLAST };
|
|
|
|
|
|
/* sync w/MSON */
|
|
|
|
enum MSSSObjNameEnum {
|
|
msonNONE = 0,
|
|
msonBody,
|
|
msonData,
|
|
msonEnvelope,
|
|
msonGet,
|
|
msonObject,
|
|
msonRequest,
|
|
msonResponse,
|
|
msonSet,
|
|
msonWhere };
|
|
|
|
#include "moab-wiki.h"
|
|
|
|
#ifndef __MX
|
|
#define __MX
|
|
#endif /* __MX */
|
|
|
|
#if !defined(__MX)
|
|
#define MAX_SUNAME 64
|
|
#define MAX_SULINE 1024
|
|
#define MAX_G2XMLATTR 64
|
|
#define DEFAULT_G2XMLICCOUNT 16
|
|
#else /* !__MX */
|
|
#include "mg2.h"
|
|
#endif /* !__MX */
|
|
|
|
#ifdef __M_H
|
|
|
|
#define MAM_CLIENTTYPE "maui"
|
|
|
|
#endif /* __M_H */
|
|
|
|
#endif /* __MOAB_H */
|
|
|
|
/* END moab.h */
|