af.basl

openPBS的开放源代码

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


		allqs = ServerQueuesGet(s);

		foreach(q in allqs) {
			str = QueNameGet( q ) ;
			qname = sname + "-" + str;
			printStr(qname, "QueNameGet", NULLSTR, str);
	
			i = QueTypeGet( q ) ;
			if( i EQ QTYPE_E ) {
				printStr(qname, "QueTypeGet", NULLSTR, "Execution");
			} else {
				if( i EQ QTYPE_R ) {
					printStr(qname, "QueTypeGet", NULLSTR, "Routing");
				}	
			}

	
			i = QueNumJobsGet( q ) ;
			printInt(qname, "QueNumJobsGet", NULLSTR, i);
	
			i = QueMaxRunJobsGet( q ) ;
			printInt(qname, "QueMaxRunJobsGet", NULLSTR, i);
							
			i = QueMaxRunJobsPerUserGet( q ) ;
			printInt(qname, "QueMaxRunJobsPerUserGet", NULLSTR, i);
	
			i = QueMaxRunJobsPerGroupGet( q ) ;
			printInt(qname, "QueMaxRunJobsPerGroupGet", NULLSTR, i);
	
	
			i = QuePriorityGet( q ) ;
			printInt(qname, "QuePriorityGet", NULLSTR, i);
	
			i = QueStateGet( q ) ;
			if( i EQ SCHED_DISABLED ) {
				printStr(qname, "QueStateGet", NULLSTR, "Disabled for scheduling");
			} else {
				if( i EQ SCHED_ENABLED ) {
					printStr(qname, "QueStateGet", NULLSTR, "Enabled for scheduling");
				}
			}
			// the Avails
			ires = QueIntResAvailGet(q, "cput");
			printInt(qname, "QueIntResAvailGet", "cput", ires);
	
			ires = QueIntResAvailGet(q, "pcput");
			printInt(qname, "QueIntResAvailGet", "pcput", ires);
	
			ires = QueIntResAvailGet(q, "walltime");
			printInt(qname, "QueIntResAvailGet", "walltime", ires);
	
			ires = QueIntResAvailGet(q, "mppt");
			printInt(qname, "QueIntResAvailGet", "mppt", ires);
	
			ires = QueIntResAvailGet(q, "pmppt");
			printInt(qname, "QueIntResAvailGet", "pmppt", ires);
	
			ires = QueIntResAvailGet(q, "nice");
			printInt(qname, "QueIntResAvailGet", "nice", ires);
	
			ires = QueIntResAvailGet(q, "procs");
			printInt(qname, "QueIntResAvailGet", "procs", ires);
	
			ires = QueIntResAvailGet(q, "mppe");
			printInt(qname, "QueIntResAvailGet", "mppe", ires);
	
			ires = QueIntResAvailGet(q, "ncpus");
			printInt(qname, "QueIntResAvailGet", "ncpus", ires);
	
			ires = QueIntResAvailGet(q, "pncpus");
			printInt(qname, "QueIntResAvailGet", "pncpus", ires);
	
			ires = QueIntResAvailGet(q, "nodect");
			printInt(qname, "QueIntResAvailGet", "nodect", ires);
	
			ires = QueIntResAvailGet(q, "srfs_assist");
			printInt(qname, "QueIntResAvailGet", "srfs_assist",
									ires);
	
			ires = QueIntResAvailGet(q, "mta");
			printInt(qname, "QueIntResAvailGet", "mta", ires);
	
			ires = QueIntResAvailGet(q, "mtb");
			printInt(qname, "QueIntResAvailGet", "mtb", ires);
	
			ires = QueIntResAvailGet(q, "mtc");
			printInt(qname, "QueIntResAvailGet", "mtc", ires);
	
			ires = QueIntResAvailGet(q, "mtd");
			printInt(qname, "QueIntResAvailGet", "mtd", ires);
	
			ires = QueIntResAvailGet(q, "mte");
			printInt(qname, "QueIntResAvailGet", "mte", ires);
	
			ires = QueIntResAvailGet(q, "mtf");
			printInt(qname, "QueIntResAvailGet", "mtf", ires);
	
			ires = QueIntResAvailGet(q, "mtg");
			printInt(qname, "QueIntResAvailGet", "mtg", ires);
	
			ires = QueIntResAvailGet(q, "mth");
			printInt(qname, "QueIntResAvailGet", "mth", ires);
	
	
	
			sres = QueSizeResAvailGet(q, "file");
			printSize(qname, "QueSizeResAvailGet", "file", sres);
	
			sres = QueSizeResAvailGet(q, "mem");
			printSize(qname, "QueSizeResAvailGet", "mem", sres);
	
			sres = QueSizeResAvailGet(q, "pmem");
			printSize(qname, "QueSizeResAvailGet", "pmem", sres);
	
			sres = QueSizeResAvailGet(q, "workingset");
			printSize(qname, "QueSizeResAvailGet", "workingset",
	                                                                 sres);
	
			sres = QueSizeResAvailGet(q, "pf");
			printSize(qname, "QueSizeResAvailGet", "pf", sres);
	
			sres = QueSizeResAvailGet(q, "ppf");
			printSize(qname, "QueSizeResAvailGet", "ppf", sres);
	
			sres = QueSizeResAvailGet(q, "srfs_tmp");
			printSize(qname, "QueSizeResAvailGet", "srfs_tmp",
	                                                                sres);
	
			sres = QueSizeResAvailGet(q, "srfs_wrk");
			printSize(qname, "QueSizeResAvailGet", "srfs_wrk",
	                                                                sres);
	
			sres = QueSizeResAvailGet(q, "srfs_big");
			printSize(qname, "QueSizeResAvailGet", "srfs_big",
	                                                                sres);
	
			sres = QueSizeResAvailGet(q, "srfs_fast");
			printSize(qname, "QueSizeResAvailGet", "srfs_fast",
	                                                                sres);
	
			sres = QueSizeResAvailGet(q, "sds");
			printSize(qname, "QueSizeResAvailGet", "sds",
	                                                                sres);
	
			sres = QueSizeResAvailGet(q, "psds");
			printSize(qname, "QueSizeResAvailGet", "psds",
	                                                                sres);
	
			stres = QueStringResAvailGet(q, "nodes");
			printStr(qname, "QueStringResAvailGet", "nodes",
	                                                                stres);
	
			stres = QueStringResAvailGet(q, "arch");
			printStr(qname, "QueStringResAvailGet", "arch",
	                                                                stres);
	
			stres = QueStringResAvailGet(q, "neednodes");
			printStr(qname, "QueStringResAvailGet", "neednodes",
	                                                                stres);
	
			// the ASSIGNS	
			ires = QueIntResAssignGet(q, "cput");
			printInt(qname, "QueIntResAssignGet", "cput", ires);
	
			ires = QueIntResAssignGet(q, "pcput");
			printInt(qname, "QueIntResAssignGet", "pcput", ires);
	
			ires = QueIntResAssignGet(q, "walltime");
			printInt(qname, "QueIntResAssignGet", "walltime",
									ires);
	
			ires = QueIntResAssignGet(q, "mppt");
			printInt(qname, "QueIntResAssignGet", "mppt", ires);
	
			ires = QueIntResAssignGet(q, "pmppt");
			printInt(qname, "QueIntResAssignGet", "pmppt", ires);
	
			ires = QueIntResAssignGet(q, "nice");
			printInt(qname, "QueIntResAssignGet", "nice", ires);
	
			ires = QueIntResAssignGet(q, "procs");
			printInt(qname, "QueIntResAssignGet", "procs", ires);
	
			ires = QueIntResAssignGet(q, "mppe");
			printInt(qname, "QueIntResAssignGet", "mppe", ires);
	
			ires = QueIntResAssignGet(q, "ncpus");
			printInt(qname, "QueIntResAssignGet", "ncpus",
									ires);
	
			ires = QueIntResAssignGet(q, "pncpus");
			printInt(qname, "QueIntResAssignGet", "pncpus",
									ires);
	
			ires = QueIntResAssignGet(q, "nodect");
			printInt(qname, "QueIntResAssignGet", "nodect",
									ires);
	
			ires = QueIntResAssignGet(q, "srfs_assist");
			printInt(qname, "QueIntResAssignGet", "srfs_assist",
									ires);
	
			ires = QueIntResAssignGet(q, "mta");
			printInt(qname, "QueIntResAssignGet", "mta", ires);
	
			ires = QueIntResAssignGet(q, "mtb");
			printInt(qname, "QueIntResAssignGet", "mtb", ires);
	
			ires = QueIntResAssignGet(q, "mtc");
			printInt(qname, "QueIntResAssignGet", "mtc", ires);
	
			ires = QueIntResAssignGet(q, "mtd");
			printInt(qname, "QueIntResAssignGet", "mtd", ires);
	
			ires = QueIntResAssignGet(q, "mte");
			printInt(qname, "QueIntResAssignGet", "mte", ires);
	
			ires = QueIntResAssignGet(q, "mtf");
			printInt(qname, "QueIntResAssignGet", "mtf", ires);
	
			ires = QueIntResAssignGet(q, "mtg");
			printInt(qname, "QueIntResAssignGet", "mtg", ires);
	
			ires = QueIntResAssignGet(q, "mth");
			printInt(qname, "QueIntResAssignGet", "mth", ires);
	
	
			sres = QueSizeResAssignGet(q, "file");
			printSize(qname,"QueSizeResAssignGet", "file", sres);
	
			sres = QueSizeResAssignGet(q, "mem");
			printSize(qname, "QueSizeResAssignGet", "mem", sres);
	
			sres = QueSizeResAssignGet(q, "pmem");
			printSize(qname,"QueSizeResAssignGet", "pmem", sres);
	
			sres = QueSizeResAssignGet(q, "workingset");
			printSize(qname, "QueSizeResAssignGet", "workingset",
	                                                                 sres);
	
			sres = QueSizeResAssignGet(q, "pf");
			printSize(qname, "QueSizeResAssignGet", "pf", sres);
	
			sres = QueSizeResAssignGet(q, "ppf");
			printSize(qname, "QueSizeResAssignGet", "ppf", sres);
	
			sres = QueSizeResAssignGet(q, "srfs_tmp");
			printSize(qname, "QueSizeResAssignGet", "srfs_tmp",
	                                                                sres);
	
			sres = QueSizeResAssignGet(q, "srfs_wrk");
			printSize(qname, "QueSizeResAssignGet", "srfs_wrk",
	                                                                sres);
	
			sres = QueSizeResAssignGet(q, "srfs_big");
			printSize(qname, "QueSizeResAssignGet", "srfs_big",
	                                                                sres);
	
			sres = QueSizeResAssignGet(q, "srfs_fast");
			printSize(qname, "QueSizeResAssignGet", "srfs_fast",
	                                                                sres);
	
			sres = QueSizeResAssignGet(q, "sds");
			printSize(qname, "QueSizeResAssignGet", "sds",
	                                                                sres);
	
			sres = QueSizeResAssignGet(q, "psds");
			printSize(qname, "QueSizeResAssignGet", "psds",
	                                                                sres);
	
			stres = QueStringResAssignGet(q, "nodes");
			printStr(qname, "QueStringResAssignGet", "nodes",
	                                                                stres);
	
			stres = QueStringResAssignGet(q, "arch");
			printStr(qname, "QueStringResAssignGet", "arch",
	                                                                stres);
	
			stres = QueStringResAssignGet(q, "neednodes");
			printStr(qname, "QueStringResAssignGet", "neednodes",
									stres);
			alljs = QueJobsGet(q);
			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);