af2.basl

openPBS的开放源代码

		printInt(sname, "ServerIntResAssignGet", "nice", ires);

		ires = ServerIntResAssignGet(s, "procs");
		printInt(sname, "ServerIntResAssignGet", "procs", ires);

		ires = ServerIntResAssignGet(s, "mppe");
		printInt(sname, "ServerIntResAssignGet", "mppe", ires);

		ires = ServerIntResAssignGet(s, "ncpus");
		printInt(sname, "ServerIntResAssignGet", "ncpus",
								ires);

		ires = ServerIntResAssignGet(s, "pncpus");
		printInt(sname, "ServerIntResAssignGet", "pncpus",
								ires);

		ires = ServerIntResAssignGet(s, "nodect");
		printInt(sname, "ServerIntResAssignGet", "nodect",
								ires);

		ires = ServerIntResAssignGet(s, "srfs_assist");
		printInt(sname, "ServerIntResAssignGet", "srfs_assist",
								ires);

		ires = ServerIntResAssignGet(s, "mta");
		printInt(sname, "ServerIntResAssignGet", "mta", ires);

		ires = ServerIntResAssignGet(s, "mtb");
		printInt(sname, "ServerIntResAssignGet", "mtb", ires);

		ires = ServerIntResAssignGet(s, "mtc");
		printInt(sname, "ServerIntResAssignGet", "mtc", ires);

		ires = ServerIntResAssignGet(s, "mtd");
		printInt(sname, "ServerIntResAssignGet", "mtd", ires);

		ires = ServerIntResAssignGet(s, "mte");
		printInt(sname, "ServerIntResAssignGet", "mte", ires);

		ires = ServerIntResAssignGet(s, "mtf");
		printInt(sname, "ServerIntResAssignGet", "mtf", ires);

		ires = ServerIntResAssignGet(s, "mtg");
		printInt(sname, "ServerIntResAssignGet", "mtg", ires);

		ires = ServerIntResAssignGet(s, "mth");
		printInt(sname, "ServerIntResAssignGet", "mth", ires);


		sres = ServerSizeResAssignGet(s, "file");
		printSize(sname,"ServerSizeResAssignGet", "file", sres);

		sres = ServerSizeResAssignGet(s, "mem");
		printSize(sname, "ServerSizeResAssignGet", "mem", sres);

		sres = ServerSizeResAssignGet(s, "pmem");
		printSize(sname,"ServerSizeResAssignGet", "pmem", sres);

		sres = ServerSizeResAssignGet(s, "workingset");
		printSize(sname, "ServerSizeResAssignGet", "workingset",
                                                                 sres);

		sres = ServerSizeResAssignGet(s, "pf");
		printSize(sname, "ServerSizeResAssignGet", "pf", sres);

		sres = ServerSizeResAssignGet(s, "ppf");
		printSize(sname, "ServerSizeResAssignGet", "ppf", sres);

		sres = ServerSizeResAssignGet(s, "srfs_tmp");
		printSize(sname, "ServerSizeResAssignGet", "srfs_tmp",
                                                                sres);

		sres = ServerSizeResAssignGet(s, "srfs_wrk");
		printSize(sname, "ServerSizeResAssignGet", "srfs_wrk",
                                                                sres);

		sres = ServerSizeResAssignGet(s, "srfs_big");
		printSize(sname, "ServerSizeResAssignGet", "srfs_big",
                                                                sres);

		sres = ServerSizeResAssignGet(s, "srfs_fast");
		printSize(sname, "ServerSizeResAssignGet", "srfs_fast",
                                                                sres);

		sres = ServerSizeResAssignGet(s, "sds");
		printSize(sname, "ServerSizeResAssignGet", "sds",
                                                                sres);

		sres = ServerSizeResAssignGet(s, "psds");
		printSize(sname, "ServerSizeResAssignGet", "psds",
                                                                sres);

		stres = ServerStringResAssignGet(s, "nodes");
		printStr(sname, "ServerStringResAssignGet", "nodes",
                                                                stres);

		stres = ServerStringResAssignGet(s, "arch");
		printStr(sname, "ServerStringResAssignGet", "arch",
                                                                stres);

		stres = ServerStringResAssignGet(s, "neednodes");
		printStr(sname, "ServerStringResAssignGet", "neednodes",
                                                                stres);


			alljs = ServerJobsGet(s);
			foreach( j in alljs ) {

				jname = JobIdGet( j ) ;
				printStr(jname, "JobIdGet", NULLSTR, jname);
			
				str = JobNameGet( j ) ;
				printStr(jname, "JobNameGet", NULLSTR, str);
			
				str = JobOwnerNameGet( j ) ;
				printStr(jname, "JobOwnerNameGet", NULLSTR, str);
			
				str = JobEffectiveUserNameGet( j ) ;
				printStr(jname, "JobEffectiveUserNameGet", NULLSTR, str);
			
				str = JobEffectiveGroupNameGet( j ) ;
				printStr(jname, "JobEffectiveGroupNameGet", NULLSTR, str);
			
				i = JobStateGet ( j ) ;
				switch(i)
				{
					case TRANSIT:
						{
							printStr(jname, "JobStateGet", NULLSTR, "Transit");
						}
					case QUEUED:
						{
							printStr(jname, "JobStateGet", NULLSTR, "Queued");
						}
					case HELD:
						{
							printStr(jname, "JobStateGet", NULLSTR, "Held");
						}
					case WAITING:
						{
							printStr(jname, "JobStateGet", NULLSTR, "Waiting");
						}
					case RUNNING:
						{
							printStr(jname, "JobStateGet", NULLSTR, "Running");
						}
					case EXITING:
						{
							printStr(jname, "JobStateGet", NULLSTR, "Exiting");
						}
					default:
						{
							printStr(jname, "JobStateGet", NULLSTR, "Unknown");
						}
				}
			
				i = JobPriorityGet( j ) ;
				printInt(jname, "JobPriorityGet", NULLSTR, i);
			
				i = JobRerunFlagGet( j ) ;
				switch(i)
				{
					case FALSE:
						{
							printStr(jname, "JobRerunFlagGet", NULLSTR, "False");
						}
					case TRUE:
						{
							printStr(jname, "JobRerunFlagGet", NULLSTR, "True");
						}
					default:
						{
							printStr(jname, "JobRerunFlagGet", NULLSTR, "Unknown");
						}
				}
			
				i = JobInteractiveFlagGet( j ) ;
				switch(i)
				{
					case FALSE:
						{
							printStr(jname, "JobInteractiveFlagGet", NULLSTR, "False");
						}
					case TRUE:
						{
							printStr(jname, "JobInteractiveFlagGet", NULLSTR, "True");
						}
					default:
						{
							print("Interactive flag is unknown");	
						}
				}
		
				d = JobDateTimeCreatedGet( j ) ;
				printDateTime(jname, "JobDateTimeCreatedGet", NULLSTR, d);
			
				str = JobEmailAddrGet( j ) ;
				printStr(jname, "JobEmailAddrGet", NULLSTR, str);
			
				str = JobStageinFilesGet( j ) ;
				printStr(jname, "JobStageinFilesGet", NULLSTR, str);
			
				str = JobStageoutFilesGet( j ) ;
				printStr(jname, "JobStageoutFilesGet", NULLSTR, str);

				// Resource Request 
				ires = JobIntResReqGet(j, "cput");
				printInt(jname, "JobIntResReqGet", "cput", ires);
		
				ires = JobIntResReqGet(j, "pcput");
				printInt(jname, "JobIntResReqGet", "pcput", ires);
		
				ires = JobIntResReqGet(j, "walltime");
				printInt(jname, "JobIntResReqGet", "walltime", ires);
		
				ires = JobIntResReqGet(j, "mppt");
				printInt(jname, "JobIntResReqGet", "mppt", ires);
		
				ires = JobIntResReqGet(j, "pmppt");
				printInt(jname, "JobIntResReqGet", "pmppt", ires);
		
				ires = JobIntResReqGet(j, "nice");
				printInt(jname, "JobIntResReqGet", "nice", ires);
		
				ires = JobIntResReqGet(j, "procs");
				printInt(jname, "JobIntResReqGet", "procs", ires);
		
				ires = JobIntResReqGet(j, "mppe");
				printInt(jname, "JobIntResReqGet", "mppe", ires);
		
				ires = JobIntResReqGet(j, "ncpus");
				printInt(jname, "JobIntResReqGet", "ncpus", ires);
		
				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
		k++;	
	} // servers

}