<?xml version="1.0" encoding="UTF-8"?>
<pbs-job-attributes>
	<pbs-job-attribute name="Account_Name" minSet="true">
		<attribute-definition id="PBSJOB_Account_Name"
			type="string" display="true">
			<description>Account to which to charge this job.</description>
		</attribute-definition>
		<qsub-flag>-A </qsub-flag>
		<tooltip>Format: string</tooltip>
	</pbs-job-attribute>
	<pbs-job-attribute name="Checkpoint">
		<attribute-definition id="PBSJOB_Checkpoint"
			type="choice" display="true">
			<description>Determines when checkpointing (if supported) will be
				performed by PBS on behalf of the job.</description>
			<default>u</default>
		</attribute-definition>
		<choice>,u,n,s,c,c=????</choice>
		<qsub-flag>-c </qsub-flag>
		<tooltip>Format: the strings "n" (no checkpointing), "s" (to be
			performed only when the server executing the job is shutdown), "c"
			(to be performed at the default minimum time for the server executing
			the job), "c=mmmm" (to be performed at an interval of minutes which
			is the integer number of minutes of CPU time used by the job; value
			must be greater than zero); default value: "u", which is unspecified.
		</tooltip>
	</pbs-job-attribute>
	<pbs-job-attribute name="depend">
		<attribute-definition id="PBSJOB_depend" type="string"
			display="true">
			<description>The type of inter-job dependencies specified by the job
				owner.</description>
		</attribute-definition>
		<qsub-flag>-W depend=</qsub-flag>
		<tooltip>Format: "type:jobid[,jobid...]"; default value: no
			dependencies.</tooltip>
	</pbs-job-attribute>
	<pbs-job-attribute name="destination" minSet="true">
		<attribute-definition id="PBSJOB_destination"
			type="string" display="true">
			<description>Designation of the queue to which to submit the job.
			</description>
		</attribute-definition>
		<qsub-flag>-q </qsub-flag>
		<tooltip>Format: queue[@server].</tooltip>
	</pbs-job-attribute>
	<pbs-job-attribute name="directive">
		<attribute-definition id="PBSJOB_directive" type="string"
			display="true">
			<description>Defines the prefix that declares a directive to the qsub
				command within the script file.</description>
		</attribute-definition>
		<qsub-flag>-C </qsub-flag>
		<tooltip>See the paragraph on script directives in the Extended
			Description section. If the option is presented with a
			directive_prefix argument that is the null string, qsub will not scan
			the script file for directives.</tooltip>
	</pbs-job-attribute>
	<pbs-job-attribute name="Error_Path">
		<attribute-definition id="PBSJOB_Error_Path"
			type="string" display="true">
			<description>The final path name for the file containing the job's
				standard error stream.</description>
		</attribute-definition>
		<qsub-flag>-e </qsub-flag>
		<tooltip>Format: "[hostname:]pathname". If the option is not
			specified, the default file name for the standard error stream will
			be used. The default name has the following form: job_name.eSeq_num
			where job_name is the name of the job, see -N option, and Seq_num is
			the job number assigned when the job is submitted; default value:
			(job_name).e(job_number).</tooltip>
	</pbs-job-attribute>
	<pbs-job-attribute name="export_all" minSet="true">
		<attribute-definition id="PBSJOB_export_all"
			type="boolean" display="true">
			<description>Declares that all environment variables in the qsub
				command's environment are to be exported to the batch job.
			</description>
			<default>true</default>
		</attribute-definition>
		<qsub-flag>-V </qsub-flag>
	</pbs-job-attribute>
	<pbs-job-attribute name="group_list">
		<attribute-definition id="PBSJOB_group_list"
			type="string" display="true">
			<description>A list of group_names@hosts which determines the group
				under which the job is run on a given host.</description>
		</attribute-definition>
		<qsub-flag>-W group_list=</qsub-flag>
		<tooltip>Format: group_name[@host][,group_name[@host]...]. When a job
			is to be placed into execution, the server will select a group name
			according to the following ordered set of rules: 1) Select the group
			name from the list for which the associated host name matches the
			name of the execution host; 2) Select the group name which has no
			associated host name, the wildcard name; 3) Use the login group for
			the username under which the job will be run.</tooltip>
	</pbs-job-attribute>
	<pbs-job-attribute name="Hold_Types">
		<attribute-definition id="PBSJOB_Hold_Types"
			type="choice" display="true">
			<description>The set of holds currently applied to the job.
			</description>
		</attribute-definition>
		<choice>,u,s,o</choice>
		<qsub-flag>-h </qsub-flag>
		<tooltip>If the set is not null, the job will not be scheduled for
			execution and is said to be in the hold state. Note, the hold state
			takes precedence over the wait state. Format: string made up of the
			letters 'u', 's', 'o'; default value: no hold.</tooltip>
	</pbs-job-attribute>
	<pbs-job-attribute name="Job_Name" minSet="true">
		<attribute-definition id="PBSJOB_Job_Name" type="string"
			display="true">
			<description>The name assigned to the job by the qsub or qalter
				command.</description>
		</attribute-definition>
		<qsub-flag>-N </qsub-flag>
		<tooltip>Format: string up to 15 characters, first character must be
			alphabetic; default value: the base name of the job script or STDIN.
		</tooltip>
	</pbs-job-attribute>
	<pbs-job-attribute name="Join_Path">
		<attribute-definition id="PBSJOB_Join_Path" type="boolean"
			display="true">
			<description>Merge stdout and stderr into stdout.</description>
			<default>false</default>
		</attribute-definition>
		<qsub-flag>-j </qsub-flag>
		<tooltip>Format: boolean, values accepted are "True", "TRUE", "true",
			"Y", "y", "1", "False", "FALSE", "false", "N", "n", "0"; default
			value: false.</tooltip>
	</pbs-job-attribute>
	<pbs-job-attribute name="Keep_Files">
		<attribute-definition id="PBSJOB_Keep_Files"
			type="choice" display="true">
			<description>Retain these streams on the execution host upon job
				termination.</description>
		</attribute-definition>
		<choice>,o,e,oe,eo</choice>
		<qsub-flag>-k </qsub-flag>
		<tooltip>Format: "o", "e", "oe" or "eo"; default value: no keep,
			return files to submission host.</tooltip>
	</pbs-job-attribute>
	<pbs-job-attribute name="Mail_Points">
		<attribute-definition id="PBSJOB_Mail_Points"
			type="choice" display="true">
			<description>Identifies at which state changes the server will send
				mail about the job.</description>
			<default>a</default>
		</attribute-definition>
		<choice>,a,b</choice>
		<qsub-flag>-m </qsub-flag>
		<tooltip>Format: string made up of the letters 'a' for abort, 'b' for
			beginning, and default value: 'a', send on job abort.</tooltip>
	</pbs-job-attribute>
	<pbs-job-attribute name="Mail_Users">
		<attribute-definition id="PBSJOB_Mail_Users"
			type="string" display="true">
			<description>The set of users to whom mail may be sent when the job
				makes certain state changes.</description>
		</attribute-definition>
		<qsub-flag>-M </qsub-flag>
		<tooltip>Format: "user@host[,user@host]";
			default value: job owner
			only.</tooltip>
	</pbs-job-attribute>
	<pbs-job-attribute name="Output_Path">
		<attribute-definition id="PBSJOB_Output_Path"
			type="string" display="true">
			<description>The final path name for the file containing the job's
				standard output stream.</description>
		</attribute-definition>
		<qsub-flag>-o </qsub-flag>
		<tooltip>Format: "[hostname:]pathname". If the option is not
			specified, the default file name for the standard error stream will
			be used. The default name has the following form: job_name.oSeq_num
			where job_name is the name of the job, see -N option, and Seq_num is
			the job number assigned when the job is submitted; default value:
			(job_name).o(job_number). </tooltip>
	</pbs-job-attribute>
	<pbs-job-attribute name="Priority">
		<attribute-definition id="PBSJOB_Priority" type="string"
			display="true">
			<description>The job scheduling priority assigned by the user.
			</description>
		</attribute-definition>
		<qsub-flag>-p </qsub-flag>
		<tooltip>Format: "[+|-]nnnnn"; default value: undefined.</tooltip>
	</pbs-job-attribute>
	<pbs-job-attribute name="Rerunnable">
		<attribute-definition id="PBSJOB_Rerunnable"
			type="choice" display="true">
			<description>The rerunnable flag assigned by the user.</description>
			<default>y</default>
		</attribute-definition>
		<choice>,n,y</choice>
		<qsub-flag>-r </qsub-flag>
		<tooltip>Format: "y" or "n", see Join_Path; default value: y, job is
			rerunable.</tooltip>
	</pbs-job-attribute>
	<pbs-job-attribute name="Resource_List.arch">
		<attribute-definition id="PBSJOB_Resource_List.arch"
			type="string" display="true">
			<description>Specifies the administrator defined system architecture
				requried.</description>
		</attribute-definition>
		<qsub-flag>-l arch=</qsub-flag>
		<tooltip>This defaults to whatever the PBS_MACH string is set to in
			"local.mk". Units: string.</tooltip>
	</pbs-job-attribute>
	<pbs-job-attribute name="Resource_List.cput">
		<attribute-definition id="PBSJOB_Resource_List.cput"
			type="string" display="true">
			<description>Maximum amount of CPU time used by all processes in the
				job.</description>
		</attribute-definition>
		<qsub-flag>-l cput=</qsub-flag>
		<tooltip>Format: [[hours:]minutes:]seconds[.milliseconds].</tooltip>
	</pbs-job-attribute>
	<pbs-job-attribute name="Resource_List.file">
		<attribute-definition id="PBSJOB_Resource_List.file"
			type="string" display="true">
			<description>The largest size of any single file that may be created
				by the job.</description>
		</attribute-definition>
		<qsub-flag>-l file=</qsub-flag>
		<tooltip>Format: integer[suffix]; the suffix is a multiplier in bytes
			or words (word size of the host): b (bytes), w (words), kb/kw (kilo),
			mb/mw (mega), gb/bw (giga).</tooltip>
	</pbs-job-attribute>
	<pbs-job-attribute name="Resource_List.host">
		<attribute-definition id="PBSJOB_Resource_List.host"
			type="string" display="true">
			<description>Name of host on which job should be run.</description>
		</attribute-definition>
		<qsub-flag>-l host=</qsub-flag>
	</pbs-job-attribute>
	<pbs-job-attribute name="Resource_List.mem">
		<attribute-definition id="PBSJOB_Resource_List.mem"
			type="string" display="true">
			<description>Maximum amount of memory used by all concurrent
				processes in the job.</description>
		</attribute-definition>
		<qsub-flag>-l mem=</qsub-flag>
		<tooltip>Format: integer[suffix]; the suffix is a multiplier in bytes
			or words (word size of the host): b (bytes), w (words), kb/kw (kilo),
			mb/mw (mega), gb/bw (giga).</tooltip>
	</pbs-job-attribute>
	<pbs-job-attribute name="Resource_List.nice">
		<attribute-definition id="PBSJOB_Resource_List.nice"
			type="integer" display="true">
			<description>The nice value under which the job is to be run.
			</description>
			<default>0</default>
			<min>0</min>
			<max>10</max>
		</attribute-definition>
		<qsub-flag>-l nice=</qsub-flag>
		<tooltip>0 to 10.</tooltip>
	</pbs-job-attribute>
	<pbs-job-attribute name="Resource_List.nodes" minSet="true">
		<attribute-definition id="PBSJOB_Resource_List.nodes"
			type="string" display="true">
			<description>Number and/or type of nodes to be reserved for exclusive
				use by the job.</description>
			<default>1</default>
		</attribute-definition>
		<qsub-flag>-l nodes=</qsub-flag>
		<tooltip>The value is one or more node_specs joined with the '+'
			character, "node_spec[+node_spec...]. Each node_spec is a number of
			nodes required of the type declared in the node_spec and a name or
			one or more properity or properities desired for the nodes. The
			number, the name, and each properity in the node_spec are separated
			by a colon ':'. If no number is specified, one (1) is assumed. Units:
			string. The name of a node is its hostname. The properties of nodes
			are: ppn=# requested; defaults to 1; or an arbitrary string defined
			by system administrator. Example: To ask for 2 processors on each of
			two blue nodes and three processors on one red node: -l
			nodes=2:blue:ppn=2+red:ppn=3.</tooltip>
	</pbs-job-attribute>
	<pbs-job-attribute name="Resource_List.ompthreads">
		<attribute-definition id="PBSJOB_Resource_List.ompthreads"
			type="integer" display="true">
			<description>Number of threads per processor for Open MP jobs.
			</description>
			<default>1</default>
			<min>1</min>
		</attribute-definition>
		<qsub-flag>-l ompthreads=</qsub-flag>
	</pbs-job-attribute>
	<pbs-job-attribute name="Resource_List.pcput">
		<attribute-definition id="PBSJOB_Resource_List.pcput"
			type="string" display="true">
			<description>Maximum amount of CPU time used by any single process in
				the job.</description>
		</attribute-definition>
		<qsub-flag>-l pcput=</qsub-flag>
		<tooltip>Format: [[hours:]minutes:]seconds[.milliseconds].</tooltip>
	</pbs-job-attribute>
	<pbs-job-attribute name="Resource_List.pmem">
		<attribute-definition id="PBSJOB_Resource_List.pmem"
			type="string" display="true">
			<description>Maximum amount of physical memory (workingset) used by
				any single process of the job.</description>
		</attribute-definition>
		<qsub-flag>-l pmem=</qsub-flag>
		<tooltip>Format: integer[suffix]; the suffix is a multiplier in bytes
			or words (word size of the host): b (bytes), w (words), kb/kw (kilo),
			mb/mw (mega), gb/bw (giga).</tooltip>
	</pbs-job-attribute>
	<pbs-job-attribute name="Resource_List.pvmem">
		<attribute-definition id="PBSJOB_Resource_List.pvmem"
			type="string" display="true">
			<description>Maximum amount of virtual memory used by any single
				process in the job.</description>
		</attribute-definition>
		<qsub-flag>-l pvmem=</qsub-flag>
		<tooltip>Format: integer[suffix]; the suffix is a multiplier in bytes
			or words (word size of the host): b (bytes), w (words), kb/kw (kilo),
			mb/mw (mega), gb/bw (giga).</tooltip>
	</pbs-job-attribute>
	<pbs-job-attribute name="Resource_List.vmem">
		<attribute-definition id="PBSJOB_Resource_List.vmem"
			type="string" display="true">
			<description>Maximum amount of virtual memory used by all concurrent
				processes in the job.</description>
		</attribute-definition>
		<qsub-flag>-l vmem=</qsub-flag>
		<tooltip>Format: integer[suffix]; the suffix is a multiplier in bytes
			or words (word size of the host): b (bytes), w (words), kb/kw (kilo),
			mb/mw (mega), gb/bw (giga).</tooltip>
	</pbs-job-attribute>
	<pbs-job-attribute name="Resource_List.walltime" minSet="true">
		<attribute-definition id="PBSJOB_Resource_List.walltime"
			type="string" display="true">
			<description>Maximum amount of real time during which the job can be
				in the running state.</description>
			<default>00:30:00</default>
		</attribute-definition>
		<qsub-flag>-l walltime=</qsub-flag>
		<tooltip>Format: [[hours:]minutes:]seconds[.milliseconds].</tooltip>
	</pbs-job-attribute>
	<pbs-job-attribute name="Shell_Path_List">
		<attribute-definition id="PBSJOB_Shell_Path_List"
			type="string" display="true">
			<description>A set of absolute paths of the program to process the
				job's script file.</description>
		</attribute-definition>
		<qsub-flag>-S </qsub-flag>
		<tooltip>Format: path[@host][,path[@host]...]. If this is null, then
			the user's login shell on the host of execution will be used. Default
			value: null, login shell.</tooltip>
	</pbs-job-attribute>
	<pbs-job-attribute name="stagein">
		<attribute-definition id="PBSJOB_stagein" type="string"
			display="true">
			<description>The list of files to be staged in prior to job
				execution.</description>
		</attribute-definition>
		<qsub-flag>-W stagein=</qsub-flag>
		<tooltip>Format: local_path@remote_host:remote_path.</tooltip>
	</pbs-job-attribute>
	<pbs-job-attribute name="stageout">
		<attribute-definition id="PBSJOB_stageout" type="string"
			display="true">
			<description>The list of files to be staged out after job execution.
			</description>
		</attribute-definition>
		<qsub-flag>-W stageout=</qsub-flag>
		<tooltip>Format: local_path@remote_host:remote_path.</tooltip>
	</pbs-job-attribute>
	<pbs-job-attribute name="User_List">
		<attribute-definition id="PBSJOB_User_List" type="string"
			display="true">
			<description>The list of user@hosts which determines the user name
				under which the job is run on a given host.</description>
		</attribute-definition>
		<qsub-flag>-u </qsub-flag>
		<tooltip>When a job is to be placed into execution, the server will
			select a user name from the list according to the following ordered
			set of rules: 1) Select the user name from the list for which the
			associated host name matches the name of the execution host; 2)
			Select the user name which has no associated host name, the wild card
			name; 3) Use the Job_Owner as the user name. Default value: job owner
			name.
      </tooltip>
	</pbs-job-attribute>
	<pbs-job-attribute name="Variable_List">
		<attribute-definition id="PBSJOB_Variable_List"
			type="string" display="true">
			<description>This is the list of environment variables passed with
				the Queue Job batch request.</description>
		</attribute-definition>
		<qsub-flag>-v </qsub-flag>
	</pbs-job-attribute>
</pbs-job-attributes>