af.basl

openPBS的开放源代码

//
//         OpenPBS (Portable Batch System) v2.3 Software License
// 
// Copyright (c) 1999-2000 Veridian Information Solutions, Inc.
// All rights reserved.
// 
// ---------------------------------------------------------------------------
// For a license to use or redistribute the OpenPBS software under conditions
// other than those described below, or to purchase support for this software,
// please contact Veridian Systems, PBS Products Department ("Licensor") at:
// 
//    www.OpenPBS.org  [phone]                  [e-mail]
//                        877 902-4PBS (US toll-free)
// ---------------------------------------------------------------------------
// 
// This license covers use of the OpenPBS v2.3 software (the "Software") at
// your site or location, and, for certain users, redistribution of the
// Software to other sites and locations.  Use and redistribution of
// OpenPBS v2.3 in source and binary forms, with or without modification,
// are permitted provided that all of the following conditions are met.
// After December 31, 2001, only conditions 3-6 must be met:
// 
// 1. Commercial and/or non-commercial use of the Software is permitted
//    provided a current software registration is on file at www.OpenPBS.org.
//    If use of this software contributes to a publication, product, or
//    service, proper attribution must be given; see www.OpenPBS.org/credit.html
// 
// 2. Redistribution in any form is only permitted for non-commercial,
//    non-profit purposes.  There can be no charge for the Software or any
//    software incorporating the Software.  Further, there can be no
//    expectation of revenue generated as a consequence of redistributing
//    the Software.
// 
// 3. Any Redistribution of source code must retain the above copyright notice
//    and the acknowledgment contained in paragraph 6, this list of conditions
//    and the disclaimer contained in paragraph 7.
// 
// 4. Any Redistribution in binary form must reproduce the above copyright
//    notice and the acknowledgment contained in paragraph 6, this list of
//    conditions and the disclaimer contained in paragraph 7 in the
//    documentation and/or other materials provided with the distribution.
// 
// 5. Redistributions in any form must be accompanied by information on how to
//    obtain complete source code for the OpenPBS software and any
//    modifications and/or additions to the OpenPBS software.  The source code
//    must either be included in the distribution or be available for no more
//    than the cost of distribution plus a nominal fee, and all modifications
//    and additions to the Software must be freely redistributable by any party
//    (including Licensor) without restriction.
// 
// 6. All advertising materials mentioning features or use of the Software must
//    display the following acknowledgment:
// 
//     "This product includes software developed by NASA Ames Research Center,
//     Lawrence Livermore National Laboratory, and Veridian Information
//     Solutions, Inc.
//     Visit www.OpenPBS.org for OpenPBS software support,
//     products, and information."
// 
// 7. DISCLAIMER OF WARRANTY
// 
// THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND. ANY EXPRESS
// OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT
// ARE EXPRESSLY DISCLAIMED.
// 
// IN NO EVENT SHALL VERIDIAN CORPORATION, ITS AFFILIATED COMPANIES, OR THE
// U.S. GOVERNMENT OR ANY OF ITS AGENCIES BE LIABLE FOR ANY DIRECT OR INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
// OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
// EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// 
// This license will be governed by the laws of the Commonwealth of Virginia,
// without reference to its choice of law rules.
// 
//
//
// af.basl: This scheduler does nothing useful to jobs except perform a 
// 	    regression test on BASL features. It will actually run one job on
// 	    every iteration. This code provides useful examples on how to call
//          the BASL assist/predefined functions.
//
// Environment: 2 Servers / 2 CNodes
//

// **************************************************************************
//
// User-defined Functions
//
// **************************************************************************

Int JobWallTimeReqGet( Job job ) {
	Int wallt;

	wallt = JobIntResReqGet(job, "walltime");
	return(wallt);
}

Int JobWallTimeUsedGet( Job job ) {
	Int wallt;

	wallt = JobIntResUseGet(job, "walltime");
	return(wallt);
}

Int JobCpuTimeReqGet( Job job ) {
	Int cput;

	cput = JobIntResReqGet(job, "cput");
	return(cput);
}

Int JobCpuTimeUsedGet( Job job ) {
	Int cput;

	cput = JobIntResUseGet(job, "cput");
	return(cput);
}

Size JobVirtualMemAvailGet(Job job)
{
	Size sz;
	sz = JobSizeResReqGet(job, "mem");
	return(sz);
}

Void printInt(String name, String fname, String resname, Int i)
{
	String str;

	str = fname   + "[" + name + "]" + "." +
              resname + "=";
	print(str);
	print(i);
}
Void printStr(String name, String fname, String resname, String string)
{
	String str;

	str = fname   + "[" + name + "]" + "." +
              resname + "=";
	print(str);
	print(string);
}
Void printSize(String name, String fname, String resname, Size sz)
{
	String str;

	str = fname   + "[" + name + "]" + "." +
              resname + "=";
	print(str);
	print(sz);

}
Void printDateTime(String name, String fname, String resname, DateTime dt)
{
	String str;

	str = fname   + "[" + name + "]" + "." +
              resname + "=";
	print(str);
	print(dt);

}
Void printFloat(String name, String fname, String resname, Float f)
{
	String str;

	str = fname   + "[" + name + "]" + "." +
              resname + "=";
	print(str);
	print(f);
}

Que findQueByName( Set Que sq, String qname )
{
	Que q;

	foreach(q in sq) {
		if( QueNameGet(q) EQ qname ) {
			return(q);
		}
	}
	return(NOQUE);
}

// **************************************************************************
//
// Global variable declarations
//
// **************************************************************************

String server_name1;
String server_name2;
String mom_name1;
String mom_name2;

// **************************************************************************
//
// Assignment statements to global variables
//
// **************************************************************************

server_name1 = "db";
server_name2 = "ruby";
mom_name1 = "db";
mom_name2 = "ruby";

// **************************************************************************
//
// main scheduling code
//
// **************************************************************************
sched_main()
{
	Int	i;
	Int	k;
	CNode   cn;
	CNode   cnhead;
	Server  s;
	Server  shead;
	Job	j;
	Set CNode  allcns;
	Set Server alls;
	Set Job	   alljs;

	String	headstr;
	String	str;
	Que	q;
	Set Que	allqs; 
	Int	ires;
	Size	sres;
	String	stres;
	String  sname;
	String  qname;
	String  jname;	
	String  cname;
	String  name;
	String  hstr;
	Float	f;
	DateTime dt;
	Int	 dtsecs;
	Que	 que;
	Que	 newq;
	Job	 job;
	Int	 res;
	DateTime d;
	Size	 sz;
	Set Que  sq;

	dt = datetimeGet();
	printDateTime(NULLSTR, "datetimeGet", NULLSTR, dt);
	dtsecs = datetimeToSecs(dt);
	printInt(NULLSTR, "datetimeToSecs", NULLSTR, dtsecs);
	
	alls = AllServersGet();
	shead = AllServersHeadGet();

	k = 1;
	foreach(s in alls) {
		if( k EQ 1 ) {
			if( ServerInetAddrGet(s) EQ ServerInetAddrGet(shead) ) {
				printStr(NULLSTR, "AllServersHeadGet", NULLSTR,
                                                               "passed");
			} else {
				printStr(NULLSTR, "AllServersHeadGet", NULLSTR,
                                                               "failed");
			}
		}
		str = ServerInetAddrGet(s) ;
		sname = str;
		printStr(sname, "ServerInetAddrGet", NULLSTR, str);
	
		str = ServerDefQueGet(s) ;
		printStr(sname, "ServerDefQueGet", NULLSTR, str);
	
		i = ServerStateGet(s) ;
		switch(i) {
	  	case SERVER_ACTIVE:
			{
				printStr(sname, "ServerStateGet",
                                                     NULLSTR, "Active");
			}
	  	case SERVER_IDLE:
			{
				printStr(sname, "ServerStateGet",
                                                     NULLSTR, "Idle");
			}
	  	case SERVER_SCHED:
			{
				printStr(sname, "ServerStateGet",
                                                 NULLSTR, "Scheduling");
			}
	  	case SERVER_TERM:
			{
				printStr(sname, "ServerStateGet",
                                                NULLSTR, "Terminating");
			}
	  	case SERVER_TERMDELAY:
			{
				printStr(sname, "ServerStateGet",
                                       NULLSTR, "Delayed Termination");
			}
	 	default:
			{
				printStr(sname, "ServerStateGet",
                                       NULLSTR, "Unknown Server state");
			}
		}
	
		i = ServerMaxRunJobsGet(s) ;
		printInt(sname, "ServerMaxRunJobsGet", NULLSTR, i);
							
		i = ServerMaxRunJobsPerUserGet(s);
		printInt(sname, "ServerMaxRunJobsPerUserGet",NULLSTR,i);
	
		i = ServerMaxRunJobsPerGroupGet(s);
		printInt(sname, "ServerMaxRunJobsPerGroupGet",NULLSTR,i);

		// the Avails
		ires = ServerIntResAvailGet(s, "cput");
		printInt(sname, "ServerIntResAvailGet", "cput", ires);

		ires = ServerIntResAvailGet(s, "pcput");
		printInt(sname, "ServerIntResAvailGet", "pcput", ires);

		ires = ServerIntResAvailGet(s, "walltime");
		printInt(sname, "ServerIntResAvailGet", "walltime", ires);

		ires = ServerIntResAvailGet(s, "mppt");
		printInt(sname, "ServerIntResAvailGet", "mppt", ires);

		ires = ServerIntResAvailGet(s, "pmppt");
		printInt(sname, "ServerIntResAvailGet", "pmppt", ires);

		ires = ServerIntResAvailGet(s, "nice");
		printInt(sname, "ServerIntResAvailGet", "nice", ires);

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

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

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

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

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

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

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

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

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

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

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

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

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

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



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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		// the ASSIGNS	
		ires = ServerIntResAssignGet(s, "cput");
		printInt(sname, "ServerIntResAssignGet", "cput", ires);

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

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

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

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

		ires = ServerIntResAssignGet(s, "nice");
		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);