source: trunk/slurm_drmaa/util.c @ 22

Revision 22, 13.0 KB checked in by mmamonski, 13 years ago (diff)

accept -time

  • 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
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", string, (unsigned)60*dt.hour+dt.minute ));
81        return 60*dt.hour+dt.minute;
82}
83
84enum slurm_native {
85        SLURM_NATIVE_ACCOUNT,
86        SLURM_NATIVE_ACCTG_FREQ,
87        SLURM_NATIVE_COMMENT,
88        SLURM_NATIVE_CONSTRAINT,
89        SLURM_NATIVE_CONTIGUOUS,
90        SLURM_NATIVE_EXCLUSIVE,
91        SLURM_NATIVE_MEM,
92        SLURM_NATIVE_MEM_PER_CPU,
93        SLURM_NATIVE_MINCPUS,
94        SLURM_NATIVE_NODELIST,
95        SLURM_NATIVE_NODES,
96        SLURM_NATIVE_NTASKS_PER_NODE,
97        SLURM_NATIVE_PARTITION,
98        SLURM_NATIVE_QOS,
99        SLURM_NATIVE_REQUEUE,
100        SLURM_NATIVE_RESERVATION,
101        SLURM_NATIVE_SHARE,
102        SLURM_NATIVE_JOB_NAME,
103        SLURM_NATIVE_TIME_LIMIT
104};
105
106void
107slurmdrmaa_init_job_desc(job_desc_msg_t *job_desc)
108{
109        memset(job_desc, 0, sizeof(job_desc_msg_t));
110}
111
112void
113slurmdrmaa_free_job_desc(job_desc_msg_t *job_desc)
114{
115        unsigned i = 0;
116        fsd_log_enter(( "" ));
117        fsd_free(job_desc->account);   
118        fsd_free(job_desc->comment);
119       
120        for(i = 0;i<job_desc->env_size;i++)
121        {
122                fsd_free(job_desc->environment[i]);
123        }       
124        fsd_free(job_desc->environment);
125        fsd_free(job_desc->features);
126        fsd_free(job_desc->name);       
127        fsd_free(job_desc->mail_user);
128        fsd_free(job_desc->partition);
129        fsd_free(job_desc->qos);
130        fsd_free(job_desc->req_nodes);
131        fsd_free(job_desc->reservation);
132        fsd_free(job_desc->script);
133        fsd_free(job_desc->std_in);
134        fsd_free(job_desc->std_out);
135        fsd_free(job_desc->std_err);   
136        fsd_free(job_desc->work_dir);
137       
138        fsd_log_return(( "" ));
139}
140
141void
142slurmdrmaa_add_attribute(job_desc_msg_t *job_desc, unsigned attr, const char *value)
143{
144        char * ptr = NULL;
145        char * rest = NULL;
146        char * token = NULL;
147
148        switch(attr)
149        {
150                case SLURM_NATIVE_ACCOUNT:
151                        fsd_free(job_desc->account);
152                        fsd_log_debug(("# account = %s",value));
153                        job_desc->account = fsd_strdup(value);
154                        break;
155                case SLURM_NATIVE_ACCTG_FREQ:
156                        fsd_log_debug(("# acctg_freq = %s",value));
157                        job_desc->acctg_freq = fsd_atoi(value);
158                        break;
159                case SLURM_NATIVE_COMMENT:
160                        fsd_free(job_desc->comment);
161                        fsd_log_debug(("# comment = %s",value));
162                        job_desc->comment = fsd_strdup(value);
163                        break;
164                case SLURM_NATIVE_CONSTRAINT:
165                        fsd_free(job_desc->features);
166                        fsd_log_debug(("# constraints -> features = %s",value));
167                        job_desc->features = fsd_strdup(value);
168                        break;
169                case SLURM_NATIVE_CONTIGUOUS:
170                        fsd_log_debug(( "# contiguous = 1"));
171                        job_desc->contiguous = 1;
172                        break;
173                case SLURM_NATIVE_EXCLUSIVE:
174                        fsd_log_debug(( "# exclusive -> shared = 0"));
175                        job_desc->shared = 0;
176                        break;
177                case SLURM_NATIVE_MEM:
178                #if SLURM_VERSION_NUMBER < SLURM_VERSION_NUM(2,2,0)
179                        if(job_desc->job_min_memory == NO_VAL ||  fsd_atoi(value) > (int)job_desc->job_min_memory) {
180                                fsd_log_debug(("# job_min_memory = %s",value));
181                                job_desc->job_min_memory = fsd_atoi(value);
182                        }
183                #else
184                        if(job_desc->pn_min_memory == NO_VAL ||  fsd_atoi(value) > (int)job_desc->pn_min_memory) {
185                                fsd_log_debug(("# pn_min_memory = %s",value));
186                                job_desc->pn_min_memory = fsd_atoi(value);
187                        }
188                #endif
189                        else {
190                                fsd_log_debug(("mem value defined lower or equal to mem-per-cpu or value defined before"));
191                        }
192                        break;
193                case SLURM_NATIVE_MEM_PER_CPU:
194                #if SLURM_VERSION_NUMBER < SLURM_VERSION_NUM(2,2,0)
195                        if(job_desc->job_min_memory == NO_VAL ||  fsd_atoi(value) > (int)job_desc->job_min_memory) {
196                                fsd_log_debug(("# job_min_memory = %s",value));
197                                job_desc->job_min_memory = fsd_atoi(value);
198                        }
199                #else
200                        if(job_desc->pn_min_memory == NO_VAL ||  fsd_atoi(value) > (int)job_desc->pn_min_memory) {
201                                fsd_log_debug(("# pn_min_memory = %s",value));
202                                job_desc->pn_min_memory = fsd_atoi(value);
203                        }
204                #endif
205                        else {
206                                fsd_log_debug(("mem-per-cpu value defined lower or equal to mem or value defined before"));
207                        }
208                        break;
209                case SLURM_NATIVE_MINCPUS:
210                #if SLURM_VERSION_NUMBER < SLURM_VERSION_NUM(2,2,0)
211                        fsd_log_debug(("# job_min_cpus = %s",value));
212                        job_desc->job_min_cpus = fsd_atoi(value);
213                #else
214                        fsd_log_debug(("# min_cpus = %s",value));
215                        job_desc->min_cpus = fsd_atoi(value);
216                #endif
217                        break;
218                case SLURM_NATIVE_NODELIST:
219                        fsd_free(job_desc->req_nodes);
220                        fsd_log_debug(("# node-list - > req_nodes = %s",value));
221                        job_desc->req_nodes = fsd_strdup(value);
222                        break;
223                case SLURM_NATIVE_NODES:
224                        ptr = strdup(value);
225
226                        if((token = strtok_r(ptr,"=",&rest)) == NULL){
227                                fsd_log_error(("strtok_r returned NULL"));
228                        }
229                                               
230                        fsd_log_debug(("nodes: %s ->",value));
231                        fsd_log_debug(("# min_nodes = %s",token));
232                        job_desc->min_nodes = fsd_atoi(token);
233                                               
234                        if(strcmp(rest,"") !=0 ) {
235                                fsd_log_debug(("# max_nodes = %s",rest));
236                                job_desc->max_nodes = fsd_atoi(rest);
237                        }
238                        fsd_free(ptr);
239                        break;         
240                case SLURM_NATIVE_NTASKS_PER_NODE:
241                        fsd_log_debug(("# ntasks_per_node = %s",value));
242                        job_desc->ntasks_per_node = fsd_atoi(value);
243                        break;
244                case SLURM_NATIVE_PARTITION:
245                        fsd_free(job_desc->partition);
246                        fsd_log_debug(("# partition = %s",value));
247                        job_desc->partition = fsd_strdup(value);
248                        break;
249                case SLURM_NATIVE_QOS:
250                        fsd_free(job_desc->qos);
251                        fsd_log_debug(("# qos = %s",value));
252                        job_desc->qos = fsd_strdup(value);
253                        break;
254                case SLURM_NATIVE_REQUEUE:
255                        fsd_log_debug(( "# requeue = 1"));
256                        job_desc->requeue = 1;
257                        break;
258                case SLURM_NATIVE_RESERVATION:
259                        fsd_log_debug(("# reservation = %s",value));
260                        job_desc->reservation = fsd_strdup(value);
261                        break;
262                case SLURM_NATIVE_SHARE:
263                        fsd_log_debug(("# shared = 1"));
264                        job_desc->shared = 1;
265                        break;
266                case SLURM_NATIVE_JOB_NAME:
267                        fsd_log_debug(("# job_name = %s",job_desc->name));
268                        job_desc->name = fsd_strdup(value);
269                        break;
270                case SLURM_NATIVE_TIME_LIMIT:
271                        fsd_log_debug(("# time_limit = %s",value));
272                        job_desc->time_limit = fsd_atoi(value);
273                        break; 
274                default:
275                        fsd_exc_raise_fmt(FSD_DRMAA_ERRNO_INVALID_ATTRIBUTE_VALUE,"Invalid attribute");
276        }
277}
278
279void
280slurmdrmaa_parse_additional_attr(job_desc_msg_t *job_desc,const char *add_attr)
281{
282        char * volatile name = NULL;
283        char *value = NULL;
284        char *ctxt = NULL;
285        char * volatile add_attr_copy = fsd_strdup(add_attr);
286
287        TRY
288          {
289                name = fsd_strdup(strtok_r(add_attr_copy, "=", &ctxt));
290                value = strtok_r(NULL, "=", &ctxt);
291                       
292                if(strcmp(name,"account") == 0) {
293                        slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_ACCOUNT,value);
294                }
295                else if(strcmp(name,"acctg-freq") == 0) {
296                        slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_ACCTG_FREQ,value);
297                }
298                else if (strcmp(name,"comment") == 0) {
299                        slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_COMMENT,value);
300                }
301                else if (strcmp(name,"constraint") == 0) {
302                        slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_CONSTRAINT,value);
303                }
304                else if (strcmp(name,"contiguous") == 0) {
305                        slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_CONTIGUOUS,NULL);
306                }
307                else if(strcmp(name,"exclusive") == 0) {
308                        slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_EXCLUSIVE,NULL);
309                }
310                else if (strcmp(name,"mem") == 0) {
311                        slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_MEM,value);
312                }
313                else if (strcmp(name,"mem-per-cpu") == 0) {
314                        slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_MEM_PER_CPU,value);
315                }
316                else if (strcmp(name,"mincpus") == 0) {
317                        slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_MINCPUS,value);
318                }
319                else if (strcmp(name,"nodelist") == 0) {
320                        slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_NODELIST,value);                 
321                }
322                else if (strcmp(name,"nodes") == 0) {
323                        slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_NODES,value);
324                }
325                else if (strcmp(name,"ntasks-per-node") == 0) {
326                        slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_NTASKS_PER_NODE,value);
327                }
328                else if (strcmp(name,"partition") == 0) {
329                        slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_PARTITION,value);
330                }
331                else if (strcmp(name,"qos") == 0) {
332                        slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_QOS,value);
333                }
334                else if (strcmp(name,"requeue") == 0) {
335                        slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_REQUEUE,NULL);
336                }
337                else if (strcmp(name,"reservation") == 0) {
338                        slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_RESERVATION,value);
339                }
340                else if (strcmp(name,"share") == 0) {
341                        slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_SHARE,NULL);
342                }               
343                else if(strcmp(name,"job_name") == 0) {
344                        slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_JOB_NAME,value);
345                }
346                else if(strcmp(name,"time_limit") == 0) {
347                        slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_TIME_LIMIT,value);
348                }
349                else if(strcmp(name,"time") == 0) {
350                        slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_TIME_LIMIT,value);
351                } else {
352                        fsd_exc_raise_fmt(FSD_DRMAA_ERRNO_INVALID_ATTRIBUTE_VALUE,
353                                        "Invalid native specification: %s (Unsupported option: --%s)",
354                                        add_attr, name);
355                }
356       
357                /*}*/
358          }
359        FINALLY
360          {
361                fsd_free(name);
362                fsd_free(add_attr_copy);
363          }
364        END_TRY
365}
366
367void
368slurmdrmaa_parse_native(job_desc_msg_t *job_desc, const char * value)
369{
370        char *arg = NULL;
371        char * volatile native_specification = fsd_strdup(value);
372        char * volatile native_spec_copy = fsd_strdup(native_specification);
373        char * ctxt = NULL;
374        int opt = 0;
375               
376        fsd_log_enter(( "" ));
377        TRY
378         {
379                for (arg = strtok_r(native_spec_copy, " \t", &ctxt); arg; arg = strtok_r(NULL, " \t",&ctxt) ) {
380                        if (!opt) {
381                                if ( (arg[0] != '-') || ((strlen(arg) != 2) && (strlen(arg) > 2) && arg[2] != ' ' && arg[1] !='-' ) ) {
382                                        fsd_exc_raise_fmt(FSD_DRMAA_ERRNO_INVALID_ATTRIBUTE_VALUE,
383                                                        "Invalid native specification: %s",
384                                                        native_specification);
385                                }
386                                if(arg[1] == '-') {
387                                        slurmdrmaa_parse_additional_attr(job_desc, arg+2);
388                                }
389                                else {
390                                        opt = arg[1];
391                                }               
392                        } else {
393                                switch (opt) {                 
394                                        case 'A' :
395                                                slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_ACCOUNT, arg);
396                                                break;
397                                        case 'C' :
398                                                slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_CONSTRAINT, arg);
399                                                break; 
400                                        case 'N' :     
401                                                slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_NODES, arg);
402                                                break; 
403                                        case 'p' :
404                                                slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_PARTITION, arg);
405                                                break;
406                                        case 's' :
407                                                slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_SHARE, NULL);
408                                                break; 
409                                        case 'w' :
410                                                slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_NODELIST, arg);
411                                                break;
412                                        case 'J' :
413                                                slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_JOB_NAME, arg);
414                                                break;         
415                                        case 't' :
416                                                slurmdrmaa_add_attribute(job_desc,SLURM_NATIVE_TIME_LIMIT, arg);
417                                                break; 
418       
419                                        default :                                                               
420                                                        fsd_exc_raise_fmt(FSD_DRMAA_ERRNO_INVALID_ATTRIBUTE_VALUE,
421                                                                        "Invalid native specification: %s (Unsupported option: -%c)",
422                                                                        native_specification, opt);
423                                }
424                                if (arg[0] == '-' && strlen(arg) == 2) { /* attribute without arg */
425                                        opt = arg[1];
426                                }
427                                else {
428                                        opt = 0;
429                                }
430                        }
431                }
432
433                if(strlen(native_spec_copy) == 2 && native_spec_copy[0] == '-' && native_spec_copy[1] == 's')
434                {
435                        slurmdrmaa_add_attribute(job_desc, SLURM_NATIVE_SHARE, NULL);
436                        opt = 0;
437                }
438               
439                if (opt)
440                        fsd_exc_raise_fmt(FSD_DRMAA_ERRNO_INVALID_ATTRIBUTE_VALUE,
441                                        "Invalid native specification: %s",
442                                        native_specification);
443
444         }
445        FINALLY
446         {
447                fsd_free(native_spec_copy);
448                fsd_free(native_specification);
449         }
450        END_TRY
451
452        fsd_log_return(( "" ));
453}
454
Note: See TracBrowser for help on using the repository browser.