source: trunk/slurm_drmaa/util.c @ 44

Revision 44, 17.7 KB checked in by pkopta, 10 years ago (diff)

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