LSF_Batch
view release on metacpan or search on metacpan
CODE:
s = (struct submit *)safemalloc(sizeof(struct submit));
j = (LSF_Batch_job *)safemalloc(sizeof(LSF_Batch_job));
initialize_submit(s);
if( format_submit(s, sub) == 0 ){
jobId = lsb_submit( s, &reply);
j->jobId = LSB_ARRAY_JOBID(jobId);
j->arrayIdx = LSB_ARRAY_IDX(jobId);
if(jobId != -1){
strncpy(j->queue, reply.queue, MAX_LSB_NAME_LEN);
}
else{
j->badJobId = reply.badJobId;
j->badReqIndx = reply.badReqIndx;
strncpy(j->badJobName, reply.badJobName, MAX_LSB_NAME_LEN);
STATUS_NATIVE_SET(lsberrno);
SET_LSB_ERRMSG;
}
}
else{
j->jobId = -1;
}
free_submit(s);
RETVAL = j;
OUTPUT:
RETVAL
int
lsb_hostcontrol(self, host, opcode)
void *self
char *host
int opcode;
PREINIT:
struct hostCtrlReq *req;
CODE:
req = (struct hostCtrlReq *)safemalloc(sizeof(struct hostCtrlReq));
bzero(req,sizeof(struct hostCtrlReq));
req->host = host;
req->opCode = opcode;
if( lsb_hostcontrol(req) < 0 ){
STATUS_NATIVE_SET(lsberrno);
SET_LSB_ERRMSG;
RETVAL = 0;
}
else{
RETVAL = 1;
}
safefree(req);
OUTPUT:
RETVAL
void
lsb_hostinfo(self, hosts)
void *self
char **hosts
PREINIT:
SV *rv;
char **h;
int i, count = 0, num = 0;
LSF_Batch_hostInfo *p, *hinfo;
PPCODE:
for( h = hosts; hosts && *h; h++ )count++;
num = count;
if( count == 0 ) hosts = NULL;
hinfo = lsb_hostinfo(hosts, &num);
if(hinfo == NULL){
STATUS_NATIVE_SET(lsberrno);
SET_LSB_ERRMSG;
XSRETURN_EMPTY;
}
for( i = 0, p = hinfo; i < num; i++,p++ ){
rv = newRV_inc(&PL_sv_undef);
sv_setref_iv(rv, "LSF::Batch::hostInfoPtr",(IV)p);
XPUSHs(sv_2mortal(rv));
}
XSRETURN(num);
void
lsb_hostinfo_ex(self, hosts, resreq, options)
void *self
char **hosts
char *resreq
int options
PREINIT:
SV *rv;
char **h;
int i, count = 0, num;
LSF_Batch_hostInfo *p, *hinfo;
PPCODE:
for( h = hosts; hosts && *h; h++ )count++;
num = count;
if( count == 0 ) hosts = NULL;
if(strlen(resreq)==0) resreq = NULL;
hinfo = lsb_hostinfo_ex(hosts, &num, resreq, options);
if(hinfo == NULL){
STATUS_NATIVE_SET(lsberrno);
SET_LSB_ERRMSG;
XSRETURN_EMPTY;
}
for( i = 0, p = hinfo; i < num; i++,p++ ){
rv = newRV_inc(&PL_sv_undef);
sv_setref_iv(rv, "LSF::Batch::hostInfoPtr",(IV)p);
XPUSHs(sv_2mortal(rv));
}
XSRETURN(num);
void
lsb_gethostlist(self)
void *self
PREINIT:
int ret;
int nhosts = 0;
char **p = NULL;
char **hosts = NULL;
PPCODE:
ret = lsb_getalloc(&hosts);
if (ret < 0) {
STATUS_NATIVE_SET(lsberrno);
SET_LSB_ERRMSG;
XSRETURN_EMPTY;
} else {
for(p = hosts; *p != NULL; p ++ ){
nhosts ++;
XPUSHs(sv_2mortal(newSVpv(*p,0)));
}
}
XSRETURN(nhosts);
int
do_launch(where, argv, userOptions)
char **where
char **argv
int userOptions
PREINIT:
int count = 0;
char **p;
CODE:
for (p = where; where && *p != NULL; p ++) count ++;
if (count == 0) where =NULL;
for (p = argv; argv && *p != NULL; p ++) count ++;
if (count == 0) argv =NULL;
if ((RETVAL = lsb_launch(where, argv, userOptions, NULL)) < 0) {
STATUS_NATIVE_SET(lsberrno);
SET_LSB_ERRMSG;
RETVAL = 0;
}
OUTPUT:
RETVAL
int
lsb_removereservation (self, rvsid)
void * self
char * rvsid
CODE:
if(lsb_removereservation(rvsid) <0) {
STATUS_NATIVE_SET(lsberrno);
SET_LSB_ERRMSG;
RETVAL = 0;
} else {
RETVAL = 1;
}
OUTPUT:
RETVAL
void
lsb_reservationinfo (self, rvsid)
void * self
char * rvsid
PREINIT:
struct rsvInfoEnt *res;
int num;
int j;
SV *rv;
LSF_Batch_rsvInfoEnt *p;
PPCODE:
if (strlen(rvsid) == 0) rvsid = NULL;
res = lsb_reservationinfo(rvsid, &num, 0);
if (lsberrno != LSBE_NO_ERROR) {
STATUS_NATIVE_SET(lsberrno);
SET_LSB_ERRMSG;
XSRETURN_EMPTY;
}
if (num == 0) {
XPUSHs(sv_2mortal(newSVnv(0)));
XSRETURN(1);
}
for (j = 0, p = res; j < num; j ++, p ++) {
rv = newRV_inc(&PL_sv_undef);
sv_setref_iv(rv, "LSF::Batch::rsvInfoEntPtr", (IV)p);
XPUSHs(sv_2mortal(rv));
}
XSRETURN(num);
MODULE = LSF::Batch PACKAGE = LSF::Batch::rsvInfoEntPtr PREFIX = rie_
char *
rie_options(self)
LSF_Batch_rsvInfoEnt *self
CODE:
if (self->options & RSV_OPTION_SYSTEM) {
RETVAL = "sys";
} else if(self->options & RSV_OPTION_GROUP) {
RETVAL = "group";
} else if(self->options & RSV_OPTION_USER) {
RETVAL = "user";
} else {
RETVAL = "-";
}
OUTPUT:
RETVAL
char *
rie_name(self)
LSF_Batch_rsvInfoEnt *self
CODE:
RETVAL = self->name;
OUTPUT:
RETVAL
char *
rie_rsvId(self)
LSF_Batch_rsvInfoEnt *self
CODE:
RETVAL = self->rsvId;
OUTPUT:
RETVAL
char *
rie_timeWindow(self)
LSF_Batch_rsvInfoEnt *self
CODE:
RETVAL = self->timeWindow;
OUTPUT:
RETVAL
void
rie_rsvHosts(self)
LSF_Batch_rsvInfoEnt *self
PREINIT:
int i;
SV *rv;
PPCODE:
for (i = 0; i < self->numRsvHosts; i ++) {
rv = newRV_inc(&PL_sv_undef);
sv_setref_iv(rv, "LSF::Batch::hostRsvInfoEntPtr", (IV)(self->rsvHosts+i));
XPUSHs(sv_2mortal(rv));
}
XSRETURN(self->numRsvHosts);
void
rie_jobIds(self)
LSF_Batch_rsvInfoEnt *self
PREINIT:
int i;
PPCODE:
for (i = 0; i < self->numRsvJobs; i ++) {
XPUSHs(sv_2mortal(newSViv(self->jobIds[i])));
}
XSRETURN(self->numRsvJobs);
void
rie_jobStatus(self)
LSF_Batch_rsvInfoEnt *self
PREINIT:
int i;
PPCODE:
for (i = 0; i < self->numRsvJobs; i ++) {
XPUSHs(sv_2mortal(newSViv(self->jobStatus[i])));
}
XSRETURN(self->numRsvJobs);
MODULE = LSF::Batch PACKAGE = LSF::Batch::hostRsvInfoEntPtr PREFIX = hrie_
char *
hrie_host(self)
LSF_Batch_hostRsvInfoEnt *self
CODE:
RETVAL = self->host;
OUTPUT:
RETVAL
int
hrie_numCPUs(self)
LSF_Batch_hostRsvInfoEnt *self
CODE:
RETVAL = self->numCPUs;
OUTPUT:
RETVAL
int
hrie_numSlots(self)
LSF_Batch_hostRsvInfoEnt *self
CODE:
RETVAL = self->numSlots;
OUTPUT:
RETVAL
int
hrie_numRsvProcs(self)
LSF_Batch_hostRsvInfoEnt *self
CODE:
RETVAL = self->numRsvProcs;
OUTPUT:
RETVAL
int
hrie_numUsedProcs(self)
LSF_Batch_hostRsvInfoEnt *self
CODE:
RETVAL = self->numUsedProcs;
OUTPUT:
RETVAL
MODULE = LSF::Batch PACKAGE = LSF::Batch::hostInfoPtr PREFIX = hi_
char *
hi_host(self)
LSF_Batch_hostInfo *self;
CODE:
RETVAL = self->host;
OUTPUT:
RETVAL
int
hi_hStatus(self)
LSF_Batch_hostInfo *self;
CODE:
RETVAL = self->hStatus;
OUTPUT:
RETVAL
void
hi_busySched(self)
LSF_Batch_hostInfo *self;
PREINIT:
int i;
PPCODE:
for( i = 0; i < self->nIdx; i++)
XPUSHs(sv_2mortal(newSVnv(self->busySched[i])));
XSRETURN(self->nIdx);
void
hi_busyStop(self)
LSF_Batch_hostInfo *self;
PREINIT:
int i;
PPCODE:
for( i = 0; i < self->nIdx; i++)
XPUSHs(sv_2mortal(newSVnv(self->busyStop[i])));
XSRETURN(self->nIdx);
void
hi_load(self)
LSF_Batch_hostInfo *self;
PREINIT:
int i;
PPCODE:
for( i = 0; i < self->nIdx; i++)
XPUSHs(sv_2mortal(newSVnv(self->load[i])));
XSRETURN(self->nIdx);
void
hi_loadSched(self)
LSF_Batch_hostInfo *self;
PREINIT:
int i;
PPCODE:
for( i = 0; i < self->nIdx; i++)
XPUSHs(sv_2mortal(newSVnv(self->loadSched[i])));
XSRETURN(self->nIdx);
void
hi_loadStop(self)
LSF_Batch_hostInfo *self;
PREINIT:
int i;
PPCODE:
for( i = 0; i < self->nIdx; i++)
XPUSHs(sv_2mortal(newSVnv(self->loadStop[i])));
XSRETURN(self->nIdx);
char *
hi_windows(self)
LSF_Batch_hostInfo *self;
CODE:
RETVAL = self->windows;
OUTPUT:
RETVAL
int
hi_userJobLimit(self)
LSF_Batch_hostInfo *self;
CODE:
RETVAL = self->userJobLimit;
OUTPUT:
RETVAL
int
hi_maxJobs(self)
LSF_Batch_hostInfo *self;
CODE:
RETVAL = self->maxJobs;
OUTPUT:
RETVAL
int
hi_numJobs(self)
LSF_Batch_hostInfo *self;
CODE:
RETVAL = self->numJobs;
OUTPUT:
RETVAL
int
hi_numRUN(self)
LSF_Batch_hostInfo *self;
CODE:
RETVAL = self->numRUN;
OUTPUT:
RETVAL
int
hi_numSSUSP(self)
LSF_Batch_hostInfo *self;
CODE:
RETVAL = self->numSSUSP;
OUTPUT:
RETVAL
int
hi_numUSUSP(self)
LSF_Batch_hostInfo *self;
CODE:
RETVAL = self->numUSUSP;
OUTPUT:
RETVAL
int
hi_numRESERVE(self)
LSF_Batch_hostInfo *self;
CODE:
RETVAL = self->numRESERVE;
OUTPUT:
RETVAL
int
hi_mig(self)
LSF_Batch_hostInfo *self;
CODE:
RETVAL = self->mig;
OUTPUT:
RETVAL
int
hi_attr(self)
LSF_Batch_hostInfo *self;
CODE:
RETVAL = self->attr;
OUTPUT:
RETVAL
void
hi_realLoad(self)
LSF_Batch_hostInfo *self;
PREINIT:
int i;
PPCODE:
for( i = 0; i < self->nIdx; i++)
XPUSHs(sv_2mortal(newSVnv(self->realLoad[i])));
XSRETURN(self->nIdx);
int
hi_chkSig(self)
LSF_Batch_hostInfo *self;
CODE:
RETVAL = self->chkSig;
OUTPUT:
RETVAL
#if LSF_VERSION >= 18
float
hi_cpuFactor(self)
LSF_Batch_hostInfo *self;
CODE:
RETVAL = self->cpuFactor;
OUTPUT:
RETVAL
int
hi_nIdxr(self)
LSF_Batch_hostInfo *self;
CODE:
RETVAL = self->nIdx;
OUTPUT:
RETVAL
float
hi_cnsmrUsage(self)
LSF_Batch_hostInfo *self;
CODE:
RETVAL = self->cnsmrUsage;
OUTPUT:
RETVAL
float
hi_prvdrUsage(self)
LSF_Batch_hostInfo *self;
CODE:
RETVAL = self->prvdrUsage;
OUTPUT:
RETVAL
float
hi_cnsmrAvail(self)
LSF_Batch_hostInfo *self;
CODE:
RETVAL = self->cnsmrAvail;
OUTPUT:
RETVAL
float
hi_prvdrAvail(self)
LSF_Batch_hostInfo *self;
CODE:
RETVAL = self->prvdrAvail;
OUTPUT:
RETVAL
float
hi_maxAvail(self)
LSF_Batch_hostInfo *self;
CODE:
RETVAL = self->maxAvail;
OUTPUT:
RETVAL
float
hi_maxExitRate(self)
LSF_Batch_hostInfo *self;
CODE:
RETVAL = self->maxExitRate;
OUTPUT:
RETVAL
float
hi_numExitRate(self)
LSF_Batch_hostInfo *self;
CODE:
RETVAL = self->numExitRate;
OUTPUT:
RETVAL
char *
hi_hCtrlMsg(self)
LSF_Batch_hostInfo *self;
CODE:
RETVAL = self->hCtrlMsg;
OUTPUT:
RETVAL
#endif
MODULE = LSF::Batch PACKAGE = LSF::Batch PREFIX = lsb_
void
lsb_usergrpinfo(self, groups, options)
void *self
char **groups
int options
PREINIT:
char **g;
int i, count = 0, num;
struct groupInfoEnt *p, *gi;
PPCODE:
for( g = groups; groups && *g; g++ )count++;
num = count;
if( count == 0 ) groups = NULL;
gi = lsb_usergrpinfo(groups, &num, options);
if(gi == NULL){
STATUS_NATIVE_SET(lsberrno);
if(lsberrno == LSBE_BAD_GROUP){
char e[100];
sprintf(e,"group %s is unknown to LSF", groups[num]);
SET_LSB_ERRMSG_TO(e);
}
else
SET_LSB_ERRMSG;
XSRETURN_EMPTY;
}
for( i = 0, p = gi; i < num; i++,p++ ){
XPUSHs(sv_2mortal(newSVpv(p->group,0)));
XPUSHs(sv_2mortal(newSVpv(p->memberList,0)));
}
XSRETURN(num*2);
void
lsb_hostgrpinfo(self, groups, options)
void *self
char **groups
int options
PREINIT:
char **g;
int i, count = 0, num;
struct groupInfoEnt *p, *gi;
PPCODE:
for( g = groups; groups && *g; g++ )count++;
num = count;
if( count == 0 ) groups = NULL;
gi = lsb_hostgrpinfo(groups, &num, options);
if(gi == NULL){
STATUS_NATIVE_SET(lsberrno);
if(lsberrno == LSBE_BAD_GROUP){
char e[100];
sprintf(e,"group %s is unknown to LSF", groups[num]);
SET_LSB_ERRMSG_TO(e);
}
else
SET_LSB_ERRMSG;
XSRETURN_EMPTY;
}
for( i = 0, p = gi; i < num; i++,p++ ){
XPUSHs(sv_2mortal(newSVpv(p->group,0)));
XPUSHs(sv_2mortal(newSVpv(p->memberList,0)));
}
XSRETURN(num*2);
void
lsb_userinfo(self, users)
void *self
char **users
PREINIT:
SV *rv;
int i, count=0, num;
LSF_Batch_userInfo *ui, *p;
char **c;
PPCODE:
for( c = users; users && *c; c++ ) count++;
num = count;
if( count == 0 ) users = NULL;
ui = lsb_userinfo(users, &num );
fflush(stdout);
if(ui == NULL){
STATUS_NATIVE_SET(lsberrno);
SET_LSB_ERRMSG;
XSRETURN_EMPTY;
}
for( i = 0, p = ui; i < num; i++,p++ ){
rv = newRV_inc(&PL_sv_undef);
sv_setref_iv(rv, "LSF::Batch::userInfoPtr",(IV)p);
XPUSHs(sv_2mortal(rv));
}
XSRETURN(num);
MODULE = LSF::Batch PACKAGE = LSF::Batch::userInfoPtr PREFIX = ui_
char *
ui_user(self)
LSF_Batch_userInfo *self
CODE:
RETVAL = self->user;
OUTPUT:
RETVAL
int
ui_procJobLimit(self)
LSF_Batch_userInfo *self
CODE:
RETVAL = self->procJobLimit;
OUTPUT:
RETVAL
int
ui_maxJobs(self)
LSF_Batch_userInfo *self
CODE:
RETVAL = self->maxJobs;
OUTPUT:
RETVAL
int
ui_numStartJobs(self)
LSF_Batch_userInfo *self
CODE:
RETVAL = self->numStartJobs;
OUTPUT:
RETVAL
int
ui_numJobs(self)
LSF_Batch_userInfo *self
CODE:
RETVAL = self->numJobs;
OUTPUT:
RETVAL
int
RETVAL
int
pi_sschedMaxRuntime(self)
LSF_Batch_parameterInfo *self;
CODE:
RETVAL = self->sschedMaxRuntime;
OUTPUT:
RETVAL
char *
pi_sschedAcctDir(self)
LSF_Batch_parameterInfo *self;
CODE:
RETVAL = self->sschedAcctDir;
OUTPUT:
RETVAL
#endif
MODULE = LSF::Batch PACKAGE = LSF::Batch PREFIX = lsb_
int
lsb_queuecontrol(self, queue, opcode)
void *self
char *queue
int opcode
PREINIT:
struct queueCtrlReq *req;
CODE:
req = (struct queueCtrlReq *)safemalloc(sizeof(struct queueCtrlReq));
bzero(req,sizeof(struct queueCtrlReq));
req->queue = queue;
req->opCode = opcode;
if( lsb_queuecontrol(req) < 0 ){
STATUS_NATIVE_SET(lsberrno);
SET_LSB_ERRMSG;
RETVAL = 0;
}
else{
RETVAL = 1;
}
safefree(req);
OUTPUT:
RETVAL
void
lsb_queueinfo(self, queues, host, user, options)
void *self
char **queues
char *host
char *user
int options
PREINIT:
SV *rv;
char **q;
int i, count = 0, num = 0;
LSF_Batch_queueInfo *p, *qinfo;
PPCODE:
for( q = queues; queues && *q; q++ ) count++;
num = count;
if( count == 0 ) queues = NULL;
if(strlen(host)==0) host = NULL;
if(strlen(user)==0) user = NULL;
qinfo = lsb_queueinfo(queues, &num, host, user, options);
if(qinfo == NULL){
STATUS_NATIVE_SET(lsberrno);
SET_LSB_ERRMSG;
XSRETURN_EMPTY;
}
for( i = 0, p = qinfo; i < num; i++,p++ ){
rv = newRV_inc(&PL_sv_undef);
sv_setref_iv(rv, "LSF::Batch::queueInfoPtr",(IV)p);
XPUSHs(sv_2mortal(rv));
}
XSRETURN(num);
MODULE = LSF::Batch PACKAGE = LSF::Batch::queueInfoPtr PREFIX = qi_
char *
qi_queue(self)
LSF_Batch_queueInfo *self
CODE:
RETVAL = self->queue;
OUTPUT:
RETVAL
char *
qi_description(self)
LSF_Batch_queueInfo *self
CODE:
RETVAL = self->description;
OUTPUT:
RETVAL
int
qi_priority(self)
LSF_Batch_queueInfo *self
CODE:
RETVAL = self->priority;
OUTPUT:
RETVAL
short
qi_nice(self)
LSF_Batch_queueInfo *self
CODE:
RETVAL = self->nice;
OUTPUT:
RETVAL
char *
qi_userList(self)
LSF_Batch_queueInfo *self
CODE:
RETVAL = self->userList;
OUTPUT:
RETVAL
char *
qi_hostList(self)
LSF_Batch_queueInfo *self
CODE:
RETVAL = self->hostList;
OUTPUT:
RETVAL
void
qi_loadSched(self)
LSF_Batch_queueInfo *self
PREINIT:
int i;
float *f;
PPCODE:
for( i = 0; i < self->nIdx; i++){
XPUSHs(sv_2mortal(newSVnv(self->loadSched[i])));
}
XSRETURN(self->nIdx);
void
qi_loadStop(self)
LSF_Batch_queueInfo *self
PREINIT:
int i;
PPCODE:
for( i = 0; i < self->nIdx; i++){
XPUSHs(sv_2mortal(newSVnv(self->loadSched[i])));
}
XSRETURN(self->nIdx);
int
qi_userJobLimit(self)
LSF_Batch_queueInfo *self
CODE:
RETVAL = self->userJobLimit;
OUTPUT:
RETVAL
int
qi_procJobLimit(self)
LSF_Batch_queueInfo *self
CODE:
RETVAL = self->procJobLimit;
OUTPUT:
RETVAL
char *
qi_windows(self)
LSF_Batch_queueInfo *self
CODE:
RETVAL = self->windows;
OUTPUT:
RETVAL
void
qi_rLimits(self)
LSF_Batch_queueInfo *self
PREINIT:
int i;
PPCODE:
for( i = 0; i < LSF_RLIM_NLIMITS; i++){
XPUSHs(sv_2mortal(newSViv(self->rLimits[i])));
}
XSRETURN(LSF_RLIM_NLIMITS);
void
qi_defLimits(self)
LSF_Batch_queueInfo *self
PREINIT:
int i;
PPCODE:
for( i = 0; i < LSF_RLIM_NLIMITS; i++){
XPUSHs(sv_2mortal(newSViv(self->defLimits[i])));
}
XSRETURN(LSF_RLIM_NLIMITS);
char *
qi_hostSpec(self)
LSF_Batch_queueInfo *self
CODE:
RETVAL = self->hostSpec;
OUTPUT:
RETVAL
int
qi_qAttrib(self)
LSF_Batch_queueInfo *self
CODE:
RETVAL = self->qAttrib;
OUTPUT:
RETVAL
int
qi_qStatus(self)
LSF_Batch_queueInfo *self
CODE:
RETVAL = self->qStatus;
OUTPUT:
RETVAL
int
qi_maxJobs(self)
LSF_Batch_queueInfo *self
CODE:
RETVAL = self->maxJobs;
OUTPUT:
RETVAL
int
qi_numJobs(self)
LSF_Batch_queueInfo *self
CODE:
RETVAL = self->numJobs;
OUTPUT:
RETVAL
int
qi_numPEND(self)
LSF_Batch_queueInfo *self
CODE:
RETVAL = self->numPEND;
OUTPUT:
RETVAL
int
qi_numRUN(self)
LSF_Batch_queueInfo *self
CODE:
RETVAL = self->numRUN;
OUTPUT:
RETVAL
qi_rcvJobsFrom(self)
LSF_Batch_queueInfo *self
CODE:
RETVAL = self->rcvJobsFrom;
OUTPUT:
RETVAL
char *
qi_resumeCond(self)
LSF_Batch_queueInfo *self
CODE:
RETVAL = self->resumeCond;
OUTPUT:
RETVAL
char *
qi_stopCond(self)
LSF_Batch_queueInfo *self
CODE:
RETVAL = self->stopCond;
OUTPUT:
RETVAL
char *
qi_jobStarter(self)
LSF_Batch_queueInfo *self
CODE:
RETVAL = self->jobStarter;
OUTPUT:
RETVAL
char *
qi_suspendActCmd(self)
LSF_Batch_queueInfo *self
CODE:
RETVAL = self->suspendActCmd;
OUTPUT:
RETVAL
char *
qi_resumeActCmd(self)
LSF_Batch_queueInfo *self
CODE:
RETVAL = self->resumeActCmd;
OUTPUT:
RETVAL
char *
qi_terminateActCmd(self)
LSF_Batch_queueInfo *self
CODE:
RETVAL = self->terminateActCmd;
OUTPUT:
RETVAL
void
qi_sigMap(self)
LSF_Batch_queueInfo *self
PREINIT:
int i;
PPCODE:
for( i = 0; i < LSB_SIG_NUM; i++){
XPUSHs(sv_2mortal(newSViv(self->sigMap[i])));
}
XSRETURN(LSB_SIG_NUM);
char *
qi_preemption(self)
LSF_Batch_queueInfo *self
CODE:
RETVAL = self->preemption;
OUTPUT:
RETVAL
void
qi_shareAccts(self)
LSF_Batch_queueInfo *self
PREINIT:
SV *rv;
LSF_Batch_shareAcctInfo *p;
int i;
PPCODE:
for( i = 0, p = self->shareAccts; i < self->numOfSAccts; i++,p++ ){
rv = newRV_inc(&PL_sv_undef);
sv_setref_iv(rv, "LSF::Batch::shareAcctInfoPtr",(IV)p);
XPUSHs(sv_2mortal(rv));
}
XSRETURN(self->numOfSAccts);
int
qi_chunkJobSize(self)
LSF_Batch_queueInfo *self
CODE:
RETVAL = self->chunkJobSize;
OUTPUT:
RETVAL
#if LSF_VERSION >= 18
char *
qi_hostStr(self)
LSF_Batch_queueInfo *self
CODE:
RETVAL = self->hostStr;
OUTPUT:
RETVAL
int
qi_schedDelay(self)
LSF_Batch_queueInfo *self
CODE:
RETVAL = self->schedDelay;
OUTPUT:
RETVAL
int
qi_acceptIntvl(self)
LSF_Batch_queueInfo *self
CODE:
RETVAL = self->acceptIntvl;
OUTPUT:
RETVAL
int
qi_maxRschedTime(self)
LSF_Batch_queueInfo *self
CODE:
RETVAL = self->maxRschedTime;
OUTPUT:
RETVAL
int
qi_numOfSAccts(self)
LSF_Batch_queueInfo *self
CODE:
RETVAL = self->numOfSAccts;
OUTPUT:
RETVAL
char *
qi_chkpntDir(self)
LSF_Batch_queueInfo *self
CODE:
RETVAL = self->maxOfSsm;
OUTPUT:
RETVAL
int
qi_numOfAllocSlots(self)
LSF_Batch_queueInfo *self
CODE:
RETVAL = self->numOfAllocSlots;
OUTPUT:
RETVAL
char *
qi_servicePreemption(self)
LSF_Batch_queueInfo *self
CODE:
RETVAL = self->servicePreemption;
OUTPUT:
RETVAL
int
qi_provisionStatus(self)
LSF_Batch_queueInfo *self
CODE:
RETVAL = self->provisionStatus;
OUTPUT:
RETVAL
int
qi_minTimeSlice(self)
LSF_Batch_queueInfo *self
CODE:
RETVAL = self->minTimeSlice;
OUTPUT:
RETVAL
char *
qi_queueGroup(self)
LSF_Batch_queueInfo *self
CODE:
RETVAL = self->queueGroup;
OUTPUT:
RETVAL
int
qi_numApsFactors(self)
LSF_Batch_queueInfo *self
CODE:
RETVAL = self->numApsFactors;
OUTPUT:
RETVAL
void
qi_apsFactorInfoList(self)
LSF_Batch_queueInfo *self
PREINIT:
SV *rv;
LSF_Batch_apsFactorInfo *p;
int i;
PPCODE:
for( i = 0, p = self->apsFactorInfoList; i < self->numApsFactors; i++,p++ ){
rv = newRV_inc(&PL_sv_undef);
sv_setref_iv(rv, "LSF::Batch::apsFactorInfoPtr",(IV)p);
XPUSHs(sv_2mortal(rv));
}
XSRETURN(self->numApsFactors);
LSF_Batch_apsFactorMap *
qi_apsFactorMaps(self)
LSF_Batch_queueInfo *self
CODE:
RETVAL = self->apsFactorMaps;
OUTPUT:
RETVAL
LSF_Batch_apsLongNameMap *
qi_apsLongNames(self)
LSF_Batch_queueInfo *self
CODE:
RETVAL = self->apsLongNames;
OUTPUT:
RETVAL
#endif
MODULE = LSF::Batch PACKAGE = LSF::Batch::shareAcctInfoPtr PREFIX = sai_
char *
sai_shareAcctPath(self)
LSF_Batch_shareAcctInfo *self;
CODE:
RETVAL = self->shareAcctPath;
OUTPUT:
RETVAL
int
sai_shares(self)
LSF_Batch_shareAcctInfo *self;
CODE:
RETVAL = self->shares;
OUTPUT:
RETVAL
float
sai_priority(self)
LSF_Batch_shareAcctInfo *self;
CODE:
RETVAL = self->priority;
OUTPUT:
RETVAL
int
sai_numStartJobs(self)
LSF_Batch_shareAcctInfo *self;
CODE:
RETVAL = self->numStartJobs;
OUTPUT:
RETVAL
PREINIT:
LS_LONG_INT jobId;
CODE:
if(job == NULL){
jobId =0;
}
else{
jobId = LSB_JOBID(job->jobId,job->arrayIdx);
}
if(strlen(jobName)==0) jobName =NULL;
if(strlen(userName)==0) userName = NULL;
if(strlen(queueName)==0) queueName = NULL;
if(strlen(hostName)==0) hostName = NULL;
RETVAL = lsb_openjobinfo_a(jobId,jobName,userName,queueName,hostName,options);
if(RETVAL == NULL){
STATUS_NATIVE_SET(lsberrno);
SET_LSB_ERRMSG;
XSRETURN_UNDEF;
}
OUTPUT:
RETVAL
LSF_Batch_jobInfo *
lsb_readjobinfo(self)
void *self;
PREINIT:
int more;
CODE:
RETVAL = lsb_readjobinfo(&more);
if(RETVAL == NULL){
STATUS_NATIVE_SET(lsberrno);
SET_LSB_ERRMSG;
XSRETURN_UNDEF;
}
OUTPUT:
RETVAL
void
lsb_closejobinfo(self)
void *self;
CODE:
lsb_closejobinfo();
MODULE = LSF::Batch PACKAGE = LSF::Batch::jobInfoHeadPtr PREFIX = head_
int
head_numJobs(self)
LSF_Batch_jobInfoHead *self
CODE:
RETVAL = self ->numJobs;
OUTPUT:
RETVAL
void
head_jobIds(self)
LSF_Batch_jobInfoHead *self
PREINIT:
int i;
PPCODE:
for(i=0; i<self->numJobs; i++){
XPUSHs(sv_2mortal(newSViv(self-> jobIds [i])));
}
XSRETURN(self -> numJobs);
int
head_numHosts(self)
LSF_Batch_jobInfoHead *self
CODE:
RETVAL = self ->numHosts;
OUTPUT:
RETVAL
void
head_hostNames(self)
LSF_Batch_jobInfoHead *self
PREINIT:
int i;
PPCODE:
for(i=0; i<self->numHosts; i++){
XPUSHs(sv_2mortal(newSVpv(self->hostNames[i],0)));
}
XSRETURN(self -> numHosts);
int
head_numClusters(self)
LSF_Batch_jobInfoHead *self
CODE:
RETVAL = self ->numClusters;
OUTPUT:
RETVAL
void
head_clusterNames(self)
LSF_Batch_jobInfoHead *self
PREINIT:
int i;
PPCODE:
for(i=0; i< self->numClusters; i++){
XPUSHs(sv_2mortal(newSVpv(self->clusterNames[i],0)));
}
XSRETURN(self->numClusters);
void
head_numRemoteHosts(self)
LSF_Batch_jobInfoHead *self
PREINIT:
int i;
PPCODE:
for(i=0; i< (self->numClusters); i++){
XPUSHs(sv_2mortal(newSViv(self->numRemoteHosts[i])));
}
XSRETURN(self->numClusters);
void
head_remoteHosts(self)
LSF_Batch_jobInfoHead *self
PREINIT:
int *numReHosts;
int i;
int numClusters,p;
int count=0;
PPCODE:
numReHosts = self -> numRemoteHosts;
numClusters = self -> numClusters;
for(p=0; p<numClusters; p++){
for(i=0; i<numReHosts[p]; i++){
XPUSHs(sv_2mortal(newSVpv(self->remoteHosts[p][i],0)));
}
}
for(p=0; p<numClusters; p++){
count += self->numRemoteHosts[p];
}
XSRETURN(count);
MODULE = LSF::Batch PACKAGE = LSF::Batch::jobInfoPtr PREFIX = ji_
LSF_Batch_job *
ji_job(self)
LSF_Batch_jobInfo *self
CODE:
if((RETVAL=(LSF_Batch_job *)safemalloc(sizeof(LSF_Batch_job))) == NULL){
STATUS_NATIVE_SET(errno);
SET_LSB_ERRMSG_TO("unable to allocate memory for job object");
XSRETURN_UNDEF;
}
RETVAL->jobId = LSB_ARRAY_JOBID(self->jobId);
RETVAL->arrayIdx = LSB_ARRAY_IDX(self->jobId);
strncpy(RETVAL->queue, self->submit.queue, MAX_LSB_NAME_LEN);
RETVAL->badJobId = 0;
RETVAL->badJobName[0] = 0;
RETVAL->badReqIndx = 0;
OUTPUT:
RETVAL
int
ji_jobId(self)
LSF_Batch_jobInfo *self
CODE:
RETVAL = LSB_ARRAY_JOBID(self->jobId);
OUTPUT:
RETVAL
int
ji_arrayIdx(self)
LSF_Batch_jobInfo *self
CODE:
RETVAL = LSB_ARRAY_IDX(self->jobId);
OUTPUT:
RETVAL
int
ji_numReasons(self)
LSF_Batch_jobInfo *self
CODE:
RETVAL = self -> numReasons;
OUTPUT:
RETVAL
char *
ji_user(self)
LSF_Batch_jobInfo *self
CODE:
RETVAL = self->user;
OUTPUT:
RETVAL
int
ji_status(self)
LSF_Batch_jobInfo *self
CODE:
RETVAL = self->status;
OUTPUT:
RETVAL
int
ji_reasons(self)
LSF_Batch_jobInfo *self
CODE:
RETVAL = self->reasons;
OUTPUT:
RETVAL
int
ji_subreasons(self)
LSF_Batch_jobInfo *self
CODE:
RETVAL = self->subreasons;
OUTPUT:
RETVAL
void
ji_reasonTb(self)
LSF_Batch_jobInfo *self
PREINIT:
int i;
PPCODE:
for( i = 0; i < self->numReasons; i++)
XPUSHs(sv_2mortal(newSViv(self->reasonTb[i])));
XSRETURN(self->numReasons);
int
ji_jobPid(self)
LSF_Batch_jobInfo *self
CODE:
RETVAL = self->jobPid;
OUTPUT:
RETVAL
char *
ji_fromHost(self)
LSF_Batch_jobInfo *self
CODE:
RETVAL = self->fromHost;
OUTPUT:
RETVAL
int
ji_submitTime(self)
LSF_Batch_jobInfo *self
CODE:
RETVAL = self->submitTime;
OUTPUT:
RETVAL
int
ji_reserveTime(self)
LSF_Batch_jobInfo *self
CODE:
RETVAL = self->reserveTime;
OUTPUT:
RETVAL
int
ji_startTime(self)
LSF_Batch_jobInfo *self
CODE:
RETVAL = self->startTime;
OUTPUT:
RETVAL
int
ji_predictedStartTime(self)
LSF_Batch_jobInfo *self
CODE:
RETVAL = self->predictedStartTime;
OUTPUT:
RETVAL
int
ji_endTime(self)
LSF_Batch_jobInfo *self
CODE:
RETVAL = self->endTime;
OUTPUT:
RETVAL
ji_lastEvent(self)
LSF_Batch_jobInfo *self
CODE:
RETVAL = self->lastEvent;
OUTPUT:
RETVAL
int
ji_nextEvent(self)
LSF_Batch_jobInfo *self
CODE:
RETVAL = self->nextEvent;
OUTPUT:
RETVAL
int
ji_duration(self)
LSF_Batch_jobInfo *self
CODE:
RETVAL = self->duration;
OUTPUT:
RETVAL
float
ji_cpuTime(self)
LSF_Batch_jobInfo *self
CODE:
RETVAL = self->cpuTime;
OUTPUT:
RETVAL
int
ji_umask(self)
LSF_Batch_jobInfo *self
CODE:
RETVAL = self->umask;
OUTPUT:
RETVAL
char *
ji_subHomeDir(self)
LSF_Batch_jobInfo *self
CODE:
RETVAL = self->subHomeDir;
OUTPUT:
RETVAL
char *
ji_cwd(self)
LSF_Batch_jobInfo *self
CODE:
RETVAL = self->cwd;
OUTPUT:
RETVAL
void
ji_exHosts(self)
LSF_Batch_jobInfo *self
PREINIT:
int i;
PPCODE:
for( i = 0; i < self->numExHosts; i++)
XPUSHs(sv_2mortal(newSVpv(self->exHosts[i],0)));
XSRETURN(self->numExHosts);
float
ji_cpuFactor(self)
LSF_Batch_jobInfo *self
CODE:
RETVAL = self->cpuFactor;
OUTPUT:
RETVAL
void
ji_loadSched(self)
LSF_Batch_jobInfo *self
PREINIT:
int i;
PPCODE:
for( i = 0; i < self->nIdx; i++)
XPUSHs(sv_2mortal(newSVnv(self->loadSched[i])));
XSRETURN(self->nIdx);
void
ji_loadStop(self)
LSF_Batch_jobInfo *self
PREINIT:
int i;
PPCODE:
for( i = 0; i < self->nIdx; i++)
XPUSHs(sv_2mortal(newSVnv(self->loadStop[i])));
XSRETURN(self->nIdx);
LSF_Batch_submit *
ji_submit(self)
LSF_Batch_jobInfo *self
CODE:
RETVAL = &self->submit;
OUTPUT:
RETVAL
int
ji_exitStatus(self)
LSF_Batch_jobInfo *self
CODE:
RETVAL = self->exitStatus;
OUTPUT:
RETVAL
int
ji_execUid(self)
LSF_Batch_jobInfo *self
CODE:
RETVAL = self->execUid;
OUTPUT:
RETVAL
char *
ji_execHome(self)
LSF_Batch_jobInfo *self
CODE:
RETVAL = self->execHome;
OUTPUT:
RETVAL
char *
ji_execCwd(self)
LSF_Batch_jobInfo *self
CODE:
RETVAL = self->execCwd;
OUTPUT:
RETVAL
char *
ji_execUsername(self)
LSF_Batch_jobInfo *self
CODE:
RETVAL = self->execUsername;
OUTPUT:
RETVAL
int
ji_jRusageUpdateTime(self)
LSF_Batch_jobInfo *self
CODE:
RETVAL = self->jRusageUpdateTime;
OUTPUT:
RETVAL
LSF_Batch_jRusage *
ji_runRusage(self)
LSF_Batch_jobInfo *self
CODE:
RETVAL = &self->runRusage;
OUTPUT:
RETVAL
int
ji_jType(self)
LSF_Batch_jobInfo *self
CODE:
RETVAL = self->jType;
OUTPUT:
RETVAL
char *
ji_parentGroup(self)
LSF_Batch_jobInfo *self
CODE:
RETVAL = self->parentGroup;
OUTPUT:
RETVAL
char *
ji_jName(self)
LSF_Batch_jobInfo *self
CODE:
RETVAL = self->jName;
OUTPUT:
RETVAL
void
ji_counter(self)
LSF_Batch_jobInfo *self
PREINIT:
int i;
PPCODE:
for( i = 0; i < NUM_JGRP_COUNTERS; i++)
XPUSHs(sv_2mortal(newSVnv(self->counter[i])));
XSRETURN(NUM_JGRP_COUNTERS);
int
ji_jobPriority(self)
LSF_Batch_jobInfo *self
CODE:
RETVAL = self->jobPriority;
OUTPUT:
RETVAL
int
ji_numExternalMsg(self)
LSF_Batch_jobInfo *self
CODE:
RETVAL = self->numExternalMsg;
OUTPUT:
RETVAL
void
ji_externalMsg(self)
LSF_Batch_jobInfo *self
PREINIT:
SV *rv;
LSF_Batch_jobExternalMsgReply **p;
int i;
PPCODE:
for( i = 0, p = self->externalMsg; i < self->numExternalMsg; i++,p++ ){
rv = newRV_inc(&PL_sv_undef);
sv_setref_iv(rv, "LSF::Batch::jobExternalMsgReplyPtr",(IV)p);
XPUSHs(sv_2mortal(rv));
}
XSRETURN(self->numExternalMsg);
#if LSF_VERSION >= 18
int
ji_port(self)
LSF_Batch_jobInfo *self
CODE:
RETVAL = self->port;
OUTPUT:
RETVAL
int
ji_clusterId(self)
LSF_Batch_jobInfo *self
CODE:
RETVAL = self->clusterId;
OUTPUT:
RETVAL
char *
ji_detailReason(self)
LSF_Batch_jobInfo *self
CODE:
RETVAL = self->detailReason;
OUTPUT:
RETVAL
float
ji_idleFactor(self)
LSF_Batch_jobInfo *self
CODE:
RETVAL = self->idleFactor;
OUTPUT:
RETVAL
int
ji_exceptMask(self)
LSF_Batch_jobInfo *self
CODE:
RETVAL = self->exceptMask;
OUTPUT:
RETVAL
char *
ji_additionalInfo(self)
LSF_Batch_jobInfo *self
CODE:
RETVAL = self->additionalInfo;
OUTPUT:
RETVAL
int
ji_exitInfo(self)
LSF_Batch_jobInfo *self
CODE:
RETVAL = self->exitInfo;
OUTPUT:
RETVAL
int
ji_warningTimePeriod(self)
LSF_Batch_jobInfo *self
CODE:
RETVAL = self->warningTimePeriod;
OUTPUT:
RETVAL
char *
ji_warningAction(self)
LSF_Batch_jobInfo *self
CODE:
RETVAL = self->warningAction;
OUTPUT:
RETVAL
char *
ji_chargedSAAP(self)
LSF_Batch_jobInfo *self
CODE:
RETVAL = self->chargedSAAP;
OUTPUT:
RETVAL
char *
ji_execRusage(self)
LSF_Batch_jobInfo *self
CODE:
RETVAL = self->execRusage;
OUTPUT:
RETVAL
time_t
ji_rsvInActive(self)
LSF_Batch_jobInfo *self
CODE:
RETVAL = self->rsvInActive;
OUTPUT:
RETVAL
int
ji_numLicense(self)
LSF_Batch_jobInfo *self
CODE:
RETVAL = self->numLicense;
OUTPUT:
RETVAL
void
ji_licenseNames(self)
LSF_Batch_jobInfo *self
PREINIT:
int i;
PPCODE:
for( i = 0; i < self->numLicense; i++ ){
XPUSHs(sv_2mortal(newSVpv(self->licenseNames[i],0)));
}
XSRETURN(self->numLicense);
float
ji_aps(self)
LSF_Batch_jobInfo *self
CODE:
RETVAL = self->aps;
OUTPUT:
RETVAL
float
ji_adminAps(self)
LSF_Batch_jobInfo *self
CODE:
RETVAL = self->adminAps;
OUTPUT:
RETVAL
float
ji_adminFactorVal(self)
LSF_Batch_jobInfo *self
CODE:
RETVAL = self->adminFactorVal;
OUTPUT:
RETVAL
#endif
MODULE = LSF::Batch PACKAGE = LSF::Batch::submitPtr PREFIX = sub_
int
sub_options(self)
LSF_Batch_submit *self
CODE:
RETVAL = self->options;
OUTPUT:
RETVAL
int
sub_options2(self)
LSF_Batch_submit *self
CODE:
RETVAL = self->options2;
OUTPUT:
RETVAL
char *
sub_jobName(self)
LSF_Batch_submit *self
CODE:
RETVAL = self->jobName;
OUTPUT:
RETVAL
char *
sub_queue(self)
LSF_Batch_submit *self
CODE:
RETVAL = self->queue;
OUTPUT:
RETVAL
void
sub_askedHosts(self)
LSF_Batch_submit *self
PREINIT:
int i;
PPCODE:
for( i = 0; i < self->numAskedHosts; i++)
XPUSHs(sv_2mortal(newSVpv(self->askedHosts[i],0)));
XSRETURN(self->numAskedHosts);
char *
sub_resReq(self)
LSF_Batch_submit *self
CODE:
RETVAL = self->resReq;
OUTPUT:
RETVAL
void
sub_rLimits(self)
LSF_Batch_submit *self
PREINIT:
int i;
PPCODE:
for( i = 0; i < LSF_RLIM_NLIMITS; i++)
XPUSHs(sv_2mortal(newSVnv(self->rLimits[i])));
XSRETURN(LSF_RLIM_NLIMITS);
char *
sub_hostSpec(self)
LSF_Batch_submit *self
CODE:
RETVAL = self->hostSpec;
OUTPUT:
RETVAL
int
sub_numProcessors(self)
LSF_Batch_submit *self
CODE:
RETVAL = self->numProcessors;
OUTPUT:
RETVAL
char *
sub_dependCond(self)
LSF_Batch_submit *self
CODE:
RETVAL = self->dependCond;
OUTPUT:
RETVAL
int
sub_beginTime(self)
LSF_Batch_submit *self
CODE:
RETVAL = self->beginTime;
OUTPUT:
RETVAL
int
sub_termTime(self)
LSF_Batch_submit *self
CODE:
RETVAL = self->termTime;
OUTPUT:
RETVAL
int
sub_sigValue(self)
LSF_Batch_submit *self
CODE:
RETVAL = self->sigValue;
OUTPUT:
RETVAL
char *
sub_inFile(self)
LSF_Batch_submit *self
CODE:
RETVAL = self->inFile;
OUTPUT:
RETVAL
char *
sub_outFile(self)
LSF_Batch_submit *self
CODE:
RETVAL = self->outFile;
OUTPUT:
RETVAL
char *
sub_errFile(self)
LSF_Batch_submit *self
CODE:
RETVAL = self->errFile;
OUTPUT:
RETVAL
char *
sub_command(self)
LSF_Batch_submit *self
CODE:
RETVAL = self->command;
OUTPUT:
RETVAL
int
sub_chkpntPeriod(self)
LSF_Batch_submit *self
CODE:
RETVAL = self->chkpntPeriod;
OUTPUT:
RETVAL
char *
sub_chkpntDir(self)
LSF_Batch_submit *self
CODE:
RETVAL = self->chkpntDir;
OUTPUT:
RETVAL
void
sub_xf(self)
LSF_Batch_submit *self
PREINIT:
int i;
SV *rv;
PPCODE:
for( i = 0; i < self->nxf; i++){
rv = newRV_inc(&PL_sv_undef);
sv_setref_iv(rv, "LSF::Batch::xFilePtr",(IV)(self->xf + i));
XPUSHs(sv_2mortal(rv));
}
XSRETURN(self->nxf);
char *
sub_preExecCmd(self)
LSF_Batch_submit *self
CODE:
RETVAL = self->preExecCmd;
OUTPUT:
RETVAL
char *
sub_mailUser(self)
LSF_Batch_submit *self
CODE:
RETVAL = self->mailUser;
OUTPUT:
RETVAL
int
sub_delOptions(self)
LSF_Batch_submit *self
CODE:
RETVAL = self->delOptions;
OUTPUT:
RETVAL
char *
sub_projectName(self)
LSF_Batch_submit *self
CODE:
RETVAL = self->projectName;
OUTPUT:
RETVAL
int
sub_maxNumProcessors(self)
LSF_Batch_submit *self
CODE:
RETVAL = self->maxNumProcessors;
OUTPUT:
RETVAL
char *
sub_loginShell(self)
LSF_Batch_submit *self
CODE:
RETVAL = self->loginShell;
OUTPUT:
RETVAL
char *
sub_userGroup(self)
LSF_Batch_submit *self
CODE:
RETVAL = self->userGroup;
OUTPUT:
RETVAL
char *
sub_exceptList(self)
LSF_Batch_submit *self
CODE:
RETVAL = self->exceptList;
OUTPUT:
RETVAL
MODULE = LSF::Batch PACKAGE = LSF::Batch::jobPtr PREFIX = job_
void
job_new(type, jobId, arrayIdx)
char *type
int jobId
int arrayIdx
PREINIT:
LSF_Batch_job *j;
SV *rv;
PPCODE:
j = (LSF_Batch_job *)safemalloc(sizeof(LSF_Batch_job));
if( j == NULL ){
XSRETURN_UNDEF;
}
j->jobId = jobId;
j->arrayIdx = arrayIdx;
rv = newRV_inc(&PL_sv_undef);
sv_setref_iv(rv, type,(IV)j);
XPUSHs(sv_2mortal(rv));
XSRETURN(1);
int
do_modify(self, sub)
LSF_Batch_job *self
HV* sub;
PREINIT:
SV *rv;
struct submit *s;
struct submitReply reply;
LSF_Batch_job *j;
int error;
CODE:
s = (struct submit *)safemalloc(sizeof(struct submit));
initialize_submit(s);
if(format_submit(s, sub) < 0 ){
RETVAL = 0;
}
else{
error = lsb_modify(s, &reply, LSB_JOBID(self->jobId,self->arrayIdx));
if(error != -1){
strncpy(self->queue, reply.queue, MAX_LSB_NAME_LEN);
RETVAL = 1;
}
else{
self->badJobId = reply.badJobId;
self->badReqIndx = reply.badReqIndx;
strncpy(self->badJobName, reply.badJobName, MAX_LSB_NAME_LEN);
STATUS_NATIVE_SET(lsberrno);
SET_LSB_ERRMSG;
RETVAL = 0;
}
}
free_submit(s);
OUTPUT:
RETVAL
void
do_readjobmsg(self, r)
LSF_Batch_job *self;
HV *r;
PREINIT:
SV *rv;
int port;
struct jobExternalMsgReply *reply;
struct jobExternalMsgReq *req;
char * fileName = NULL;
PPCODE:
req = (struct jobExternalMsgReq *)safemalloc(sizeof(struct jobExternalMsgReq));
bzero(req, sizeof(struct jobExternalMsgReq));
reply = (struct jobExternalMsgReply *)safemalloc(sizeof(struct jobExternalMsgReply));
bzero(reply, sizeof(struct jobExternalMsgReply));
if (format_rjmreq(req, r, &fileName) < 0) {
free_rjmreq(req);
safefree(reply);
XSRETURN_EMPTY;
}
req->jobId = self->jobId;
port = lsb_readjobmsg(req, reply);
free_rjmreq(req);
if (port > 0 && fileName != NULL && reply->dataSize > 0) {
if (readfile(port, fileName, reply->dataSize) < 0) {
STATUS_NATIVE_SET(lsberrno);
SET_LSB_ERRMSG;
}
}
if(port < 0) {
STATUS_NATIVE_SET(lsberrno);
SET_LSB_ERRMSG;
XSRETURN_EMPTY;
} else {
XPUSHs(sv_2mortal(newSViv(port)));
rv = newRV_inc(&PL_sv_undef);
sv_setref_iv(rv, "LSF::Batch::jobExternalMsgReplyPtr",(IV)reply);
XPUSHs(sv_2mortal(rv));
}
XSRETURN(2);
int
do_postjobmsg(self, msgReq)
LSF_Batch_job *self
HV* msgReq
PREINIT:
struct jobExternalMsgReq *s;
char *fileName = NULL;
LS_LONG_INT jobId;
int err;
CODE:
s = (struct jobExternalMsgReq *)safemalloc(sizeof(struct jobExternalMsgReq));
initialize_jobExternalMsgReq(s);
s->jobId = self -> jobId;
if(format_jobExternalMsgReq(s,msgReq,&fileName) < 0 ){
RETVAL = 0;
} else {
err = lsb_postjobmsg(s,fileName);
if(err == -1){
STATUS_NATIVE_SET(lsberrno);
SET_LSF_ERRMSG;
RETVAL = 0;
}else {
RETVAL = 1;
}
}
safefree(s);
OUTPUT:
char *
lsb_pendreason(self,numReason,rsTb,jInfoH,loadIndex,clusterId)
void *self
AV *rsTb
LSF_Batch_jobInfoHead *jInfoH
char **loadIndex
int clusterId
int numReason
PREINIT:
char **h;
int count =0;
struct loadIndexLog *s;
int *cc;
I32 len;
int *temp = NULL;
int i;
SV *element;
CODE:
len = av_len(rsTb);
if(len < 0){
STATUS_NATIVE_SET(errno);
SET_LSB_ERRMSG_TO("Reason table is empty.");
XSRETURN_UNDEF;
}
temp = (int *)safemalloc((len+1) * sizeof(int));
if(temp == NULL){
STATUS_NATIVE_SET(errno);
SET_LSB_ERRMSG_TO("Unable to allocate memory for reason Table.");
XSRETURN_UNDEF;
}
for(i=0; i<=len; i++){
element = av_shift(rsTb);
if(!SvIOK(element)){
break;
}
else{
temp[i] = SvIV(element);
}
}
for( h = loadIndex; loadIndex && *h; h++ ) count++;
s = (struct loadIndexLog *)safemalloc (sizeof (struct loadIndexLog));
s->nIdx = count;
s->name = loadIndex;
RETVAL = lsb_pendreason(numReason, temp, jInfoH, s, clusterId);
safefree(temp);
safefree(s);
OUTPUT:
RETVAL
void
lsb_sharedresourceinfo(self, resources, hostName, option)
void *self
char **resources
char *hostName
int option
PREINIT:
SV *rv;
char **r;
int i, count = 0, num;
LSF_Batch_sharedResourceInfo *p, *si;
PPCODE:
for( r = resources; resources && *r; r++ ) count++;
num = count;
if( count == 0 ) resources = NULL;
if(hostName && strlen(hostName)==0) hostName = NULL;
si = lsb_sharedresourceinfo(resources, &num, hostName, option);
if(si == NULL){
STATUS_NATIVE_SET(lsberrno);
SET_LSB_ERRMSG;
XSRETURN_EMPTY;
}
for( i = 0, p = si; i < num; i++,p++ ){
rv = newRV_inc(&PL_sv_undef);
sv_setref_iv(rv, "LSF::Batch::sharedResourceInfoPtr",(IV)p);
XPUSHs(sv_2mortal(rv));
}
XSRETURN(num);
MODULE = LSF::Batch PACKAGE = LSF::Batch::sharedResourceInfoPtr PREFIX = sri_
char *
sri_resourceName(self)
LSF_Batch_sharedResourceInfo *self;
CODE:
RETVAL = self->resourceName;
OUTPUT:
RETVAL
void
sri_instances(self)
LSF_Batch_sharedResourceInfo *self;
PREINIT:
int i;
SV *rv;
PPCODE:
for( i = 0; i < self->nInstances; i++){
rv = newRV_inc(&PL_sv_undef);
sv_setref_iv(rv,
"LSF::Batch::sharedResourceInstancePtr",
(IV)(self->instances + i));
XPUSHs(sv_2mortal(rv));
}
XSRETURN(self->nInstances);
MODULE = LSF::Batch PACKAGE=LSF::Batch::sharedResourceInstancePtr PREFIX = ins_
char *
ins_totalValue(self)
LSF_Batch_sharedResourceInstance *self;
CODE:
RETVAL = self->totalValue;
OUTPUT:
RETVAL
char *
ins_rsvValue(self)
LSF_Batch_sharedResourceInstance *self;
CODE:
RETVAL = self->rsvValue;
OUTPUT:
RETVAL
void
ins_hostList(self)
LSF_Batch_sharedResourceInstance *self;
PREINIT:
int i;
SV *rv;
PPCODE:
for( i = 0; i < self->nHosts; i++){
XPUSHs(sv_2mortal(newSVpv(self->hostList[i],0)));
}
XSRETURN(self->nHosts);
MODULE = LSF::Batch PACKAGE = LSF::Batch PREFIX = lsb_
void
lsb_hostpartinfo(self, hostParts)
void *self
char **hostParts
PREINIT:
SV *rv;
int num, i, count;
char **h;
LSF_Batch_hostPartInfo *p, *pi;
PPCODE:
for( h = hostParts; hostParts && *h; h++ ) count++;
num = count;
if( count == 0 ) hostParts = NULL;
pi = lsb_hostpartinfo(hostParts, &num);
if(pi == NULL){
STATUS_NATIVE_SET(lsberrno);
SET_LSB_ERRMSG;
XSRETURN_EMPTY;
}
for( i = 0, p = pi; i < num; i++,p++ ){
rv = newRV_inc(&PL_sv_undef);
sv_setref_iv(rv, "LSF::Batch::hostPartInfoPtr",(IV)p);
XPUSHs(sv_2mortal(rv));
}
XSRETURN(num);
MODULE = LSF::Batch PACKAGE = LSF::Batch::hostPartInfoPtr PREFIX = hpi_
char *
hpi_hostPart(self)
LSF_Batch_hostPartInfo *self
CODE:
RETVAL = self->hostPart;
OUTPUT:
RETVAL
char *
hpi_hostList(self)
LSF_Batch_hostPartInfo *self
CODE:
RETVAL = self->hostList;
OUTPUT:
RETVAL
void
hpi_users(self)
LSF_Batch_hostPartInfo *self;
PREINIT:
int i;
SV *rv;
PPCODE:
for( i = 0; i < self->numUsers; i++){
rv = newRV_inc(&PL_sv_undef);
sv_setref_iv(rv,
"LSF::Batch::hostPartUserInfoPtr",
(IV)(self->users + i));
XPUSHs(sv_2mortal(rv));
}
XSRETURN(self->numUsers);
MODULE = LSF::Batch PACKAGE = LSF::Batch::hostPartUserInfoPtr PREFIX = hpu_
char *
hpu_user(self)
LSF_Batch_hostPartUserInfo *self
CODE:
RETVAL = self->user;
OUTPUT:
RETVAL
int
hpu_shares(self)
LSF_Batch_hostPartUserInfo *self
CODE:
RETVAL = self->shares;
OUTPUT:
RETVAL
float
hpu_priority(self)
LSF_Batch_hostPartUserInfo *self
CODE:
RETVAL = self->priority;
OUTPUT:
RETVAL
int
hpu_numStartJobs(self)
LSF_Batch_hostPartUserInfo *self
CODE:
RETVAL = self->numStartJobs;
OUTPUT:
RETVAL
int
hpu_numReserveJobs(self)
LSF_Batch_hostPartUserInfo *self
CODE:
RETVAL = self->numReserveJobs;
OUTPUT:
RETVAL
float
hpu_histCpuTime(self)
LSF_Batch_hostPartUserInfo *self
CODE:
RETVAL = self->histCpuTime;
OUTPUT:
RETVAL
#endif
MODULE = LSF::Batch PACKAGE = LSF::Batch PREFIX = lsb_
LSF_Batch_eventRec *
lsb_geteventrecord(self, log_fp, lineNum)
void *self
FILE* log_fp
SV* lineNum
PREINIT:
int ln;
CODE:
if( SvIOK(lineNum) ){
ln = (int)SvIV(lineNum);
}
else{
croak("geteventrecord: lineNum is not an integer");
}
if((RETVAL = lsb_geteventrecord(log_fp, &ln)) == NULL){
STATUS_NATIVE_SET(lsberrno);
SET_LSB_ERRMSG;
XSRETURN_UNDEF;
}
sv_setiv(lineNum, ln);
OUTPUT:
RETVAL
MODULE = LSF::Batch PACKAGE = LSF::Batch::eventRecPtr PREFIX = er_
char *
er_version(self)
LSF_Batch_eventRec *self
CODE:
RETVAL = self->version;
OUTPUT:
RETVAL
int
er_type(self)
LSF_Batch_eventRec *self
CODE:
RETVAL = self->type;
OUTPUT:
RETVAL
int
er_eventTime(self)
LSF_Batch_eventRec *self
CODE:
RETVAL = self->eventTime;
OUTPUT:
RETVAL
void
er_eventLog(self)
LSF_Batch_eventRec *self
PREINIT:
char *label;
SV *rv;
PPCODE:
switch(self->type){
case EVENT_LOG_SWITCH:
label = "LSF::Batch::logSwitchLogPtr";
rv = newRV_inc(&PL_sv_undef);
sv_setref_iv(rv, label, (IV)&self->eventLog.logSwitchLog);
break;
/*
case EVENT_JGRP_NEW:
label = "LSF::Batch::jgrpNewLogPtr";
rv = newRV_inc(&PL_sv_undef);
sv_setref_iv(rv, label, (IV)&self->eventLog.jgrpNewLog);
break;
case EVENT_JGRP_CNTL:
label = "LSF::Batch::jgrpCtrlLogPtr";
rv = newRV_inc(&PL_sv_undef);
sv_setref_iv(rv, label, (IV)&self->eventLog.jgrpCtrlLog);
break;
*/
case EVENT_JGRP_STATUS:
label = "LSF::Batch::jgrpStatusLogPtr";
rv = newRV_inc(&PL_sv_undef);
sv_setref_iv(rv, label, (IV)&self->eventLog.jgrpStatusLog);
break;
case EVENT_JOB_NEW:
label = "LSF::Batch::jobNewLogPtr";
rv = newRV_inc(&PL_sv_undef);
sv_setref_iv(rv, label, (IV)&self->eventLog.jobNewLog);
break;
case EVENT_JOB_MODIFY:
label = "LSF::Batch::jobModLogPtr";
rv = newRV_inc(&PL_sv_undef);
sv_setref_iv(rv, label, (IV)&self->eventLog.jobModLog);
break;
case EVENT_JOB_START:
label = "LSF::Batch::jobStartLogPtr";
rv = newRV_inc(&PL_sv_undef);
sv_setref_iv(rv, label, (IV)&self->eventLog.jobStartLog);
break;
case EVENT_JOB_START_ACCEPT:
label = "LSF::Batch::jobStartAcceptLogPtr";
rv = newRV_inc(&PL_sv_undef);
sv_setref_iv(rv, label, (IV)&self->eventLog.jobStartAcceptLog);
break;
case EVENT_JOB_EXECUTE:
label = "LSF::Batch::jobExecuteLogPtr";
rv = newRV_inc(&PL_sv_undef);
sv_setref_iv(rv, label, (IV)&self->eventLog.jobExecuteLog);
break;
case EVENT_JOB_STATUS:
label = "LSF::Batch::jobStatusLogPtr";
rv = newRV_inc(&PL_sv_undef);
sv_setref_iv(rv, label, (IV)&self->eventLog.jobStatusLog);
break;
case EVENT_SBD_JOB_STATUS:
label = "LSF::Batch::sbdJobStatusLogPtr";
rv = newRV_inc(&PL_sv_undef);
sv_setref_iv(rv, label, (IV)&self->eventLog.sbdJobStatusLog);
break;
case EVENT_SBD_UNREPORTED_STATUS:
label = "LSF::Batch::sbdUnreportedStatusLogPtr";
jnl2_idx(self)
LSF_Batch_jobNewLog *self
CODE:
RETVAL = self->idx;
OUTPUT:
RETVAL
int
jnl2_nxf(self)
LSF_Batch_jobNewLog *self
CODE:
RETVAL = self->nxf;
OUTPUT:
RETVAL
time_t
jnl2_submitTime(self)
LSF_Batch_jobNewLog *self
CODE:
RETVAL = self->submitTime;
OUTPUT:
RETVAL
char *
jnl2_chkpntDir(self)
LSF_Batch_jobNewLog *self
CODE:
RETVAL = self->chkpntDir;
OUTPUT:
RETVAL
int
jnl2_userPriority(self)
LSF_Batch_jobNewLog *self
CODE:
RETVAL = self->userPriority;
OUTPUT:
RETVAL
time_t
jnl2_beginTime(self)
LSF_Batch_jobNewLog *self
CODE:
RETVAL = self->beginTime;
OUTPUT:
RETVAL
int
jnl2_userId(self)
LSF_Batch_jobNewLog *self
CODE:
RETVAL = self->userId;
OUTPUT:
RETVAL
void
jnl2_askedHosts(self)
LSF_Batch_jobNewLog *self
PREINIT:
int i;
PPCODE:
for( i = 0; i < self->numAskedHosts; i++)
XPUSHs(sv_2mortal(newSVpv(self->askedHosts[i],0)));
XSRETURN(self->numAskedHosts);
char *
jnl2_userGroup(self)
LSF_Batch_jobNewLog *self
CODE:
RETVAL = self->userGroup;
OUTPUT:
RETVAL
void
jnl2_rLimits(self)
LSF_Batch_jobNewLog *self
PREINIT:
int i;
PPCODE:
for( i = 0; i < LSF_RLIM_NLIMITS; i++)
XPUSHs(sv_2mortal(newSViv(self->rLimits[i])));
XSRETURN(LSF_RLIM_NLIMITS);
time_t
jnl2_termTime(self)
LSF_Batch_jobNewLog *self
CODE:
RETVAL = self->termTime;
OUTPUT:
RETVAL
char *
jnl2_inFileSpool(self)
LSF_Batch_jobNewLog *self
CODE:
RETVAL = self->inFileSpool;
OUTPUT:
RETVAL
char *
jnl2_dependCond(self)
LSF_Batch_jobNewLog *self
CODE:
RETVAL = self->dependCond;
OUTPUT:
RETVAL
char *
jnl2_jobName(self)
LSF_Batch_jobNewLog *self
CODE:
RETVAL = self->jobName;
OUTPUT:
RETVAL
int
jnl2_chkpntPeriod(self)
LSF_Batch_jobNewLog *self
CODE:
RETVAL = self->chkpntPeriod;
OUTPUT:
RETVAL
float
jnl2_hostFactor(self)
LSF_Batch_jobNewLog *self
CODE:
RETVAL = self->hostFactor;
OUTPUT:
RETVAL
char *
jnl2_command(self)
LSF_Batch_jobNewLog *self
CODE:
RETVAL = self->command;
OUTPUT:
RETVAL
jml_options2(self)
LSF_Batch_jobModLog *self
CODE:
RETVAL = self->options2;
OUTPUT:
RETVAL
int
jml_nxf(self)
LSF_Batch_jobModLog *self
CODE:
RETVAL = self->nxf;
OUTPUT:
RETVAL
char *
jml_chkpntDir(self)
LSF_Batch_jobModLog *self
CODE:
RETVAL = self->chkpntDir;
OUTPUT:
RETVAL
int
jml_submitTime(self)
LSF_Batch_jobModLog *self
CODE:
RETVAL = self->submitTime;
OUTPUT:
RETVAL
int
jml_userPriority(self)
LSF_Batch_jobModLog *self
CODE:
RETVAL = self->userPriority;
OUTPUT:
RETVAL
int
jml_beginTime(self)
LSF_Batch_jobModLog *self
CODE:
RETVAL = self->beginTime;
OUTPUT:
RETVAL
int
jml_userId(self)
LSF_Batch_jobModLog *self
CODE:
RETVAL = self->userId;
OUTPUT:
RETVAL
char *
jml_askedHosts(self)
LSF_Batch_jobModLog *self
PREINIT:
int i;
PPCODE:
for( i = 0; i < self->numAskedHosts; i++)
XPUSHs(sv_2mortal(newSVpv(self->askedHosts[i],0)));
XSRETURN(self->numAskedHosts);
char *
jml_userGroup(self)
LSF_Batch_jobModLog *self
CODE:
RETVAL = self->userGroup;
OUTPUT:
RETVAL
int
jml_termTime(self)
LSF_Batch_jobModLog *self
CODE:
RETVAL = self->termTime;
OUTPUT:
RETVAL
void
jml_rLimits(self)
LSF_Batch_jobModLog *self
PREINIT:
int i;
PPCODE:
for( i = 0; i < LSF_RLIM_NLIMITS; i++)
XPUSHs(sv_2mortal(newSViv(self->rLimits[i])));
XSRETURN(LSF_RLIM_NLIMITS);
char *
jml_dependCond(self)
LSF_Batch_jobModLog *self
CODE:
RETVAL = self->dependCond;
OUTPUT:
RETVAL
char *
jml_inFileSpool(self)
LSF_Batch_jobModLog *self
CODE:
RETVAL = self->inFileSpool;
OUTPUT:
RETVAL
char *
jml_jobName(self)
LSF_Batch_jobModLog *self
CODE:
RETVAL = self->jobName;
OUTPUT:
RETVAL
int
jml_chkpntPeriod(self)
LSF_Batch_jobModLog *self
CODE:
RETVAL = self->chkpntPeriod;
OUTPUT:
RETVAL
char *
jml_command(self)
LSF_Batch_jobModLog *self
CODE:
RETVAL = self->command;
OUTPUT:
RETVAL
char *
jml_inFile(self)
LSF_Batch_jobModLog *self
CODE:
RETVAL = self->inFile;
OUTPUT:
RETVAL
char *
jml_commandSpool(self)
LSF_Batch_jobModLog *self
CODE:
RETVAL = self->commandSpool;
OUTPUT:
RETVAL
jsl2_jobPGid(self)
LSF_Batch_jobStartLog *self
CODE:
RETVAL = self->jobPGid;
OUTPUT:
RETVAL
int
jsl2_jobId(self)
LSF_Batch_jobStartLog *self
CODE:
RETVAL = self->jobId;
OUTPUT:
RETVAL
char *
jsl2_userGroup(self)
LSF_Batch_jobStartLog *self
CODE:
RETVAL = self->userGroup;
OUTPUT:
RETVAL
int
jsl2_numExHosts(self)
LSF_Batch_jobStartLog *self
CODE:
RETVAL = self->numExHosts;
OUTPUT:
RETVAL
float
jsl2_hostFactor(self)
LSF_Batch_jobStartLog *self
CODE:
RETVAL = self->hostFactor;
OUTPUT:
RETVAL
int
jsl2_idx(self)
LSF_Batch_jobStartLog *self
CODE:
RETVAL = self->idx;
OUTPUT:
RETVAL
char *
jsl2_queuePreCmd(self)
LSF_Batch_jobStartLog *self
CODE:
RETVAL = self->queuePreCmd;
OUTPUT:
RETVAL
void
jsl2_execHosts(self)
LSF_Batch_jobStartLog *self
PREINIT:
int i;
PPCODE:
for( i = 0; i < self->numExHosts; i++)
XPUSHs(sv_2mortal(newSVpv(self->execHosts[i],0)));
XSRETURN(self->numExHosts);
int
jsl2_jobPid(self)
LSF_Batch_jobStartLog *self
CODE:
RETVAL = self->jobPid;
OUTPUT:
RETVAL
MODULE = LSF::Batch PACKAGE = LSF::Batch::jobStartAcceptLogPtr PREFIX = jsal_
int
jsal_jobPGid(self)
LSF_Batch_jobStartAcceptLog *self
CODE:
RETVAL = self->jobPGid;
OUTPUT:
RETVAL
int
jsal_jobId(self)
LSF_Batch_jobStartAcceptLog *self
CODE:
RETVAL = self->jobId;
OUTPUT:
RETVAL
int
jsal_idx(self)
LSF_Batch_jobStartAcceptLog *self
CODE:
RETVAL = self->idx;
OUTPUT:
RETVAL
int
jsal_jobPid(self)
LSF_Batch_jobStartAcceptLog *self
CODE:
RETVAL = self->jobPid;
OUTPUT:
RETVAL
MODULE = LSF::Batch PACKAGE = LSF::Batch::jobExecuteLogPtr PREFIX = jel_
char *
jel_execHome(self)
LSF_Batch_jobExecuteLog *self
CODE:
RETVAL = self->execHome;
OUTPUT:
RETVAL
int
jel_execUid(self)
RETVAL = self->flags;
OUTPUT:
RETVAL
time_t
sl_period(self)
LSF_Batch_sigactLog *self
CODE:
RETVAL = self->period;
OUTPUT:
RETVAL
int
sl_idx(self)
LSF_Batch_sigactLog *self
CODE:
RETVAL = self->idx;
OUTPUT:
RETVAL
int
sl_jobId(self)
LSF_Batch_sigactLog *self
CODE:
RETVAL = self->jobId;
OUTPUT:
RETVAL
int
sl_actStatus(self)
LSF_Batch_sigactLog *self
CODE:
RETVAL = self->actStatus;
OUTPUT:
RETVAL
int
sl_pid(self)
LSF_Batch_sigactLog *self
CODE:
RETVAL = self->pid;
OUTPUT:
RETVAL
MODULE = LSF::Batch PACKAGE = LSF::Batch::migLogPtr PREFIX = ml_
int
ml_userId(self)
LSF_Batch_migLog *self
CODE:
RETVAL = self->userId;
OUTPUT:
RETVAL
char *
ml_askedHosts(self)
LSF_Batch_migLog *self
PREINIT:
int i;
PPCODE:
for( i = 0; i < self->numAskedHosts; i++)
XPUSHs(sv_2mortal(newSVpv(self->askedHosts[i],0)));
XSRETURN(self->numAskedHosts);
int
ml_jobId(self)
LSF_Batch_migLog *self
CODE:
RETVAL = self->jobId;
OUTPUT:
RETVAL
int
ml_numAskedHosts(self)
LSF_Batch_migLog *self
CODE:
RETVAL = self->numAskedHosts;
OUTPUT:
RETVAL
int
ml_idx(self)
LSF_Batch_migLog *self
CODE:
RETVAL = self->idx;
OUTPUT:
RETVAL
MODULE = LSF::Batch PACKAGE = LSF::Batch::signalLogPtr PREFIX = sl2_
int
sl2_userId(self)
LSF_Batch_signalLog *self
CODE:
RETVAL = self->userId;
OUTPUT:
RETVAL
char *
sl2_signalSymbol(self)
LSF_Batch_signalLog *self
CODE:
RETVAL = self->signalSymbol;
OUTPUT:
RETVAL
int
sl2_jobId(self)
LSF_Batch_signalLog *self
CODE:
RETVAL = self->jobId;
OUTPUT:
RETVAL
int
sl2_runCount(self)
LSF_Batch_signalLog *self
CODE:
RETVAL = self->runCount;
jfl_maxRMem(self)
LSF_Batch_jobFinishLog *self
CODE:
RETVAL = self->maxRMem;
OUTPUT:
RETVAL
int
jfl_maxRSwap(self)
LSF_Batch_jobFinishLog *self
CODE:
RETVAL = self->maxRSwap;
OUTPUT:
RETVAL
char *
jfl_resReq(self)
LSF_Batch_jobFinishLog *self
CODE:
RETVAL = self->resReq;
OUTPUT:
RETVAL
char *
jfl_queue(self)
LSF_Batch_jobFinishLog *self
CODE:
RETVAL = self->queue;
OUTPUT:
RETVAL
char *
jfl_userName(self)
LSF_Batch_jobFinishLog *self
CODE:
RETVAL = self->userName;
OUTPUT:
RETVAL
int
jfl_jobId(self)
LSF_Batch_jobFinishLog *self
CODE:
RETVAL = self->jobId;
OUTPUT:
RETVAL
char *
jfl_loginShell(self)
LSF_Batch_jobFinishLog *self
CODE:
RETVAL = self->loginShell;
OUTPUT:
RETVAL
void
jfl_execHosts(self)
LSF_Batch_jobFinishLog *self
PREINIT:
int i;
PPCODE:
for( i = 0; i < self->numExHosts; i++)
XPUSHs(sv_2mortal(newSVpv(self->execHosts[i],0)));
XSRETURN(self->numExHosts);
float
jfl_cpuTime(self)
LSF_Batch_jobFinishLog *self
CODE:
RETVAL = self->cpuTime;
OUTPUT:
RETVAL
int
jfl_maxNumProcessors(self)
LSF_Batch_jobFinishLog *self
CODE:
RETVAL = self->maxNumProcessors;
OUTPUT:
RETVAL
LSF_Batch_lsfRusage *
jfl_lsfRusage(self)
LSF_Batch_jobFinishLog *self
CODE:
RETVAL = &self->lsfRusage;
OUTPUT:
RETVAL
char *
jfl_timeEvent(self)
LSF_Batch_jobFinishLog *self
CODE:
RETVAL = self->timeEvent;
OUTPUT:
RETVAL
char *
jfl_mailUser(self)
LSF_Batch_jobFinishLog *self
CODE:
RETVAL = self->mailUser;
OUTPUT:
RETVAL
int
jfl_idx(self)
LSF_Batch_jobFinishLog *self
CODE:
RETVAL = self->idx;
OUTPUT:
RETVAL
time_t
jfl_submitTime(self)
LSF_Batch_jobFinishLog *self
CODE:
RETVAL = self->submitTime;
OUTPUT:
RETVAL
time_t
jfl_beginTime(self)
LSF_Batch_jobFinishLog *self
CODE:
RETVAL = self->beginTime;
OUTPUT:
RETVAL
int
jfl_jStatus(self)
LSF_Batch_jobFinishLog *self
CODE:
RETVAL = self->jStatus;
OUTPUT:
RETVAL
int
jfl_userId(self)
LSF_Batch_jobFinishLog *self
CODE:
RETVAL = self->userId;
OUTPUT:
RETVAL
char *
jfl_askedHosts(self)
LSF_Batch_jobFinishLog *self
PREINIT:
int i;
PPCODE:
for( i = 0; i < self->numAskedHosts; i++)
XPUSHs(sv_2mortal(newSVpv(self->askedHosts[i],0)));
XSRETURN(self->numAskedHosts);
time_t
jfl_termTime(self)
LSF_Batch_jobFinishLog *self
CODE:
RETVAL = self->termTime;
OUTPUT:
RETVAL
char *
jfl_inFileSpool(self)
LSF_Batch_jobFinishLog *self
CODE:
RETVAL = self->inFileSpool;
OUTPUT:
RETVAL
char *
jfl_dependCond(self)
LSF_Batch_jobFinishLog *self
CODE:
RETVAL = self->dependCond;
OUTPUT:
RETVAL
char *
jfl_jobName(self)
LSF_Batch_jobFinishLog *self
CODE:
RETVAL = self->jobName;
OUTPUT:
RETVAL
float
jfl_hostFactor(self)
LSF_Batch_jobFinishLog *self
CODE:
RETVAL = self->hostFactor;
OUTPUT:
RETVAL
int
jfl_numExHosts(self)
LSF_Batch_jobFinishLog *self
CODE:
RETVAL = self->numExHosts;
OUTPUT:
RETVAL
char *
jfl_command(self)
LSF_Batch_jobFinishLog *self
CODE:
RETVAL = self->command;
OUTPUT:
RETVAL
char *
jfl_inFile(self)
LSF_Batch_jobFinishLog *self
CODE:
RETVAL = self->inFile;
OUTPUT:
RETVAL
char *
jfl_commandSpool(self)
LSF_Batch_jobFinishLog *self
CODE:
RETVAL = self->commandSpool;
OUTPUT:
RETVAL
MODULE = LSF::Batch PACKAGE = LSF::Batch::loadIndexLogPtr PREFIX = lil_
void
lil_name(self)
LSF_Batch_loadIndexLog *self
PREINIT:
int i;
PPCODE:
for( i = 0; i < self->nIdx; i++)
XPUSHs(sv_2mortal(newSVpv(self->name[i],0)));
XSRETURN(self->nIdx);
int
lil_nIdx(self)
LSF_Batch_loadIndexLog *self
CODE:
RETVAL = self->nIdx;
OUTPUT:
RETVAL
MODULE = LSF::Batch PACKAGE = LSF::Batch::calendarLogPtr PREFIX = cl2_
int
cl2_userId(self)
LSF_Batch_calendarLog *self
CODE:
RETVAL = self->userId;
OUTPUT:
RETVAL
char *
cl2_calExpr(self)
LSF_Batch_calendarLog *self
CODE:
RETVAL = self->calExpr;
OUTPUT:
RETVAL
char *
cl2_desc(self)
LSF_Batch_calendarLog *self
CODE:
RETVAL = self->desc;
OUTPUT:
RETVAL
int
cl2_options(self)
LSF_Batch_calendarLog *self
CODE:
RETVAL = self->options;
OUTPUT:
RETVAL
char *
cl2_name(self)
LSF_Batch_calendarLog *self
CODE:
RETVAL = self->name;
OUTPUT:
RETVAL
MODULE = LSF::Batch PACKAGE = LSF::Batch::jobForwardLogPtr PREFIX = jfl2_
void
jfl2_reserHosts(self)
LSF_Batch_jobForwardLog *self
PREINIT:
int i;
PPCODE:
for( i = 0; i < self->numReserHosts; i++)
XPUSHs(sv_2mortal(newSVpv(self->reserHosts[i],0)));
XSRETURN(self->numReserHosts);
int
jfl2_jobId(self)
LSF_Batch_jobForwardLog *self
CODE:
RETVAL = self->jobId;
OUTPUT:
RETVAL
char *
jfl2_cluster(self)
LSF_Batch_jobForwardLog *self
CODE:
RETVAL = self->cluster;
OUTPUT:
RETVAL
int
jfl2_numReserHosts(self)
LSF_Batch_jobForwardLog *self
CODE:
RETVAL = self->numReserHosts;
OUTPUT:
RETVAL
int
jfl2_idx(self)
LSF_Batch_jobForwardLog *self
CODE:
RETVAL = self->idx;
OUTPUT:
RETVAL
MODULE = LSF::Batch PACKAGE = LSF::Batch::jobAcceptLogPtr PREFIX = jal_
LSF_Batch_job *
jal_remoteJid(self)
LSF_Batch_jobAcceptLog *self
CODE:
RETVAL = (LSF_Batch_job *)safemalloc(sizeof(LSF_Batch_job));
RETVAL->jobId = LSB_ARRAY_JOBID(self->remoteJid);
RETVAL->arrayIdx = LSB_ARRAY_IDX(self->remoteJid);
OUTPUT:
RETVAL
int
jal_jobId(self)
LSF_Batch_jobAcceptLog *self
CODE:
RETVAL = self->jobId;
OUTPUT:
RETVAL
char *
jal_cluster(self)
LSF_Batch_jobAcceptLog *self
int
jfrl_userId(self)
LSF_Batch_jobForceRequestLog *self
CODE:
RETVAL = self->userId;
OUTPUT:
RETVAL
int
jfrl_jobId(self)
LSF_Batch_jobForceRequestLog *self
CODE:
RETVAL = self->jobId;
OUTPUT:
RETVAL
int
jfrl_numExecHosts(self)
LSF_Batch_jobForceRequestLog *self
CODE:
RETVAL = self->numExecHosts;
OUTPUT:
RETVAL
int
jfrl_options(self)
LSF_Batch_jobForceRequestLog *self
CODE:
RETVAL = self->options;
OUTPUT:
RETVAL
int
jfrl_idx(self)
LSF_Batch_jobForceRequestLog *self
CODE:
RETVAL = self->idx;
OUTPUT:
RETVAL
char**
jfrl_execHosts(self)
LSF_Batch_jobForceRequestLog *self
CODE:
RETVAL = self->execHosts;
OUTPUT:
RETVAL
MODULE = LSF::Batch PACKAGE = LSF::Batch::jobChunkLogPtr PREFIX = jcl3_
void
jcl3_membJobId(self)
LSF_Batch_jobChunkLog *self
PREINIT:
LS_LONG_INT id;
int i;
LSF_Batch_job *j;
SV *rv;
PPCODE:
for( i = 0; i < self->membSize; i++){
j = (LSF_Batch_job *)safemalloc(sizeof(LSF_Batch_job));
j->jobId = LSB_ARRAY_JOBID(id);
j->arrayIdx = LSB_ARRAY_IDX(id);
rv = newRV_inc(&PL_sv_undef);
sv_setref_iv(rv, "LSF::Batch::jobPtr", (IV)&j);
XPUSHs(sv_2mortal(rv));
}
XSRETURN(self->membSize);
long
jcl3_numExHosts(self)
LSF_Batch_jobChunkLog *self
CODE:
RETVAL = self->numExHosts;
OUTPUT:
RETVAL
long
jcl3_membSize(self)
LSF_Batch_jobChunkLog *self
CODE:
RETVAL = self->membSize;
OUTPUT:
RETVAL
void
jcl3_execHosts(self)
LSF_Batch_jobChunkLog *self
PREINIT:
int i;
PPCODE:
for( i = 0; i < self->numExHosts; i++)
XPUSHs(sv_2mortal(newSVpv(self->execHosts[i],0)));
XSRETURN(self->numExHosts);
MODULE = LSF::Batch PACKAGE = LSF::Batch::jobExternalMsgLogPtr PREFIX = jeml_
int
jeml_userId(self)
LSF_Batch_jobExternalMsgLog *self
CODE:
RETVAL = self->userId;
OUTPUT:
RETVAL
int
jeml_jobId(self)
LSF_Batch_jobExternalMsgLog *self
CODE:
RETVAL = self->jobId;
OUTPUT:
RETVAL
char *
jeml_fileName(self)
LSF_Batch_jobExternalMsgLog *self
CODE:
RETVAL = self->fileName;
OUTPUT:
RETVAL
int
jeml_dataStatus(self)
LSF_Batch_jobExternalMsgLog *self
CODE:
RETVAL = self->dataStatus;
OUTPUT:
RETVAL
time_t
jeml_postTime(self)
LSF_Batch_jobExternalMsgLog *self
CODE:
RETVAL = self->postTime;
OUTPUT:
RETVAL
char *
jeml_desc(self)
LSF_Batch_jobExternalMsgLog *self
CODE:
RETVAL = self->desc;
OUTPUT:
RETVAL
long
jeml_dataSize(self)
LSF_Batch_jobExternalMsgLog *self
CODE:
RETVAL = self->dataSize;
OUTPUT:
OUTPUT:
RETVAL
char *
jemr_userName(self)
LSF_Batch_jobExternalMsgReply *self
CODE:
RETVAL = self->userName;
OUTPUT:
RETVAL
MODULE = LSF::Batch PACKAGE = LSF::Batch::jRusagePtr PREFIX = jru_
int
jru_mem(self)
LSF_Batch_jRusage *self
CODE:
RETVAL = self->mem;
OUTPUT:
RETVAL
int
jru_swap(self)
LSF_Batch_jRusage *self
CODE:
RETVAL = self->swap;
OUTPUT:
RETVAL
int
jru_utime(self)
LSF_Batch_jRusage *self
CODE:
RETVAL = self->utime;
OUTPUT:
RETVAL
int
jru_stime(self)
LSF_Batch_jRusage *self
CODE:
RETVAL = self->stime;
OUTPUT:
RETVAL
int
jru_npids(self)
LSF_Batch_jRusage *self
CODE:
RETVAL = self->npids;
OUTPUT:
RETVAL
void
jru_pidInfo(self)
LSF_Batch_jRusage *self
PREINIT:
int num = 0;
SV *rv;
LSF_Batch_pidInfo *p;
PPCODE:
for (num = 0, p = self->pidInfo; num < self->npids; num ++, p ++) {
rv = newRV_inc(&PL_sv_undef);
sv_setref_iv(rv, "LSF::Batch::pidInfoPtr",(IV)p);
XPUSHs(sv_2mortal(rv));
}
XSRETURN(self->npids);
void
jru_pgids(self)
LSF_Batch_jRusage *self
PREINIT:
int num = 0;
PPCODE:
for (num = 0; num < self->npgids; num ++) {
XPUSHs(sv_2mortal(newSVnv(self->pgid[num])));
}
XSRETURN(self->npgids);
int
jru_nthreads(self)
LSF_Batch_jRusage *self
CODE:
RETVAL = self->nthreads;
OUTPUT:
RETVAL
MODULE = LSF::Batch PACKAGE = LSF::Batch::pidInfoPtr PREFIX = pi_
int
pi_pid(self)
LSF_Batch_pidInfo *self
CODE:
RETVAL = self->pid;
OUTPUT:
RETVAL
int
pi_ppid(self)
LSF_Batch_pidInfo *self
CODE:
RETVAL = self->ppid;
OUTPUT:
RETVAL
int
pi_pgid(self)
LSF_Batch_pidInfo *self
CODE:
RETVAL = self->pgid;
OUTPUT:
RETVAL
int
pi_jobid(self)
LSF_Batch_pidInfo *self
CODE:
RETVAL = self->jobid;
OUTPUT:
RETVAL
( run in 1.732 second using v1.01-cache-2.11-cpan-5511b514fd6 )