af.basl

openPBS的开放源代码

		
				ires = JobIntResReqGet(j, "pncpus");
				printInt(jname, "JobIntResReqGet", "pncpus", ires);
		
				ires = JobIntResReqGet(j, "nodect");
				printInt(jname, "JobIntResReqGet", "nodect", ires);
		
				ires = JobIntResReqGet(j, "srfs_assist");
				printInt(jname, "JobIntResReqGet", "srfs_assist",
										ires);
		
				ires = JobIntResReqGet(j, "mta");
				printInt(jname, "JobIntResReqGet", "mta", ires);
		
				ires = JobIntResReqGet(j, "mtb");
				printInt(jname, "JobIntResReqGet", "mtb", ires);
		
				ires = JobIntResReqGet(j, "mtc");
				printInt(jname, "JobIntResReqGet", "mtc", ires);
		
				ires = JobIntResReqGet(j, "mtd");
				printInt(jname, "JobIntResReqGet", "mtd", ires);
		
				ires = JobIntResReqGet(j, "mte");
				printInt(jname, "JobIntResReqGet", "mte", ires);
		
				ires = JobIntResReqGet(j, "mtf");
				printInt(jname, "JobIntResReqGet", "mtf", ires);
		
				ires = JobIntResReqGet(j, "mtg");
				printInt(jname, "JobIntResReqGet", "mtg", ires);
		
				ires = JobIntResReqGet(j, "mth");
				printInt(jname, "JobIntResReqGet", "mth", ires);
		
		
		
				sres = JobSizeResReqGet(j, "file");
				printSize(jname, "JobSizeResReqGet", "file", sres);
		
				sres = JobSizeResReqGet(j, "mem");
				printSize(jname, "JobSizeResReqGet", "mem", sres);
		
				sres = JobSizeResReqGet(j, "pmem");
				printSize(jname, "JobSizeResReqGet", "pmem", sres);
		
				sres = JobSizeResReqGet(j, "workingset");
				printSize(jname, "JobSizeResReqGet", "workingset",
		                                                                 sres);
		
				sres = JobSizeResReqGet(j, "pf");
				printSize(jname, "JobSizeResReqGet", "pf", sres);
		
				sres = JobSizeResReqGet(j, "ppf");
				printSize(jname, "JobSizeResReqGet", "ppf", sres);
		
				sres = JobSizeResReqGet(j, "srfs_tmp");
				printSize(jname, "JobSizeResReqGet", "srfs_tmp",
		                                                                sres);
		
				sres = JobSizeResReqGet(j, "srfs_wrk");
				printSize(jname, "JobSizeResReqGet", "srfs_wrk",
		                                                                sres);
		
				sres = JobSizeResReqGet(j, "srfs_big");
				printSize(jname, "JobSizeResReqGet", "srfs_big",
		                                                                sres);
		
				sres = JobSizeResReqGet(j, "srfs_fast");
				printSize(jname, "JobSizeResReqGet", "srfs_fast",
		                                                                sres);
		
				sres = JobSizeResReqGet(j, "sds");
				printSize(jname, "JobSizeResReqGet", "sds",
		                                                                sres);
		
				sres = JobSizeResReqGet(j, "psds");
				printSize(jname, "JobSizeResReqGet", "psds",
		                                                                sres);
		
				stres = JobStringResReqGet(j, "nodes");
				printStr(jname, "JobStringResReqGet", "nodes",
		                                                                stres);
		
				stres = JobStringResReqGet(j, "arch");
				printStr(jname, "JobStringResReqGet", "arch",
		                                                                stres);
		
				stres = JobStringResReqGet(j, "neednodes");
				printStr(jname, "JobStringResReqGet", "neednodes",
		                                                                stres);
		
				// Resource Used

				ires = JobIntResUseGet(j, "cput");
				printInt(jname, "JobIntResUseGet", "cput", ires);
		
				ires = JobIntResUseGet(j, "pcput");
				printInt(jname, "JobIntResUseGet", "pcput", ires);
		
				ires = JobIntResUseGet(j, "walltime");
				printInt(jname, "JobIntResUseGet", "walltime",
										ires);
		
				ires = JobIntResUseGet(j, "mppt");
				printInt(jname, "JobIntResUseGet", "mppt", ires);
		
				ires = JobIntResUseGet(j, "pmppt");
				printInt(jname, "JobIntResUseGet", "pmppt", ires);
		
				ires = JobIntResUseGet(j, "nice");
				printInt(jname, "JobIntResUseGet", "nice", ires);
		
				ires = JobIntResUseGet(j, "procs");
				printInt(jname, "JobIntResUseGet", "procs", ires);
		
				ires = JobIntResUseGet(j, "mppe");
				printInt(jname, "JobIntResUseGet", "mppe", ires);
		
				ires = JobIntResUseGet(j, "ncpus");
				printInt(jname, "JobIntResUseGet", "ncpus",
										ires);
		
				ires = JobIntResUseGet(j, "pncpus");
				printInt(jname, "JobIntResUseGet", "pncpus",
										ires);
		
				ires = JobIntResUseGet(j, "nodect");
				printInt(jname, "JobIntResUseGet", "nodect",
										ires);
		
				ires = JobIntResUseGet(j, "srfs_assist");
				printInt(jname, "JobIntResUseGet", "srfs_assist",
										ires);
		
				ires = JobIntResUseGet(j, "mta");
				printInt(jname, "JobIntResUseGet", "mta", ires);
		
				ires = JobIntResUseGet(j, "mtb");
				printInt(jname, "JobIntResUseGet", "mtb", ires);
		
				ires = JobIntResUseGet(j, "mtc");
				printInt(jname, "JobIntResUseGet", "mtc", ires);
		
				ires = JobIntResUseGet(j, "mtd");
				printInt(jname, "JobIntResUseGet", "mtd", ires);
		
				ires = JobIntResUseGet(j, "mte");
				printInt(jname, "JobIntResUseGet", "mte", ires);
		
				ires = JobIntResUseGet(j, "mtf");
				printInt(jname, "JobIntResUseGet", "mtf", ires);
		
				ires = JobIntResUseGet(j, "mtg");
				printInt(jname, "JobIntResUseGet", "mtg", ires);
		
				ires = JobIntResUseGet(j, "mth");
				printInt(jname, "JobIntResUseGet", "mth", ires);
		
		
				sres = JobSizeResUseGet(j, "file");
				printSize(jname,"JobSizeResUseGet", "file", sres);
		
				sres = JobSizeResUseGet(j, "mem");
				printSize(jname, "JobSizeResUseGet", "mem", sres);
		
				sres = JobSizeResUseGet(j, "pmem");
				printSize(jname,"JobSizeResUseGet", "pmem", sres);
		
				sres = JobSizeResUseGet(j, "workingset");
				printSize(jname, "JobSizeResUseGet", "workingset",
		                                                                 sres);
		
				sres = JobSizeResUseGet(j, "pf");
				printSize(jname, "JobSizeResUseGet", "pf", sres);
		
				sres = JobSizeResUseGet(j, "ppf");
				printSize(jname, "JobSizeResUseGet", "ppf", sres);
		
				sres = JobSizeResUseGet(j, "srfs_tmp");
				printSize(jname, "JobSizeResUseGet", "srfs_tmp",
		                                                                sres);
		
				sres = JobSizeResUseGet(j, "srfs_wrk");
				printSize(jname, "JobSizeResUseGet", "srfs_wrk",
		                                                                sres);
		
				sres = JobSizeResUseGet(j, "srfs_big");
				printSize(jname, "JobSizeResUseGet", "srfs_big",
		                                                                sres);
		
				sres = JobSizeResUseGet(j, "srfs_fast");
				printSize(jname, "JobSizeResUseGet", "srfs_fast",
		                                                                sres);
		
				sres = JobSizeResUseGet(j, "sds");
				printSize(jname, "JobSizeResUseGet", "sds",
		                                                                sres);
		
				sres = JobSizeResUseGet(j, "psds");
				printSize(jname, "JobSizeResUseGet", "psds",
		                                                                sres);
		
				stres = JobStringResUseGet(j, "nodes");
				printStr(jname, "JobStringResUseGet", "nodes",
		                                                                stres);
		
				stres = JobStringResUseGet(j, "arch");
				printStr(jname, "JobStringResUseGet", "arch",
						stres);
		
				stres = JobStringResUseGet(j, "neednodes");
				printStr(jname, "JobStringResUseGet",
                                          		"neednodes", stres);

			} // jobs
		} // queues
		k++;	
	} // servers

	allcns = AllNodesGet();
	cnhead = AllNodesHeadGet();
	i=1;
	foreach( cn in allcns ) {

		if( i EQ 1 ) {
			if( CNodeNameGet(cn) EQ CNodeNameGet(cnhead) ) {
				printStr(NULLSTR, "AllNodesHeadGet", NULLSTR,
                                                               "passed");
			} else {
				printStr(NULLSTR, "AllNodesHeadGet", NULLSTR,
                                                               "failed");
			}
		}

		str = CNodeNameGet(cn) ;
		cname = str;
		printStr(cname, "CNodeNameGet", NULLSTR, str);
	
		str = CNodeAliasGet(cn) ;
		printStr(cname, "CNodeAliasGet", NULLSTR, str);
	
		str = CNodeVendorGet(cn) ;
		printStr(cname, "CNodeVendorGet", NULLSTR, str);
	
		str = CNodeOsGet(cn) ;
		printStr(cname, "CNodeOsGet", NULLSTR, str);
	
		i = CNodeNumCpusGet(cn) ;
		printInt(cname, "CNodeNumCpusGet", NULLSTR, i);

		sz =  CNodeMemTotalGet( cn, "real" ) ;
		printSize(cname, "CNodeMemTotalGet", "real", sz);
	
		sz =  CNodeMemTotalGet( cn, "virtual" ) ;
		printSize(cname, "CNodeMemTotalGet", "virtual", sz);
		
		sz =  CNodeMemAvailGet( cn, "real" ) ;
		printSize(cname, "CNodeMemAvailGet", "real", sz);
	
		sz =  CNodeMemAvailGet( cn, "virtual" ) ;
		printSize(cname, "CNodeMemAvailGet", "virtual", sz);

		i = CNodeStateGet( cn ) ;
		switch(i)
		{
		  case CNODE_DOWN:
			{
				printStr(cname, "CNodeStateGet", NULLSTR, "Down");
			}
		  case CNODE_OFFLINE:
			{
				printStr(cname, "CNodeStateGet", NULLSTR, "Offline");
			}
		  case CNODE_UP:
			{
				printStr(cname, "CNodeStateGet", NULLSTR, "Up");
			}
		  case CNODE_DYNAMIC_STALE:
			{
				printStr(cname, "CNodeStateGet", NULLSTR, "DynamicStale");
			}
		  case CNODE_STATIC_STALE:
			{
				printStr(cname, "CNodeStateGet", NULLSTR, "StaticStale");
			}
		  case CNODE_ALL_STALE:
			{
				printStr(cname, "CNodeStateGet", NULLSTR, "AllStale");
			}
		  default:	
			{
				printStr(cname, "CNodeStateGet", NULLSTR, "Unknown");
			}
		}	
	
		i = CNodeIdletimeGet( cn ) ;	
		printInt(cname, "CNodeIdleTimeGet", NULLSTR, i);
	
		f = CNodeLoadAveGet(  cn ) ;
		printFloat(cname, "CNodeLoadAveGet", NULLSTR, f);

		i = CNodeCpuPercentIdleGet( cn ) ;
		printInt(cname, "CNodeCpuPercentIdleGet", NULLSTR, i);

		i = CNodeCpuPercentSysGet( cn ) ;
		printInt(cname, "CNodeCpuPercentSysGet", NULLSTR, i);

		i = CNodeCpuPercentUserGet( cn ) ;
		printInt(cname, "CNodeCpuPercentUserGet", NULLSTR, i);

		i = CNodeCpuPercentGuestGet( cn ) ;
		printInt(cname, "CNodeCpuPercentGuestGet", NULLSTR, i);
	
		i = CNodeNetworkBwGet( cn, "hippi" ) ;
		printInt(cname, "CNodeNetworkBwGet", "hippi", i);

		sz = CNodeDiskSpaceTotalGet( cn, "/u" ) ;
		printSize(cname, "CNodeDiskSpaceTotalGet", "/u", sz);
	
		sz = CNodeDiskSpaceAvailGet( cn, "/u" ) ;
		printSize(cname, "CNodeDiskSpaceAvailGet", "/u", sz);
	
		sz = CNodeDiskSpaceReservedGet( cn, "/u" ) ;
		printSize(cname, "CNodeDiskSpaceReservedGet", "/u", sz);
	
		i = CNodeDiskInBwGet( cn, "/u" ) ;
		printInt(cname, "CNodeDiskInBwGet", "/u", i);
	
		i = CNodeDiskOutBwGet( cn, "/u" ) ;
		printInt(cname, "CNodeDiskOutBwGet", "/u", i);

		sz = CNodeDiskSpaceTotalGet( cn, "/u/wk" ) ;
		printSize(cname, "CNodeDiskSpaceTotalGet", "/u/wk", sz);
	
		sz = CNodeDiskSpaceAvailGet( cn, "/u/wk" ) ;
		printSize(cname, "CNodeDiskSpaceAvailGet", "/u/wk", sz);
	
		sz = CNodeDiskSpaceReservedGet( cn, "/u/wk" ) ;
		printSize(cname, "CNodeDiskSpaceReservedGet", "/u/wk", sz);
	
		i = CNodeDiskInBwGet( cn, "/u/wk" ) ;
		printInt(cname, "CNodeDiskInBwGet", "/u/wk", i);
	
		i = CNodeDiskOutBwGet( cn, "/u/wk" ) ;
		printInt(cname, "CNodeDiskOutBwGet", "/u/wk", i);


		sz = CNodeDiskSpaceTotalGet( cn, "/tmp" ) ;
		printSize(cname, "CNodeDiskSpaceTotalGet", "/tmp", sz);
	
		sz = CNodeDiskSpaceAvailGet( cn, "/tmp" ) ;
		printSize(cname, "CNodeDiskSpaceAvailGet", "/tmp", sz);
	
		sz = CNodeDiskSpaceReservedGet( cn, "/tmp" ) ;
		printSize(cname, "CNodeDiskSpaceReservedGet", "/tmp", sz);
	
		i = CNodeDiskInBwGet( cn, "/tmp" ) ;
		printInt(cname, "CNodeDiskInBwGet", "/tmp", i);
	
		i = CNodeDiskOutBwGet( cn, "/tmp" ) ;
		printInt(cname, "CNodeDiskOutBwGet", "/tmp", i);


		name = "primary";	
		sz = CNodeSwapSpaceTotalGet( cn, name ) ;
		printSize(cname, "CNodeSwapSpaceTotalGet", name, sz); 
	
		sz = CNodeSwapSpaceAvailGet( cn, name ) ;
		printSize(cname, "CNodeSwapSpaceAvailGet", name, sz); 
	
		i = CNodeSwapInBwGet( cn, name ) ;
		printInt(cname, "CNodeSwapInBwGet", name, i); 
	
		i = CNodeSwapOutBwGet( cn, name ) ;
		printInt(cname, "CNodeSwapOutBwGet", name, i); 
	
		sz = CNodeTapeSpaceTotalGet( cn, "4mm" ) ;
		printSize(cname, "CNodeTapeSpaceTotalGet", "4mm", sz); 
	
		sz = CNodeTapeSpaceAvailGet( cn, "4mm" ) ;
		printSize(cname, "CNodeTapeSpaceAvailGet", "4mm", sz); 
	
		i = CNodeTapeInBwGet( cn, "4mm" ) ;
		printInt(cname, "CNodeTapeInBwGet", "4mm", i); 
	
		i = CNodeTapeOutBwGet( cn, "4mm" ) ;
		printInt(cname, "CNodeTapeOutBwGet", "4mm", i); 

		sz = CNodeTapeSpaceTotalGet( cn, "8mm" ) ;
		printSize(cname, "CNodeTapeSpaceTotalGet", "8mm", sz); 
	
		sz = CNodeTapeSpaceAvailGet( cn, "8mm" ) ;
		printSize(cname, "CNodeTapeSpaceAvailGet", "8mm", sz); 
	
		i = CNodeTapeInBwGet( cn, "8mm" ) ;
		printInt(cname, "CNodeTapeInBwGet", "8mm", i); 
	
		i = CNodeTapeOutBwGet( cn, "8mm" ) ;
		printInt(cname, "CNodeTapeOutBwGet", "8mm", i); 

	
		sz = CNodeSrfsSpaceTotalGet( cn, "fast" ) ;
		printSize(cname, "CNodeSrfsSpaceTotalGet", "fast", sz); 
	
		sz = CNodeSrfsSpaceAvailGet( cn, "fast" ) ;
		printSize(cname, "CNodeSrfsSpaceAvailGet", "fast", sz); 
	
		sz = CNodeSrfsSpaceReservedGet( cn, "fast" ) ;
		printSize(cname, "CNodeSrfsSpaceReservedGet", "fast", sz); 
	
		i = CNodeSrfsInBwGet( cn, "fast" ) ;
		printInt(cname, "CNodeSrfsInBwGet", "fast", i); 
	
		i = CNodeSrfsOutBwGet( cn, "fast" ) ;
		printInt(cname, "CNodeSrfsOutBwGet", "fast", i); 

		sz = CNodeSrfsSpaceTotalGet( cn, "big" ) ;
		printSize(cname, "CNodeSrfsSpaceTotalGet", "big", sz); 
	
		sz = CNodeSrfsSpaceAvailGet( cn, "big" ) ;
		printSize(cname, "CNodeSrfsSpaceAvailGet", "big", sz); 
	
		sz = CNodeSrfsSpaceReservedGet( cn, "big" ) ;
		printSize(cname, "CNodeSrfsSpaceReservedGet", "big", sz); 
	
		i = CNodeSrfsInBwGet( cn, "big" ) ;
		printInt(cname, "CNodeSrfsInBwGet", "big", i); 
	
		i = CNodeSrfsOutBwGet( cn, "big" ) ;
		printInt(cname, "CNodeSrfsOutBwGet", "big", i); 

		i++;
	}

        print("*****************Doing various miscellaneous functions*******");
        print("Jobs in fast are searched and queues filter while Jobs in slow are operated on");
 
	s = AllServersHeadGet();
	sq = 	ServerQueuesGet(s) ;

	que = findQueByName(sq, "fast");	

	i = 300;
	job = QueJobFind(que, JobWallTimeReqGet, OP_EQ, i);
	if( job NEQ NOJOB ) {
		str = "1st job in fast whose wallTimeReq == 300s: " + JobIdGet(job);
	} else {
		str = "1st job in fast whose wallTimeReq == 300s: " + "NOJOB";
	}
	print(str);

	str = "bayucan";
	job = QueJobFind(que, JobEmailAddrGet, OP_NEQ, str);
	if( job NEQ NOJOB ) {
		str = "1st job in fast whose JobEmailAddrGet != bayucan: " + JobIdGet(job);
	} else {
		str = "1st job in fast whose JobEmailAddrGet != bayucan: " + "NOJOB"; 
	}
	print(str);


	d = (4|9|1997);
	job = QueJobFind(que, JobDateTimeCreatedGet, OP_GE, d);
	if( job NEQ NOJOB ) {
		str = "1st job in fast whose JobDateTimeCreatedGet >= 4|9|1997: " + JobIdGet(job);
	} else {
		str = "1st job in fast whose JobDateTimeCreatedGet >= 4|9|1997: " + "NOJOB";
	}
	print(str);


	d = (12:00:00);
	job = QueJobFind(que, JobDateTimeCreatedGet, OP_GT, d);
	if( job NEQ NOJOB ) {
		str = "1st job in fast whose JobDateTimeCreatedGet > 12h0m0s: " + JobIdGet(job);
	} else {
		str = "1st job in fast whose JobDateTimeCreatedGet > 12h0m0s: " + "NOJOB";
	}
	print(str);

	d = (4|9|1997@12:00:00);
	job = QueJobFind(que, JobDateTimeCreatedGet, OP_LT, d);
	if( job NEQ NOJOB ) {
		str = "1st job in fast whose JobDateTimeCreatedGet < 4|9|1997@12h0m0s: " + JobIdGet(job);
	} else {