Context Navigation

source: trunk/slurm_drmaa/util.c @ 35

Revision 35, 17.4 KB checked in by pkopta, 11 years ago (diff)
Michael Gutteridge <michael.gutteridge@…> patch for "mincpus" calculations.
Property svn:executable set to ``* Property svn:keywords set to `Id`

Line
1	/*
2	* PSNC DRMAA for SLURM
3	* Copyright (C) 2011 Poznan Supercomputing and Networking Center
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
33	= "$Id$";
34	#endif
35
36	unsigned int
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
80	fsd_log_return(( "(%s) =%u minutes", string, (unsigned)60*dt.hour+dt.minute ));
81	return 60*dt.hour+dt.minute;
82	}
83
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;
96	#if SLURM_VERSION_NUMBER >= SLURM_VERSION_NUM(2,2,0)
97	else if (strcasecmp(mail_type_str, "REQUEUE") == 0)
98	rc = MAIL_JOB_REQUEUE;
99	#endif
100	else if (strcasecmp(mail_type_str, "ALL") == 0)
101	#if SLURM_VERSION_NUMBER >= SLURM_VERSION_NUM(2,2,0)
102	rc = MAIL_JOB_BEGIN \| MAIL_JOB_END \| MAIL_JOB_FAIL \| MAIL_JOB_REQUEUE;
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	}
109
110	return rc;
111	}
112
113
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_CPUS_PER_TASK,
121	SLURM_NATIVE_EXCLUSIVE,
122	SLURM_NATIVE_MEM,
123	SLURM_NATIVE_MEM_PER_CPU,
124	SLURM_NATIVE_MINCPUS,
125	SLURM_NATIVE_NODELIST,
126	SLURM_NATIVE_NODES,
127	SLURM_NATIVE_NTASKS_PER_NODE,
128	SLURM_NATIVE_PARTITION,
129	SLURM_NATIVE_QOS,
130	SLURM_NATIVE_REQUEUE,
131	SLURM_NATIVE_RESERVATION,
132	SLURM_NATIVE_SHARE,
133	SLURM_NATIVE_JOB_NAME,
134	SLURM_NATIVE_TIME_LIMIT,
135	SLURM_NATIVE_NTASKS,
136	SLURM_NATIVE_GRES,
137	SLURM_NATIVE_NO_KILL,
138	SLURM_NATIVE_LICENSES,
139	SLURM_NATIVE_MAIL_TYPE,
140	SLURM_NATIVE_NO_REQUEUE,
141	SLURM_NATIVE_EXCLUDE,
142	SLURM_NATIVE_TMP
143	};
144
145	void
146	slurmdrmaa_init_job_desc(job_desc_msg_t *job_desc)
147	{
148	memset(job_desc, 0, sizeof(job_desc_msg_t));
149	}
150
151	void
152	slurmdrmaa_free_job_desc(job_desc_msg_t *job_desc)
153	{
154	unsigned i = 0;
155	fsd_log_enter(( "" ));
156	fsd_free(job_desc->account);
157	fsd_free(job_desc->comment);
158
159	for(i = 0;i<job_desc->env_size;i++)
160	{
161	fsd_free(job_desc->environment[i]);
162	}
163	fsd_free(job_desc->environment);
164	fsd_free(job_desc->features);
165	fsd_free(job_desc->name);
166	fsd_free(job_desc->mail_user);
167	fsd_free(job_desc->partition);
168	fsd_free(job_desc->qos);
169	fsd_free(job_desc->script);
170	fsd_free(job_desc->std_in);
171	fsd_free(job_desc->std_out);
172	fsd_free(job_desc->std_err);
173	fsd_free(job_desc->work_dir);
174	fsd_free(job_desc->exc_nodes);
175	#if SLURM_VERSION_NUMBER >= SLURM_VERSION_NUM(2,2,0)
176	fsd_free(job_desc->gres);
177	#endif
178
179	fsd_log_return(( "" ));
180	}
181
182	void
183	slurmdrmaa_add_attribute(job_desc_msg_t job_desc, unsigned attr, const char value)
184	{
185	char * ptr = NULL;
186	char * rest = NULL;
187	char * token = NULL;
188
189	switch(attr)
190	{
191	case SLURM_NATIVE_ACCOUNT:
192	fsd_free(job_desc->account);
193	fsd_log_debug(("# account = %s",value));
194	job_desc->account = fsd_strdup(value);
195	break;
196	case SLURM_NATIVE_ACCTG_FREQ:
197	fsd_log_debug(("# acctg_freq = %s",value));
198	job_desc->acctg_freq = fsd_atoi(value);
199	break;
200	case SLURM_NATIVE_COMMENT:
201	fsd_free(job_desc->comment);
202	fsd_log_debug(("# comment = %s",value));
203	job_desc->comment = fsd_strdup(value);
204	break;
205	case SLURM_NATIVE_CONSTRAINT:
206	fsd_free(job_desc->features);
207	fsd_log_debug(("# constraints -> features = %s",value));
208	job_desc->features = fsd_strdup(value);
209	break;
210	case SLURM_NATIVE_CONTIGUOUS:
211	fsd_log_debug(( "# contiguous = 1"));
212	job_desc->contiguous = 1;
213	break;
214	case SLURM_NATIVE_CPUS_PER_TASK:
215	fsd_log_debug(( "# cpus_per_task = %s", value));
216	job_desc->cpus_per_task = fsd_atoi(value);
217	break;
218	case SLURM_NATIVE_EXCLUSIVE:
219	fsd_log_debug(( "# exclusive -> shared = 0"));
220	job_desc->shared = 0;
221	break;
222	case SLURM_NATIVE_MEM:
223	#if SLURM_VERSION_NUMBER < SLURM_VERSION_NUM(2,2,0)
224	if(job_desc->job_min_memory == NO_VAL \|\| fsd_atoi(value) > (int)job_desc->job_min_memory) {
225	fsd_log_debug(("# job_min_memory = %s",value));
226	job_desc->job_min_memory = fsd_atoi(value);
227	}
228	#else
229	if(job_desc->pn_min_memory == NO_VAL \|\| fsd_atoi(value) > (int)job_desc->pn_min_memory) {
230	fsd_log_debug(("# pn_min_memory = %s",value));
231	job_desc->pn_min_memory = fsd_atoi(value);
232	}
233	#endif
234	else {
235	fsd_log_debug(("mem value defined lower or equal to mem-per-cpu or value defined before"));
236	}
237	break;
238	case SLURM_NATIVE_MEM_PER_CPU:
239	#if SLURM_VERSION_NUMBER < SLURM_VERSION_NUM(2,2,0)
240	if(job_desc->job_min_memory == NO_VAL \|\| fsd_atoi(value) > (int)job_desc->job_min_memory) {
241	fsd_log_debug(("# job_min_memory = %s",value));
242	job_desc->job_min_memory = fsd_atoi(value);
243	}
244	#else
245	if(job_desc->pn_min_memory == NO_VAL \|\| fsd_atoi(value) > (int)job_desc->pn_min_memory) {
246	fsd_log_debug(("# pn_min_memory (MEM_PER_CPU) = %s",value));
247	job_desc->pn_min_memory = fsd_atoi(value) \| MEM_PER_CPU;
248	}
249	#endif
250	else {
251	fsd_log_debug(("mem-per-cpu value defined lower or equal to mem or value defined before"));
252	}
253	break;
254	case SLURM_NATIVE_MINCPUS:
255	#if SLURM_VERSION_NUMBER < SLURM_VERSION_NUM(2,2,0)
256	fsd_log_debug(("# job_min_cpus = %s",value));
257	job_desc->job_min_cpus = fsd_atoi(value);
258	#else
259	fsd_log_debug(("# pn_min_cpus = %s",value));
260	job_desc->pn_min_cpus = fsd_atoi(value);
261	#endif
262	break;
263	case SLURM_NATIVE_NODELIST:
264	fsd_free(job_desc->req_nodes);
265	fsd_log_debug(("# node-list - > req_nodes = %s",value));
266	job_desc->req_nodes = fsd_strdup(value);
267	break;
268	case SLURM_NATIVE_NODES:
269	ptr = strdup(value);
270
271	if((token = strtok_r(ptr,"=",&rest)) == NULL){
272	fsd_log_error(("strtok_r returned NULL"));
273	}
274
275	fsd_log_debug(("nodes: %s ->",value));
276	fsd_log_debug(("# min_nodes = %s",token));
277	job_desc->min_nodes = fsd_atoi(token);
278
279	if(strcmp(rest,"") !=0 ) {
280	fsd_log_debug(("# max_nodes = %s",rest));
281	job_desc->max_nodes = fsd_atoi(rest);
282	}
283	fsd_free(ptr);
284	break;
285	case SLURM_NATIVE_NTASKS_PER_NODE:
286	fsd_log_debug(("# ntasks_per_node = %s",value));
287	job_desc->ntasks_per_node = fsd_atoi(value);
288	break;
289	case SLURM_NATIVE_PARTITION:
290	fsd_free(job_desc->partition);
291	fsd_log_debug(("# partition = %s",value));
292	job_desc->partition = fsd_strdup(value);
293	break;
294	case SLURM_NATIVE_QOS:
295	fsd_free(job_desc->qos);
296	fsd_log_debug(("# qos = %s",value));
297	job_desc->qos = fsd_strdup(value);
298	break;
299	case SLURM_NATIVE_REQUEUE:
300	fsd_log_debug(( "# requeue = 1"));
301	job_desc->requeue = 1;
302	break;
303	case SLURM_NATIVE_RESERVATION:
304	fsd_log_debug(("# reservation = %s",value));
305	job_desc->reservation = fsd_strdup(value);
306	break;
307	case SLURM_NATIVE_SHARE:
308	fsd_log_debug(("# shared = 1"));
309	job_desc->shared = 1;
310	break;
311	case SLURM_NATIVE_JOB_NAME:
312	fsd_log_debug(("# job_name = %s",job_desc->name));
313	job_desc->name = fsd_strdup(value);
314	break;
315	case SLURM_NATIVE_NTASKS:
316	fsd_log_debug(("# ntasks = %s",value));
317	job_desc->num_tasks = fsd_atoi(value);
318	break;
319	case SLURM_NATIVE_TIME_LIMIT:
320	fsd_log_debug(("# time_limit = %s",value));
321	job_desc->time_limit = slurmdrmaa_datetime_parse(value);
322	break;
323	case SLURM_NATIVE_GRES:
324	#if SLURM_VERSION_NUMBER >= SLURM_VERSION_NUM(2,2,0)
325	fsd_log_debug(("# gres = %s",value));
326	job_desc->gres = fsd_strdup(value);
327	#else
328	fsd_log_error(("GRES not supported in this version of SLURM."));
329	#endif
330	break;
331	case SLURM_NATIVE_NO_KILL:
332	fsd_log_debug(("# no_kill = 1"));
333	job_desc->kill_on_node_fail = 0;
334	break;
335	case SLURM_NATIVE_LICENSES:
336	fsd_log_debug(("# licenses = %s", value));
337	job_desc->licenses = fsd_strdup(value);
338	break;
339	case SLURM_NATIVE_MAIL_TYPE:
340	fsd_log_debug(("# mail_type = %s", value));
341	job_desc->mail_type = slurmdrmaa_mail_type_parse(value);
342	break;
343	case SLURM_NATIVE_NO_REQUEUE:
344	fsd_log_debug(("# requeue = 0"));
345	job_desc->requeue = 0;
346	break;
347	case SLURM_NATIVE_EXCLUDE:
348	fsd_log_debug(("# exclude = %s", value));
349	job_desc->exc_nodes = fsd_strdup(value);
350	break;
351	case SLURM_NATIVE_TMP:
352	fsd_log_debug(("# tmp = %s", value));
353	#if SLURM_VERSION_NUMBER >= SLURM_VERSION_NUM(2,3,0)
354	job_desc->pn_min_tmp_disk = fsd_atoi(value);
355	#else
356	job_desc->job_min_tmp_disk = fsd_atoi(value);
357	#endif
358	break;
359	default:
360	fsd_exc_raise_fmt(FSD_DRMAA_ERRNO_INVALID_ATTRIBUTE_VALUE,"Invalid attribute");
361	}
362	}
363
364	void
365	slurmdrmaa_parse_additional_attr(job_desc_msg_t job_desc,const char add_attr)
366	{
367	char * volatile name = NULL;
368	char *value = NULL;
369	char *ctxt = NULL;
370	char * volatile add_attr_copy = fsd_strdup(add_attr);
371
372	fsd_log_enter(( "" ));
373
374	TRY
375	{
376	name = fsd_strdup(strtok_r(add_attr_copy, "=", &ctxt));
377	value = strtok_r(NULL, "=", &ctxt);
378	/*
379	* TODO: move it to slurmdrmaa_add_attribute
380	if (value == NULL) {
381	fsd_exc_raise_fmt(FSD_DRMAA_ERRNO_INVALID_ATTRIBUTE_VALUE,
382	"Invalid native specification: %s Missing '='.", add_attr_copy);
383	} */
384
385	if(strcmp(name,"account") == 0) {
386	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_ACCOUNT,value);
387	}
388	else if(strcmp(name,"acctg-freq") == 0) {
389	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_ACCTG_FREQ,value);
390	}
391	else if (strcmp(name,"comment") == 0) {
392	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_COMMENT,value);
393	}
394	else if (strcmp(name,"constraint") == 0) {
395	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_CONSTRAINT,value);
396	}
397	else if (strcmp(name,"contiguous") == 0) {
398	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_CONTIGUOUS,NULL);
399	}
400	else if (strcmp(name,"cpus-per-task") == 0) {
401	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_CPUS_PER_TASK,value);
402	}
403	else if(strcmp(name,"exclusive") == 0) {
404	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_EXCLUSIVE,NULL);
405	}
406	else if (strcmp(name,"mem") == 0) {
407	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_MEM,value);
408	}
409	else if (strcmp(name,"mem-per-cpu") == 0) {
410	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_MEM_PER_CPU,value);
411	}
412	else if (strcmp(name,"mincpus") == 0) {
413	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_MINCPUS,value);
414	}
415	else if (strcmp(name,"nodelist") == 0) {
416	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_NODELIST,value);
417	}
418	else if (strcmp(name,"nodes") == 0) {
419	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_NODES,value);
420	}
421	else if (strcmp(name,"ntasks-per-node") == 0) {
422	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_NTASKS_PER_NODE,value);
423	}
424	else if (strcmp(name,"partition") == 0) {
425	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_PARTITION,value);
426	}
427	else if (strcmp(name,"qos") == 0) {
428	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_QOS,value);
429	}
430	else if (strcmp(name,"requeue") == 0) {
431	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_REQUEUE,NULL);
432	}
433	else if (strcmp(name,"reservation") == 0) {
434	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_RESERVATION,value);
435	}
436	else if (strcmp(name,"share") == 0) {
437	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_SHARE,NULL);
438	}
439	else if(strcmp(name,"job_name") == 0) {
440	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_JOB_NAME,value);
441	}
442	else if(strcmp(name,"time_limit") == 0) {
443	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_TIME_LIMIT,value);
444	}
445	else if(strcmp(name,"time") == 0) {
446	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_TIME_LIMIT,value);
447	}
448	else if(strcmp(name,"ntasks") == 0) {
449	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_NTASKS,value);
450	}
451	else if(strcmp(name,"gres") == 0) {
452	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_GRES,value);
453	}
454	else if(strcmp(name,"no-kill") == 0) {
455	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_NO_KILL,NULL);
456	}
457	else if(strcmp(name,"licenses") == 0) {
458	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_LICENSES,value);
459	}
460	else if(strcmp(name,"mail-type") == 0) {
461	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_MAIL_TYPE,value);
462	}
463	else if(strcmp(name,"no-requeue") == 0) {
464	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_NO_REQUEUE,NULL);
465	}
466	else if(strcmp(name,"exclude") == 0) {
467	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_EXCLUDE,value);
468	}
469	else if(strcmp(name,"tmp") == 0) {
470	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_TMP,value);
471	} else {
472	fsd_exc_raise_fmt(FSD_DRMAA_ERRNO_INVALID_ATTRIBUTE_VALUE,
473	"Invalid native specification: %s (Unsupported option: --%s)",
474	add_attr, name);
475	}
476
477	}
478	FINALLY
479	{
480	fsd_free(name);
481	fsd_free(add_attr_copy);
482	}
483	END_TRY
484	fsd_log_return(( "" ));
485	}
486
487	void
488	slurmdrmaa_parse_native(job_desc_msg_t job_desc, const char value)
489	{
490	char *arg = NULL;
491	char * volatile native_specification = fsd_strdup(value);
492	char * volatile native_spec_copy = fsd_strdup(native_specification);
493	char * ctxt = NULL;
494	int opt = 0;
495
496	fsd_log_enter(( "" ));
497	TRY
498	{
499	for (arg = strtok_r(native_spec_copy, " \t", &ctxt); arg; arg = strtok_r(NULL, " \t",&ctxt) ) {
500	if (!opt) {
501	if ( (arg[0] != '-') \|\| ((strlen(arg) != 2) && (strlen(arg) > 2) && arg[2] != ' ' && arg[1] !='-' ) ) {
502	fsd_exc_raise_fmt(FSD_DRMAA_ERRNO_INVALID_ATTRIBUTE_VALUE,
503	"Invalid native specification: %s",
504	native_specification);
505	}
506	if(arg[1] == '-') {
507	slurmdrmaa_parse_additional_attr(job_desc, arg+2);
508	}
509	else {
510	opt = arg[1];
511	}
512	} else {
513	switch (opt) {
514	case 'A' :
515	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_ACCOUNT, arg);
516	break;
517	case 'C' :
518	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_CONSTRAINT, arg);
519	break;
520	case 'c' :
521	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_CPUS_PER_TASK, arg);
522	break;
523	case 'N' :
524	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_NODES, arg);
525	break;
526	case 'p' :
527	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_PARTITION, arg);
528	break;
529	case 's' :
530	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_SHARE, NULL);
531	break;
532	case 'w' :
533	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_NODELIST, arg);
534	break;
535	case 'J' :
536	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_JOB_NAME, arg);
537	break;
538	case 't' :
539	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_TIME_LIMIT, arg);
540	break;
541	case 'n' :
542	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_NTASKS, arg);
543	break;
544	case 'x' :
545	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_EXCLUDE, arg);
546	break;
547	case 'L' :
548	slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_LICENSES, arg);
549	break;
550	default :
551	fsd_exc_raise_fmt(FSD_DRMAA_ERRNO_INVALID_ATTRIBUTE_VALUE,
552	"Invalid native specification: %s (Unsupported option: -%c)",
553	native_specification, opt);
554	}
555	if (arg[0] == '-' && strlen(arg) == 2) { /* attribute without arg */
556	opt = arg[1];
557	}
558	else {
559	opt = 0;
560	}
561	}
562	}
563
564	if(strlen(native_spec_copy) == 2 && native_spec_copy[0] == '-' && native_spec_copy[1] == 's')
565	{
566	slurmdrmaa_add_attribute(job_desc, SLURM_NATIVE_SHARE, NULL);
567	opt = 0;
568	}
569
570	if (opt)
571	fsd_exc_raise_fmt(FSD_DRMAA_ERRNO_INVALID_ATTRIBUTE_VALUE,
572	"Invalid native specification: %s",
573	native_specification);
574
575	}
576	FINALLY
577	{
578	fsd_log_debug(( "finalizing job constraints" ));
579	if( job_desc->cpus_per_task > 0 ) {
580	job_desc->min_cpus = job_desc->num_tasks * job_desc->cpus_per_task ;
581	fsd_log_debug((
582	"set min_cpus to ntasks*cpus_per_task: %d",
583	job_desc->min_cpus
584	));
585	} else {
586	job_desc->min_cpus = job_desc->num_tasks ;
587	fsd_log_debug((
588	"set min_cpus to ntasks: %d",
589	job_desc->min_cpus
590	));
591	}
592	fsd_free(native_spec_copy);
593	fsd_free(native_specification);
594	}
595	END_TRY
596
597	fsd_log_return(( "" ));
598	}
599

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

Download in other formats: