LSF_Batch
view release on metacpan or search on metacpan
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++ ){
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;
}
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)));
}
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)));
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->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:
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:
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);
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);
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;
}
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;
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:
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;
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;
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
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 ->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];
}
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:
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:
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:
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
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;
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 = 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
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);
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;
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;
}
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_
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++ ){
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);
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);
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:
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:
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:
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:
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:
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:
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
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::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:
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);
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:
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;
}
print "/* XS Code.... */\n";
print "MODULE = LSF::Batch PACKAGE = LSF::Batch::eventRecPtr PREFIX = er_\n";
print "\n";
print "void\n";
print "er_eventLog(self)\n";
print "\tLSF_Batch_eventRec *self\n";
print " PREINIT:\n";
print "\tchar *label;\n";
print "\tSV *rv;\n";
print " PPCODE:\n";
print "\tswitch(self->type){\n";
foreach $struct (@structures){
$label = $struct;
$label =~ s/Log$//;
$label =~ s/([A-Z]{1})/_\1/g;
$label = "EVENT_" . uc $label;
print "\t case $label:\n";
print "\t label = \"LSF::Batch::${struct}Ptr\";\n";
print "\t rv = newRV_inc(&PL_sv_undef);\n";
( run in 0.542 second using v1.01-cache-2.11-cpan-5511b514fd6 )