source: trunk/slurm_drmaa/util.c @ 33

Revision 33, 16.5 KB checked in by mmamonski, 11 years ago (diff)

-L opt added, beside just --licenses
  • 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
29static char rcsid[]
30#       ifdef __GNUC__
31                __attribute__ ((unused))
32#       endif
33        = "$Id$";
34#endif
35
36unsigned int
37slurmdrmaa_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 */
85static 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
114enum 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,
131        SLURM_NATIVE_SHARE,
132        SLURM_NATIVE_JOB_NAME,
133        SLURM_NATIVE_TIME_LIMIT,
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,
140        SLURM_NATIVE_EXCLUDE,
141        SLURM_NATIVE_TMP
142};
143
144void
145slurmdrmaa_init_job_desc(job_desc_msg_t *job_desc)
146{
147        memset(job_desc, 0, sizeof(job_desc_msg_t));
148}
149
150void
151slurmdrmaa_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);
173        fsd_free(job_desc->exc_nodes);
174#if SLURM_VERSION_NUMBER >= SLURM_VERSION_NUM(2,2,0)
175        fsd_free(job_desc->gres);
176#endif
177       
178        fsd_log_return(( "" ));
179}
180
181void
182slurmdrmaa_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:
218                #if SLURM_VERSION_NUMBER < SLURM_VERSION_NUM(2,2,0)
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                        }
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 {
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:
234                #if SLURM_VERSION_NUMBER < SLURM_VERSION_NUM(2,2,0)
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                        }
239                #else
240                        if(job_desc->pn_min_memory == NO_VAL ||  fsd_atoi(value) > (int)job_desc->pn_min_memory) {
241                                fsd_log_debug(("# pn_min_memory (MEM_PER_CPU) = %s",value));
242                                job_desc->pn_min_memory = fsd_atoi(value) | MEM_PER_CPU;
243                        }
244                #endif
245                        else {
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:
250                #if SLURM_VERSION_NUMBER < SLURM_VERSION_NUM(2,2,0)
251                        fsd_log_debug(("# job_min_cpus = %s",value));
252                        job_desc->job_min_cpus = fsd_atoi(value);
253                #else
254                        fsd_log_debug(("# min_cpus = %s",value));
255                        job_desc->min_cpus = fsd_atoi(value);
256                #endif
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);
265                       
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;
306                case SLURM_NATIVE_JOB_NAME:
307                        fsd_log_debug(("# job_name = %s",job_desc->name));
308                        job_desc->name = fsd_strdup(value);
309                        break;
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; 
319                case SLURM_NATIVE_GRES:
320                        #if SLURM_VERSION_NUMBER >= SLURM_VERSION_NUM(2,2,0)
321                        fsd_log_debug(("# gres = %s",value));
322                        job_desc->gres = fsd_strdup(value);
323                        #else
324                        fsd_log_error(("GRES not supported in this version of SLURM."));
325                        #endif
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;
347                case SLURM_NATIVE_TMP:
348                        fsd_log_debug(("# tmp = %s", value));
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
354                        break;
355       
356                default:
357                        fsd_exc_raise_fmt(FSD_DRMAA_ERRNO_INVALID_ATTRIBUTE_VALUE,"Invalid attribute");
358        }
359}
360
361void
362slurmdrmaa_parse_additional_attr(job_desc_msg_t *job_desc,const char *add_attr)
363{
364        char * volatile name = NULL;
365        char *value = NULL;
366        char *ctxt = NULL;
367        char * volatile add_attr_copy = fsd_strdup(add_attr);
368
369        TRY
370          {
371                name = fsd_strdup(strtok_r(add_attr_copy, "=", &ctxt));
372                value = strtok_r(NULL, "=", &ctxt);
373                /*
374                 * TODO: move it to slurmdrmaa_add_attribute
375                 if (value == NULL) {
376                        fsd_exc_raise_fmt(FSD_DRMAA_ERRNO_INVALID_ATTRIBUTE_VALUE,
377                                "Invalid native specification: %s Missing '='.", add_attr_copy);
378                } */
379
380                if(strcmp(name,"account") == 0) {
381                        slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_ACCOUNT,value);
382                }
383                else if(strcmp(name,"acctg-freq") == 0) {
384                        slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_ACCTG_FREQ,value);
385                }
386                else if (strcmp(name,"comment") == 0) {
387                        slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_COMMENT,value);
388                }
389                else if (strcmp(name,"constraint") == 0) {
390                        slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_CONSTRAINT,value);
391                }
392                else if (strcmp(name,"contiguous") == 0) {
393                        slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_CONTIGUOUS,NULL);
394                }
395                else if(strcmp(name,"exclusive") == 0) {
396                        slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_EXCLUSIVE,NULL);
397                }
398                else if (strcmp(name,"mem") == 0) {
399                        slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_MEM,value);
400                }
401                else if (strcmp(name,"mem-per-cpu") == 0) {
402                        slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_MEM_PER_CPU,value);
403                }
404                else if (strcmp(name,"mincpus") == 0) {
405                        slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_MINCPUS,value);
406                }
407                else if (strcmp(name,"nodelist") == 0) {
408                        slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_NODELIST,value);                 
409                }
410                else if (strcmp(name,"nodes") == 0) {
411                        slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_NODES,value);
412                }
413                else if (strcmp(name,"ntasks-per-node") == 0) {
414                        slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_NTASKS_PER_NODE,value);
415                }
416                else if (strcmp(name,"partition") == 0) {
417                        slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_PARTITION,value);
418                }
419                else if (strcmp(name,"qos") == 0) {
420                        slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_QOS,value);
421                }
422                else if (strcmp(name,"requeue") == 0) {
423                        slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_REQUEUE,NULL);
424                }
425                else if (strcmp(name,"reservation") == 0) {
426                        slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_RESERVATION,value);
427                }
428                else if (strcmp(name,"share") == 0) {
429                        slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_SHARE,NULL);
430                }               
431                else if(strcmp(name,"job_name") == 0) {
432                        slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_JOB_NAME,value);
433                }
434                else if(strcmp(name,"time_limit") == 0) {
435                        slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_TIME_LIMIT,value);
436                }
437                else if(strcmp(name,"time") == 0) {
438                        slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_TIME_LIMIT,value);
439                }
440                else if(strcmp(name,"ntasks") == 0) {
441                        slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_NTASKS,value);
442                }
443                else if(strcmp(name,"gres") == 0) {
444                        slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_GRES,value);
445                }
446                else if(strcmp(name,"no-kill") == 0) {
447                        slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_NO_KILL,NULL);
448                }
449                else if(strcmp(name,"licenses") == 0) {
450                        slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_LICENSES,value);
451                }
452                else if(strcmp(name,"mail-type") == 0) {
453                        slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_MAIL_TYPE,value);
454                }
455                else if(strcmp(name,"no-requeue") == 0) {
456                        slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_NO_REQUEUE,NULL);
457                }
458                else if(strcmp(name,"exclude") == 0) {
459                        slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_EXCLUDE,value);
460                }
461                else if(strcmp(name,"tmp") == 0) {
462                        slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_TMP,value);
463                } else {
464                        fsd_exc_raise_fmt(FSD_DRMAA_ERRNO_INVALID_ATTRIBUTE_VALUE,
465                                        "Invalid native specification: %s (Unsupported option: --%s)",
466                                        add_attr, name);
467                }
468       
469          }
470        FINALLY
471          {
472                fsd_free(name);
473                fsd_free(add_attr_copy);
474          }
475        END_TRY
476}
477
478void
479slurmdrmaa_parse_native(job_desc_msg_t *job_desc, const char * value)
480{
481        char *arg = NULL;
482        char * volatile native_specification = fsd_strdup(value);
483        char * volatile native_spec_copy = fsd_strdup(native_specification);
484        char * ctxt = NULL;
485        int opt = 0;
486               
487        fsd_log_enter(( "" ));
488        TRY
489         {
490                for (arg = strtok_r(native_spec_copy, " \t", &ctxt); arg; arg = strtok_r(NULL, " \t",&ctxt) ) {
491                        if (!opt) {
492                                if ( (arg[0] != '-') || ((strlen(arg) != 2) && (strlen(arg) > 2) && arg[2] != ' ' && arg[1] !='-' ) ) {
493                                        fsd_exc_raise_fmt(FSD_DRMAA_ERRNO_INVALID_ATTRIBUTE_VALUE,
494                                                        "Invalid native specification: %s",
495                                                        native_specification);
496                                }
497                                if(arg[1] == '-') {
498                                        slurmdrmaa_parse_additional_attr(job_desc, arg+2);
499                                }
500                                else {
501                                        opt = arg[1];
502                                }               
503                        } else {
504                                switch (opt) {
505                                        case 'A' :
506                                                slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_ACCOUNT, arg);
507                                                break;
508                                        case 'C' :
509                                                slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_CONSTRAINT, arg);
510                                                break; 
511                                        case 'N' :     
512                                                slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_NODES, arg);
513                                                break; 
514                                        case 'p' :
515                                                slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_PARTITION, arg);
516                                                break;
517                                        case 's' :
518                                                slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_SHARE, NULL);
519                                                break;
520                                        case 'w' :
521                                                slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_NODELIST, arg);
522                                                break;
523                                        case 'J' :
524                                                slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_JOB_NAME, arg);
525                                                break;
526                                        case 't' :
527                                                slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_TIME_LIMIT, arg);
528                                                break; 
529                                        case 'n' :
530                                                slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_NTASKS, arg);
531                                                break; 
532                                        case 'x' :
533                                                slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_EXCLUDE, arg);
534                                                break;
535                                        case 'L' :
536                                                slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_LICENSES, arg);
537                                                break;                                                 
538                                        default :
539                                                        fsd_exc_raise_fmt(FSD_DRMAA_ERRNO_INVALID_ATTRIBUTE_VALUE,
540                                                                        "Invalid native specification: %s (Unsupported option: -%c)",
541                                                                        native_specification, opt);
542                                }
543                                if (arg[0] == '-' && strlen(arg) == 2) { /* attribute without arg */
544                                        opt = arg[1];
545                                }
546                                else {
547                                        opt = 0;
548                                }
549                        }
550                }
551
552                if(strlen(native_spec_copy) == 2 && native_spec_copy[0] == '-' && native_spec_copy[1] == 's')
553                {
554                        slurmdrmaa_add_attribute(job_desc, SLURM_NATIVE_SHARE, NULL);
555                        opt = 0;
556                }
557               
558                if (opt)
559                        fsd_exc_raise_fmt(FSD_DRMAA_ERRNO_INVALID_ATTRIBUTE_VALUE,
560                                        "Invalid native specification: %s",
561                                        native_specification);
562
563         }
564        FINALLY
565         {
566                fsd_free(native_spec_copy);
567                fsd_free(native_specification);
568         }
569        END_TRY
570
571        fsd_log_return(( "" ));
572}
573
Note: See TracBrowser for help on using the repository browser.