PPCODE results from the CPAN

PPCODE

LSF-Batch

view release on metacpan or search on metacpan

        HV*  sub;
    PREINIT:
        SV *rv;
        struct submit *s;
        struct submitReply reply;
        LSF_Batch_job *j;
        LS_LONG_INT jobId;
    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);
	  free_submit(s);
          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;
        }
        RETVAL = j;
    OUTPUT:
        RETVAL 

int
lsb_hostcontrol(self, host, opcode)
	void *self
	char *host
	int opcode;
    CODE:
	if( lsb_hostcontrol(host, opcode ) < 0 ){
	  STATUS_NATIVE_SET(lsberrno);
	  SET_LSB_ERRMSG;
	  RETVAL = 0;
	}
	else{
	  RETVAL = 1;
	}
    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",(I32)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",(I32)p);
	    XPUSHs(sv_2mortal(rv));
	}
	XSRETURN(num);
	

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

int
hi_busySched(self)
	LSF_Batch_hostInfo *self;
    CODE:
	RETVAL = *(self->busySched);
    OUTPUT:
	RETVAL

int
hi_busyStop(self)
	LSF_Batch_hostInfo *self;
    CODE:
	RETVAL = *(self->busyStop);
    OUTPUT:
	RETVAL

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

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",(I32)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

Batch.xs view on Meta::CPAN

    OUTPUT:
	RETVAL

int
pi_jobPriorityValue(self)
	LSF_Batch_parameterInfo *self;
    CODE:
	RETVAL = self->jobPriorityValue;
    OUTPUT:
	RETVAL

int
pi_jobPriorityTime(self)
	LSF_Batch_parameterInfo *self;
    CODE:
	RETVAL = self->jobPriorityTime;
    OUTPUT:
	RETVAL

int
pi_pgSuspendIt(self)
	LSF_Batch_parameterInfo *self;
    CODE:
	RETVAL = self->pgSuspendIt;
    OUTPUT:
	RETVAL


MODULE = LSF::Batch	PACKAGE = LSF::Batch	PREFIX = lsb_

int
lsb_queuecontrol(self, queue, opcode)
	void *self
	char *queue
	int opcode
    CODE:
	if( lsb_queuecontrol(queue, opcode) < 0 ){
	  STATUS_NATIVE_SET(lsberrno);
	  SET_LSB_ERRMSG;
	  RETVAL = 0;
	}
	else{
	  RETVAL = 1;
	}
    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",(I32)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

Batch.xs view on Meta::CPAN

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",(I32)p);
	    XPUSHs(sv_2mortal(rv));
	}
	XSRETURN(self->numOfSAccts);

int
qi_chunkJobSize(self)
	LSF_Batch_queueInfo *self
    CODE:
	RETVAL = self->chunkJobSize;
    OUTPUT:
	RETVAL


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

float
sai_histCpuTime(self)
	LSF_Batch_shareAcctInfo *self;
    CODE:
	RETVAL = self->histCpuTime;
    OUTPUT:
	RETVAL

int
sai_numReserveJobs(self)

Batch.xs view on Meta::CPAN

	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

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

Batch.xs view on Meta::CPAN

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->numExHosts);

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->numExHosts);

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 < self->nIdx; i++)
          XPUSHs(sv_2mortal(newSVnv(self->loadStop[i])));	
	XSRETURN(self->numExHosts);

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);


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",(I32)(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,(I32)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));
	  free_submit(s);
          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;
          }
        }
    OUTPUT:
        RETVAL 

int
job_jobId(self)
        LSF_Batch_job *self
    CODE:
        RETVAL = self->jobId;
    OUTPUT:
        RETVAL

int
job_arrayIdx(self)
        LSF_Batch_job *self
    CODE:
        RETVAL = self->arrayIdx;
    OUTPUT:

Batch.xs view on Meta::CPAN

	r.numHosts = count;
	r.hostname = hosts;
	r.options = options;
	if( lsb_runjob(&r) < 0 ){
	  STATUS_NATIVE_SET(lsberrno);
	  SET_LSB_ERRMSG;
	  RETVAL = 0;
        }
	else{
	  RETVAL = 1;
        }
    OUTPUT:
	RETVAL

int
job_signal(self, sigValue)
	LSF_Batch_job *self
	int sigValue
    CODE:
	if(lsb_signaljob(LSB_JOBID(self->jobId,self->arrayIdx), sigValue)<0){
	  STATUS_NATIVE_SET(lsberrno);
	  SET_LSB_ERRMSG;
	  RETVAL = 0;
	}
	else{
	  RETVAL = 1;
        }
        RETVAL = 1;
    OUTPUT:
	RETVAL

int 
job_switch(self, queue)
	LSF_Batch_job *self
	char *queue
    CODE:
	if( lsb_switchjob(LSB_JOBID(self->jobId,self->arrayIdx), queue) < 0 ){
	  STATUS_NATIVE_SET(lsberrno);
	  SET_LSB_ERRMSG;
	  RETVAL = 0;
	}
	else{
	  RETVAL = 1;
        }
    OUTPUT:
	RETVAL


MODULE = LSF::Batch	PACKAGE = LSF::Batch	PREFIX = lsb_

void
lsb_sharedresourceinfo(self, resources, hostName)
	void *self	
	char **resources
	char *hostName
    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, 0);
	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",(I32)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",
                       (I32)(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",(I32)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",
                        (I32)(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
	
MODULE = LSF::Batch PACKAGE = LSF::Batch PREFIX = lsb_

LSF_Batch_eventRec *
lsb_geteventrec(self, log_fp, lineNum)
	void  *self
	FILE* log_fp
	SV*   lineNum
   PREINIT:
	int ln;
   CODE:
	if( SvIOK(lineNum) ){
	   ln = (int)SvIV(lineNum);
	}
	else{
	   croak("geteventrec: lineNum is not an integer");
	}
	if((RETVAL = lsb_geteventrec(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";

Batch.xs view on Meta::CPAN

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

Batch.xs view on Meta::CPAN

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

Batch.xs view on Meta::CPAN

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)

Batch.xs view on Meta::CPAN

	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;

Batch.xs view on Meta::CPAN

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_

char *
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_

char *
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

Batch.xs view on Meta::CPAN


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:

( run in 0.531 second using v1.01-cache-2.11-cpan-5511b514fd6 )