Context Navigation

source: trunk/slurm_drmaa/util.c @ 34

Revision 34, 16.5 KB checked in by mmamonski, 11 years ago (diff)
Rorder parsing native specification: DRMAA attr after DRMAA conf
Property svn:executable set to ``* Property svn:keywords set to `Id`

Rev	Line
[1]	1	/*
	2	* PSNC DRMAA for SLURM
[13]	3	* Copyright (C) 2011 Poznan Supercomputing and Networking Center
[1]	4	*
	5	* This program is free software: you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License as published by
	7	* the Free Software Foundation, either version 3 of the License, or
	8	* (at your option) any later version.
	9	*
	10	* This program is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	* GNU General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU General Public License
	16	* along with this program. If not, see <http://www.gnu.org/licenses/>.
	17	*/
	18
	19	#include <drmaa_utils/common.h>
	20	#include <drmaa_utils/exception.h>
	21	#include <slurm_drmaa/util.h>
	22	#include <string.h>
	23
	24	#include <time.h>
	25	#include <drmaa_utils/datetime.h>
	26	#include <drmaa_utils/datetime_impl.h>
	27
	28	#ifndef lint
	29	static char rcsid[]
	30	# ifdef __GNUC__
	31	__attribute__ ((unused))
	32	# endif
[5]	33	= "$Id$";
[1]	34	#endif
	35
[24]	36	unsigned int
[1]	37	slurmdrmaa_datetime_parse( const char *string )
	38	{
	39	#ifdef DEBUGGING
	40	char dbg[256];
	41	#endif
	42	fsd_dt_parser_t *volatile parser = NULL;
	43	fsd_dt_lexer_t *volatile lexer = NULL;
	44	int parse_err = 0;
	45	fsd_datetime_t dt;
	46
	47	memset(&dt, 0, sizeof(fsd_datetime_t));
	48
	49	fsd_log_enter(( "(%s)", string ));
	50	TRY
	51	{
	52	fsd_malloc( parser, fsd_dt_parser_t );
	53	fsd_malloc( lexer, fsd_dt_lexer_t );
	54
	55	parser->lexer = lexer;
	56	parser->n_errors = 0;
	57	lexer->parser = parser;
	58	lexer->begin = lexer->p = (unsigned char*)string;
	59	lexer->end = (unsigned char*)( string + strlen(string) );
	60	parse_err = fsd_dt_parse( parser, lexer );
	61	if( parse_err \|\| parser->n_errors )
	62	fsd_exc_raise_fmt(
	63	FSD_ERRNO_INVALID_VALUE_FORMAT,
	64	"invalid date/time format: %s", string
	65	);
	66
	67	dt = parser->result;
	68	#ifdef DEBUGGING
	69	fsd_datetime_dump( &dt, dbg, sizeof(dbg) );
	70	fsd_log_debug(( "parsed: %s", dbg ));
	71	#endif
	72	}
	73	FINALLY
	74	{
	75	fsd_free( parser );
	76	fsd_free( lexer );
	77	}
	78	END_TRY
	79
[24]	80	fsd_log_return(( "(%s) =%u minutes", string, (unsigned)60*dt.hour+dt.minute ));
[1]	81	return 60*dt.hour+dt.minute;
	82	}
	83
[28]	84	/* taken from SLURM src/common/proc_args.c */
	85	static int slurmdrmaa_mail_type_parse(const char *mail_type_str)
	86	{
	87	int rc = 0;
	88
	89
	90	if (strcasecmp(mail_type_str, "BEGIN") == 0)
	91	rc = MAIL_JOB_BEGIN;
	92	else if (strcasecmp(mail_type_str, "END") == 0)
	93	rc = MAIL_JOB_END;
	94	else if (strcasecmp(mail_type_str, "FAIL") == 0)
	95	rc = MAIL_JOB_FAIL;
[29]	96	#if SLURM_VERSION_NUMBER >= SLURM_VERSION_NUM(2,2,0)
[28]	97	else if (strcasecmp(mail_type_str, "REQUEUE") == 0)
	98	rc = MAIL_JOB_REQUEUE;
[29]	99	#endif
[28]	100	else if (strcasecmp(mail_type_str, "ALL") == 0)
[29]	101	#if SLURM_VERSION_NUMBER >= SLURM_VERSION_NUM(2,2,0)
[28]	102	rc = MAIL_JOB_BEGIN \| MAIL_JOB_END \| MAIL_JOB_FAIL \| MAIL_JOB_REQUEUE;
[29]	103	#else
	104	rc = MAIL_JOB_BEGIN \| MAIL_JOB_END \| MAIL_JOB_FAIL;
	105	#endif
	106	else {
	107	fsd_log_error(("Unknown mail type: %s", mail_type_str));
	108	}
[28]	109
	110	return rc;
	111	}
	112
	113
[1]	114	enum slurm_native {
	115	SLURM_NATIVE_ACCOUNT,
	116	SLURM_NATIVE_ACCTG_FREQ,
	117	SLURM_NATIVE_COMMENT,
	118	SLURM_NATIVE_CONSTRAINT,
	119	SLURM_NATIVE_CONTIGUOUS,
	120	SLURM_NATIVE_EXCLUSIVE,
	121	SLURM_NATIVE_MEM,
	122	SLURM_NATIVE_MEM_PER_CPU,
	123	SLURM_NATIVE_MINCPUS,
	124	SLURM_NATIVE_NODELIST,
	125	SLURM_NATIVE_NODES,
	126	SLURM_NATIVE_NTASKS_PER_NODE,
	127	SLURM_NATIVE_PARTITION,
	128	SLURM_NATIVE_QOS,
	129	SLURM_NATIVE_REQUEUE,
	130	SLURM_NATIVE_RESERVATION,
[18]	131	SLURM_NATIVE_SHARE,
[19]	132	SLURM_NATIVE_JOB_NAME,
[24]	133	SLURM_NATIVE_TIME_LIMIT,
[28]	134	SLURM_NATIVE_NTASKS,
	135	SLURM_NATIVE_GRES,
	136	SLURM_NATIVE_NO_KILL,
	137	SLURM_NATIVE_LICENSES,
	138	SLURM_NATIVE_MAIL_TYPE,
	139	SLURM_NATIVE_NO_REQUEUE,
[30]	140	SLURM_NATIVE_EXCLUDE,
	141	SLURM_NATIVE_TMP
[1]	142	};
	143
	144	void
	145	slurmdrmaa_init_job_desc(job_desc_msg_t *job_desc)
	146	{
	147	memset(job_desc, 0, sizeof(job_desc_msg_t));
	148	}
	149
	150	void
	151	slurmdrmaa_free_job_desc(job_desc_msg_t *job_desc)
	152	{
	153	unsigned i = 0;
	154	fsd_log_enter(( "" ));
	155	fsd_free(job_desc->account);
	156	fsd_free(job_desc->comment);
	157
	158	for(i = 0;i<job_desc->env_size;i++)
	159	{
	160	fsd_free(job_desc->environment[i]);
	161	}
	162	fsd_free(job_desc->environment);
	163	fsd_free(job_desc->features);
	164	fsd_free(job_desc->name);
	165	fsd_free(job_desc->mail_user);
	166	fsd_free(job_desc->partition);
	167	fsd_free(job_desc->qos);
	168	fsd_free(job_desc->script);
	169	fsd_free(job_desc->std_in);
	170	fsd_free(job_desc->std_out);
	171	fsd_free(job_desc->std_err);
	172	fsd_free(job_desc->work_dir);
[29]	173	fsd_free(job_desc->exc_nodes);
	174	#if SLURM_VERSION_NUMBER >= SLURM_VERSION_NUM(2,2,0)
[28]	175	fsd_free(job_desc->gres);
[29]	176	#endif
[1]	177
	178	fsd_log_return(( "" ));
	179	}
	180
	181	void
	182	slurmdrmaa_add_attribute(job_desc_msg_t job_desc, unsigned attr, const char value)
	183	{
	184	char * ptr = NULL;
	185	char * rest = NULL;
	186	char * token = NULL;
	187
	188	switch(attr)
	189	{
	190	case SLURM_NATIVE_ACCOUNT:
	191	fsd_free(job_desc->account);
	192	fsd_log_debug(("# account = %s",value));
	193	job_desc->account = fsd_strdup(value);
	194	break;
	195	case SLURM_NATIVE_ACCTG_FREQ:
	196	fsd_log_debug(("# acctg_freq = %s",value));
	197	job_desc->acctg_freq = fsd_atoi(value);
	198	break;
	199	case SLURM_NATIVE_COMMENT:
	200	fsd_free(job_desc->comment);
	201	fsd_log_debug(("# comment = %s",value));
	202	job_desc->comment = fsd_strdup(value);
	203	break;
	204	case SLURM_NATIVE_CONSTRAINT:
	205	fsd_free(job_desc->features);
	206	fsd_log_debug(("# constraints -> features = %s",value));
	207	job_desc->features = fsd_strdup(value);
	208	break;
	209	case SLURM_NATIVE_CONTIGUOUS:
	210	fsd_log_debug(( "# contiguous = 1"));
	211	job_desc->contiguous = 1;
	212	break;
	213	case SLURM_NATIVE_EXCLUSIVE:
	214	fsd_log_debug(( "# exclusive -> shared = 0"));
	215	job_desc->shared = 0;
	216	break;
	217	case SLURM_NATIVE_MEM:
[13]	218	#if SLURM_VERSION_NUMBER < SLURM_VERSION_NUM(2,2,0)
[1]	219	if(job_desc->job_min_memory == NO_VAL \|\| fsd_atoi(value) > (int)job_desc->job_min_memory) {
	220	fsd_log_debug(("# job_min_memory = %s",value));
	221	job_desc->job_min_memory = fsd_atoi(value);
	222	}
[13]	223	#else
	224	if(job_desc->pn_min_memory == NO_VAL \|\| fsd_atoi(value) > (int)job_desc->pn_min_memory) {
	225	fsd_log_debug(("# pn_min_memory = %s",value));
	226	job_desc->pn_min_memory = fsd_atoi(value);
	227	}
	228	#endif
	229	else {
[1]	230	fsd_log_debug(("mem value defined lower or equal to mem-per-cpu or value defined before"));
	231	}
	232	break;
	233	case SLURM_NATIVE_MEM_PER_CPU:
[13]	234	#if SLURM_VERSION_NUMBER < SLURM_VERSION_NUM(2,2,0)
[1]	235	if(job_desc->job_min_memory == NO_VAL \|\| fsd_atoi(value) > (int)job_desc->job_min_memory) {
	236	fsd_log_debug(("# job_min_memory = %s",value));
	237	job_desc->job_min_memory = fsd_atoi(value);
	238	}
[13]	239	#else
	240	if(job_desc->pn_min_memory == NO_VAL \|\| fsd_atoi(value) > (int)job_desc->pn_min_memory) {
[31]	241	fsd_log_debug(("# pn_min_memory (MEM_PER_CPU) = %s",value));
	242	job_desc->pn_min_memory = fsd_atoi(value) \| MEM_PER_CPU;
[13]	243	}
	244	#endif
	245	else {
[1]	246	fsd_log_debug(("mem-per-cpu value defined lower or equal to mem or value defined before"));
	247	}
	248	break;
	249	case SLURM_NATIVE_MINCPUS:
[13]	250	#if SLURM_VERSION_NUMBER < SLURM_VERSION_NUM(2,2,0)
[1]	251	fsd_log_debug(("# job_min_cpus = %s",value));
	252	job_desc->job_min_cpus = fsd_atoi(value);
[13]	253	#else
	254	fsd_log_debug(("# min_cpus = %s",value));
	255	job_desc->min_cpus = fsd_atoi(value);
	256	#endif
[1]	257	break;
	258	case SLURM_NATIVE_NODELIST:
	259	fsd_free(job_desc->req_nodes);
	260	fsd_log_debug(("# node-list - > req_nodes = %s",value));
	261	job_desc->req_nodes = fsd_strdup(value);
	262	break;
	263	case SLURM_NATIVE_NODES:
	264	ptr = strdup(value);
[24]	265
[1]	266	if((token = strtok_r(ptr,"=",&rest)) == NULL){
	267	fsd_log_error(("strtok_r returned NULL"));
	268	}
	269
	270	fsd_log_debug(("nodes: %s ->",value));
	271	fsd_log_debug(("# min_nodes = %s",token));
	272	job_desc->min_nodes = fsd_atoi(token);
	273
	274	if(strcmp(rest,"") !=0 ) {
	275	fsd_log_debug(("# max_nodes = %s",rest));
	276	job_desc->max_nodes = fsd_atoi(rest);
	277	}
	278	fsd_free(ptr);
	279	break;
	280	case SLURM_NATIVE_NTASKS_PER_NODE:
	281	fsd_log_debug(("# ntasks_per_node = %s",value));
	282	job_desc->ntasks_per_node = fsd_atoi(value);
	283	break;
	284	case SLURM_NATIVE_PARTITION:
	285	fsd_free(job_desc->partition);
	286	fsd_log_debug(("# partition = %s",value));
	287	job_desc->partition = fsd_strdup(value);
	288	break;
	289	case SLURM_NATIVE_QOS:
	290	fsd_free(job_desc->qos);
	291	fsd_log_debug(("# qos = %s",value));
	292	job_desc->qos = fsd_strdup(value);
	293	break;
	294	case SLURM_NATIVE_REQUEUE:
	295	fsd_log_debug(( "# requeue = 1"));
	296	job_desc->requeue = 1;
	297	break;
	298	case SLURM_NATIVE_RESERVATION:
	299	fsd_log_debug(("# reservation = %s",value));
	300	job_desc->reservation = fsd_strdup(value);
	301	break;
	302	case SLURM_NATIVE_SHARE:
	303	fsd_log_debug(("# shared = 1"));
	304	job_desc->shared = 1;
	305	break;
[18]	306	case SLURM_NATIVE_JOB_NAME:
[24]	307	fsd_log_debug(("# job_name = %s",job_desc->name));
	308	job_desc->name = fsd_strdup(value);
[18]	309	break;
[24]	310	case SLURM_NATIVE_NTASKS:
	311	fsd_log_debug(("# ntasks = %s",value));
	312	job_desc->num_tasks = fsd_atoi(value);
	313	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_MINCPUS,value);
	314	break;
	315	case SLURM_NATIVE_TIME_LIMIT:
	316	fsd_log_debug(("# time_limit = %s",value));
	317	job_desc->time_limit = slurmdrmaa_datetime_parse(value);
	318	break;
[28]	319	case SLURM_NATIVE_GRES:
[29]	320	#if SLURM_VERSION_NUMBER >= SLURM_VERSION_NUM(2,2,0)
[28]	321	fsd_log_debug(("# gres = %s",value));
	322	job_desc->gres = fsd_strdup(value);
[29]	323	#else
	324	fsd_log_error(("GRES not supported in this version of SLURM."));
	325	#endif
[28]	326	break;
	327	case SLURM_NATIVE_NO_KILL:
	328	fsd_log_debug(("# no_kill = 1"));
	329	job_desc->kill_on_node_fail = 0;
	330	break;
	331	case SLURM_NATIVE_LICENSES:
	332	fsd_log_debug(("# licenses = %s", value));
	333	job_desc->licenses = fsd_strdup(value);
	334	break;
	335	case SLURM_NATIVE_MAIL_TYPE:
	336	fsd_log_debug(("# mail_type = %s", value));
	337	job_desc->mail_type = slurmdrmaa_mail_type_parse(value);
	338	break;
	339	case SLURM_NATIVE_NO_REQUEUE:
	340	fsd_log_debug(("# requeue = 0"));
	341	job_desc->requeue = 0;
	342	break;
	343	case SLURM_NATIVE_EXCLUDE:
	344	fsd_log_debug(("# exclude = %s", value));
	345	job_desc->exc_nodes = fsd_strdup(value);
	346	break;
[30]	347	case SLURM_NATIVE_TMP:
	348	fsd_log_debug(("# tmp = %s", value));
[32]	349	#if SLURM_VERSION_NUMBER >= SLURM_VERSION_NUM(2,3,0)
	350	job_desc->pn_min_tmp_disk = fsd_atoi(value);
	351	#else
	352	job_desc->job_min_tmp_disk = fsd_atoi(value);
	353	#endif
[30]	354	break;
[1]	355	default:
	356	fsd_exc_raise_fmt(FSD_DRMAA_ERRNO_INVALID_ATTRIBUTE_VALUE,"Invalid attribute");
	357	}
	358	}
	359
	360	void
	361	slurmdrmaa_parse_additional_attr(job_desc_msg_t job_desc,const char add_attr)
	362	{
	363	char * volatile name = NULL;
	364	char *value = NULL;
	365	char *ctxt = NULL;
	366	char * volatile add_attr_copy = fsd_strdup(add_attr);
	367
	368	TRY
	369	{
	370	name = fsd_strdup(strtok_r(add_attr_copy, "=", &ctxt));
	371	value = strtok_r(NULL, "=", &ctxt);
[28]	372	/*
	373	* TODO: move it to slurmdrmaa_add_attribute
	374	if (value == NULL) {
[24]	375	fsd_exc_raise_fmt(FSD_DRMAA_ERRNO_INVALID_ATTRIBUTE_VALUE,
	376	"Invalid native specification: %s Missing '='.", add_attr_copy);
[28]	377	} */
[24]	378
[1]	379	if(strcmp(name,"account") == 0) {
	380	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_ACCOUNT,value);
	381	}
	382	else if(strcmp(name,"acctg-freq") == 0) {
	383	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_ACCTG_FREQ,value);
	384	}
	385	else if (strcmp(name,"comment") == 0) {
	386	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_COMMENT,value);
	387	}
	388	else if (strcmp(name,"constraint") == 0) {
	389	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_CONSTRAINT,value);
	390	}
	391	else if (strcmp(name,"contiguous") == 0) {
	392	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_CONTIGUOUS,NULL);
	393	}
	394	else if(strcmp(name,"exclusive") == 0) {
	395	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_EXCLUSIVE,NULL);
	396	}
	397	else if (strcmp(name,"mem") == 0) {
	398	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_MEM,value);
	399	}
	400	else if (strcmp(name,"mem-per-cpu") == 0) {
	401	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_MEM_PER_CPU,value);
	402	}
	403	else if (strcmp(name,"mincpus") == 0) {
	404	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_MINCPUS,value);
	405	}
	406	else if (strcmp(name,"nodelist") == 0) {
	407	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_NODELIST,value);
	408	}
	409	else if (strcmp(name,"nodes") == 0) {
	410	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_NODES,value);
	411	}
	412	else if (strcmp(name,"ntasks-per-node") == 0) {
	413	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_NTASKS_PER_NODE,value);
	414	}
	415	else if (strcmp(name,"partition") == 0) {
	416	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_PARTITION,value);
	417	}
	418	else if (strcmp(name,"qos") == 0) {
	419	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_QOS,value);
	420	}
	421	else if (strcmp(name,"requeue") == 0) {
	422	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_REQUEUE,NULL);
	423	}
	424	else if (strcmp(name,"reservation") == 0) {
	425	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_RESERVATION,value);
	426	}
	427	else if (strcmp(name,"share") == 0) {
	428	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_SHARE,NULL);
	429	}
[28]	430	else if(strcmp(name,"job_name") == 0) {
	431	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_JOB_NAME,value);
	432	}
	433	else if(strcmp(name,"time_limit") == 0) {
	434	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_TIME_LIMIT,value);
	435	}
[22]	436	else if(strcmp(name,"time") == 0) {
[28]	437	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_TIME_LIMIT,value);
	438	}
	439	else if(strcmp(name,"ntasks") == 0) {
	440	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_NTASKS,value);
	441	}
	442	else if(strcmp(name,"gres") == 0) {
	443	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_GRES,value);
	444	}
	445	else if(strcmp(name,"no-kill") == 0) {
	446	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_NO_KILL,NULL);
	447	}
	448	else if(strcmp(name,"licenses") == 0) {
	449	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_LICENSES,value);
	450	}
	451	else if(strcmp(name,"mail-type") == 0) {
	452	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_MAIL_TYPE,value);
	453	}
	454	else if(strcmp(name,"no-requeue") == 0) {
	455	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_NO_REQUEUE,NULL);
	456	}
	457	else if(strcmp(name,"exclude") == 0) {
	458	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_EXCLUDE,value);
	459	}
[30]	460	else if(strcmp(name,"tmp") == 0) {
	461	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_TMP,value);
	462	} else {
[1]	463	fsd_exc_raise_fmt(FSD_DRMAA_ERRNO_INVALID_ATTRIBUTE_VALUE,
	464	"Invalid native specification: %s (Unsupported option: --%s)",
	465	add_attr, name);
	466	}
	467
	468	}
	469	FINALLY
	470	{
	471	fsd_free(name);
	472	fsd_free(add_attr_copy);
	473	}
	474	END_TRY
	475	}
	476
	477	void
	478	slurmdrmaa_parse_native(job_desc_msg_t job_desc, const char value)
	479	{
	480	char *arg = NULL;
	481	char * volatile native_specification = fsd_strdup(value);
	482	char * volatile native_spec_copy = fsd_strdup(native_specification);
	483	char * ctxt = NULL;
	484	int opt = 0;
	485
	486	fsd_log_enter(( "" ));
	487	TRY
	488	{
	489	for (arg = strtok_r(native_spec_copy, " \t", &ctxt); arg; arg = strtok_r(NULL, " \t",&ctxt) ) {
	490	if (!opt) {
	491	if ( (arg[0] != '-') \|\| ((strlen(arg) != 2) && (strlen(arg) > 2) && arg[2] != ' ' && arg[1] !='-' ) ) {
	492	fsd_exc_raise_fmt(FSD_DRMAA_ERRNO_INVALID_ATTRIBUTE_VALUE,
	493	"Invalid native specification: %s",
	494	native_specification);
	495	}
	496	if(arg[1] == '-') {
	497	slurmdrmaa_parse_additional_attr(job_desc, arg+2);
	498	}
	499	else {
	500	opt = arg[1];
	501	}
	502	} else {
[28]	503	switch (opt) {
[1]	504	case 'A' :
	505	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_ACCOUNT, arg);
	506	break;
	507	case 'C' :
	508	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_CONSTRAINT, arg);
	509	break;
	510	case 'N' :
	511	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_NODES, arg);
	512	break;
	513	case 'p' :
	514	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_PARTITION, arg);
	515	break;
	516	case 's' :
	517	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_SHARE, NULL);
[28]	518	break;
[1]	519	case 'w' :
	520	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_NODELIST, arg);
[18]	521	break;
	522	case 'J' :
	523	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_JOB_NAME, arg);
[28]	524	break;
[24]	525	case 't' :
	526	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_TIME_LIMIT, arg);
	527	break;
	528	case 'n' :
	529	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_NTASKS, arg);
	530	break;
[28]	531	case 'x' :
	532	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_EXCLUDE, arg);
	533	break;
[33]	534	case 'L' :
	535	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_LICENSES, arg);
	536	break;
[28]	537	default :
[1]	538	fsd_exc_raise_fmt(FSD_DRMAA_ERRNO_INVALID_ATTRIBUTE_VALUE,
	539	"Invalid native specification: %s (Unsupported option: -%c)",
	540	native_specification, opt);
	541	}
	542	if (arg[0] == '-' && strlen(arg) == 2) { /* attribute without arg */
	543	opt = arg[1];
	544	}
	545	else {
	546	opt = 0;
	547	}
	548	}
	549	}
	550
	551	if(strlen(native_spec_copy) == 2 && native_spec_copy[0] == '-' && native_spec_copy[1] == 's')
	552	{
	553	slurmdrmaa_add_attribute(job_desc, SLURM_NATIVE_SHARE, NULL);
	554	opt = 0;
	555	}
	556
	557	if (opt)
	558	fsd_exc_raise_fmt(FSD_DRMAA_ERRNO_INVALID_ATTRIBUTE_VALUE,
	559	"Invalid native specification: %s",
	560	native_specification);
	561
	562	}
	563	FINALLY
	564	{
	565	fsd_free(native_spec_copy);
	566	fsd_free(native_specification);
	567	}
	568	END_TRY
	569
	570	fsd_log_return(( "" ));
	571	}
	572

Note: See TracBrowser for help on using the repository browser.

Download in other formats: