Changeset 6038


Ignore:
Timestamp:
09/26/10 12:10:02 (15 years ago)
Author:
Eric.Larour
Message:

LaunchQueueJob is not a method of each cluster class,
thus allowing some pretty cluster specific operations.
For ex, on astrid, we rarely do batch runs. On pleiades,
we do more of them, and we do a lot of interactive runs.

Location:
issm/trunk/src/m
Files:
1 added
2 deleted
12 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk/src/m/classes/@model/setdefaultparameters.m

    r6016 r6038  
    237237%set petsc options for different analysis
    238238md.petscoptions=petscoptions;
    239 %md.petscoptions=addoptions(md.petscoptions,DiagnosticHorizAnalysisEnum,asmoptions);
    240 %md.petscoptions=addoptions(md.petscoptions,DiagnosticVertAnalysisEnum,mumpsoptions);
     239md.petscoptions=addoptions(md.petscoptions,DiagnosticVertAnalysisEnum,mumpsoptions);
    241240
    242241%solution speed-up

  • issm/trunk/src/m/classes/@runsteps/savemodel.m

    r5297 r6038  
    4545end
    4646
    47 save(name,'md');
     47save(name,'md','-v7.3');
    4848disp(['model saved as: ' name]);

  • issm/trunk/src/m/clusters/astrid.m

    r6005 r6038  
    7777                 end
    7878                 %}}}
    79                  function command=LaunchCommand(cluster,modelruntimename,modelname)% {{{1
    80                          command=['cd ' cluster.executionpath ' && rm -rf ./' modelruntimename ' && mkdir ' modelruntimename ' && cd ' modelruntimename ' && mv ../' modelruntimename '.tar.gz ./ && tar -zxf ' modelruntimename '.tar.gz  && source  ' modelname '.queue '];
     79                 function LaunchQueueJob(cluster,md,options)%{{{1
     80                         
     81                         %lauch command, to be executed via ssh
     82                         launchcommand=['cd ' cluster.executionpath ' && rm -rf ./' md.runtimename ' && mkdir ' md.runtimename ...
     83                                        ' && cd ' md.runtimename ' && mv ../' md.runtimename '.tar.gz ./ && tar -zxf ' md.runtimename '.tar.gz  && source  ' md.name '.queue '];
     84
     85                        if ~strcmpi(options.batch,'yes'),
     86                               
     87                                %compress the files into one zip.
     88                                compressstring=['tar -zcf ' md.runtimename '.tar.gz ' md.name '.bin ' md.name '.queue '  md.name '.petsc '];
     89                                if md.qmu_analysis,
     90                                        compressstring=[compressstring md.name '.qmu.in'];
     91                                end
     92                                system(compressstring);
     93                               
     94                                disp('uploading input file and queueing script');
     95                                issmscpout(md.cluster.name,md.cluster.executionpath,md.cluster.login,md.cluster.port,{[md.runtimename '.tar.gz']});
     96                        else
     97                                disp('batch mode requested: not launching job interactively');
     98                                disp('launch solution sequence on remote cluster by hand');
     99                        end
     100
    81101                 end
    82102                 %}}}

  • issm/trunk/src/m/clusters/castor.m

    r5985 r6038  
    8080                 end
    8181                 %}}}
    82                  function command=LaunchCommand(cluster,modelruntimename,modelname)% {{{1
    83                          command=['cd ' cluster.executionpath ' && rm -rf ./' modelruntimename ' && mkdir ' modelruntimename ' && cd ' modelruntimename ' && mv ../' modelruntimename '.tar.gz ./ && tar -zxf ' modelruntimename '.tar.gz  && qsub ' modelname '.queue '];
     82                 function LaunchQueueJob(cluster,md,options)%{{{1
     83                         
     84                         %lauch command, to be executed via ssh
     85                         launchcommand=['cd ' cluster.executionpath ' && rm -rf ./' md.runtimename ' && mkdir ' md.runtimename ...
     86                                        ' && cd ' md.runtimename ' && mv ../' md.runtimename '.tar.gz ./ && tar -zxf ' md.runtimename '.tar.gz  && qsub ' modelname '.queue '];
     87
     88                        if ~strcmpi(options.batch,'yes'),
     89                               
     90                                %compress the files into one zip.
     91                                compressstring=['tar -zcf ' md.runtimename '.tar.gz ' md.name '.bin ' md.name '.queue '  md.name '.petsc '];
     92                                if md.qmu_analysis,
     93                                        compressstring=[compressstring md.name '.qmu.in'];
     94                                end
     95                                system(compressstring);
     96                               
     97                                disp('uploading input file and queueing script');
     98                                issmscpout(md.cluster.name,md.cluster.executionpath,md.cluster.login,md.cluster.port,{[md.runtimename '.tar.gz']});
     99                        else
     100                                disp('batch mode requested: not launching job interactively');
     101                                disp('launch solution sequence on remote cluster by hand');
     102                        end
     103
    84104                 end
    85105                 %}}}

  • issm/trunk/src/m/clusters/cosmos.m

    r5985 r6038  
    7979                 end
    8080                 %}}}
    81                  function command=LaunchCommand(cluster,modelruntimename,modelname)% {{{1
    82                          command=['cd ' cluster.executionpath ' && rm -rf ./' modelruntimename ' && mkdir ' modelruntimename ' && cd ' modelruntimename ' && mv ../' modelruntimename '.tar.gz ./ && tar -zxf ' modelruntimename '.tar.gz  && qsub -S/bin/sh ' modelname '.queue '];
     81                 function LaunchQueueJob(cluster,md,options)%{{{1
     82                         
     83                         %lauch command, to be executed via ssh
     84                         launchcommand=['cd ' cluster.executionpath ' && rm -rf ./' md.runtimename ' && mkdir ' md.runtimename ...
     85                                        ' && cd ' md.runtimename ' && mv ../' md.runtimename '.tar.gz ./ && tar -zxf ' md.runtimename '.tar.gz  && qsub -S/bin/sh ' modelname '.queue '];
     86
     87                        if ~strcmpi(options.batch,'yes'),
     88                               
     89                                %compress the files into one zip.
     90                                compressstring=['tar -zcf ' md.runtimename '.tar.gz ' md.name '.bin ' md.name '.queue '  md.name '.petsc '];
     91                                if md.qmu_analysis,
     92                                        compressstring=[compressstring md.name '.qmu.in'];
     93                                end
     94                                system(compressstring);
     95                               
     96                                disp('uploading input file and queueing script');
     97                                issmscpout(md.cluster.name,md.cluster.executionpath,md.cluster.login,md.cluster.port,{[md.runtimename '.tar.gz']});
     98                        else
     99                                disp('batch mode requested: not launching job interactively');
     100                                disp('launch solution sequence on remote cluster by hand');
     101                        end
     102
    83103                 end
    84104                 %}}}

  • issm/trunk/src/m/clusters/ericmac.m

    r5985 r6038  
    7676                 end
    7777                 %}}}
    78                  function command=LaunchCommand(cluster,modelruntimename,modelname)% {{{1
    79                          command=['cd ' cluster.executionpath ' && rm -rf ./' modelruntimename ' && mkdir ' modelruntimename ' && cd ' modelruntimename ' && mv ../' modelruntimename '.tar.gz ./ && tar -zxf ' modelruntimename '.tar.gz  && source  ' modelname '.queue '];
     78                 function LaunchQueueJob(cluster,md,options)%{{{1
     79                         
     80                         %lauch command, to be executed via ssh
     81                         launchcommand=['cd ' cluster.executionpath ' && rm -rf ./' md.runtimename ' && mkdir ' md.runtimename ...
     82                                        ' && cd ' md.runtimename ' && mv ../' md.runtimename '.tar.gz ./ && tar -zxf ' md.runtimename '.tar.gz  && source  ' md.name '.queue '];
     83
     84                        if ~strcmpi(options.batch,'yes'),
     85                               
     86                                %compress the files into one zip.
     87                                compressstring=['tar -zcf ' md.runtimename '.tar.gz ' md.name '.bin ' md.name '.queue '  md.name '.petsc '];
     88                                if md.qmu_analysis,
     89                                        compressstring=[compressstring md.name '.qmu.in'];
     90                                end
     91                                system(compressstring);
     92                               
     93                                disp('uploading input file and queueing script');
     94                                issmscpout(md.cluster.name,md.cluster.executionpath,md.cluster.login,md.cluster.port,{[md.runtimename '.tar.gz']});
     95                        else
     96                                disp('batch mode requested: not launching job interactively');
     97                                disp('launch solution sequence on remote cluster by hand');
     98                        end
     99
    80100                 end
    81101                 %}}}

  • issm/trunk/src/m/clusters/gemini.m

    r5985 r6038  
    8080                 end
    8181                 %}}}
    82                  function command=LaunchCommand(cluster,modelruntimename,modelname)% {{{1
    83                          command=['cd ' cluster.executionpath ' && rm -rf ./' modelruntimename ' && mkdir ' modelruntimename ' && cd ' modelruntimename ' && mv ../' modelruntimename '.tar.gz ./ && tar -zxf ' modelruntimename '.tar.gz  && qsub ' modelname '.queue '];
     82                 function LaunchQueueJob(cluster,md,options)%{{{1
     83                         
     84                         %lauch command, to be executed via ssh
     85                         launchcommand=['cd ' cluster.executionpath ' && rm -rf ./' md.runtimename ' && mkdir ' md.runtimename ...
     86                                        ' && cd ' md.runtimename ' && mv ../' md.runtimename '.tar.gz ./ && tar -zxf ' md.runtimename '.tar.gz  && qsub ' modelname '.queue '];
     87
     88                        if ~strcmpi(options.batch,'yes'),
     89                               
     90                                %compress the files into one zip.
     91                                compressstring=['tar -zcf ' md.runtimename '.tar.gz ' md.name '.bin ' md.name '.queue '  md.name '.petsc '];
     92                                if md.qmu_analysis,
     93                                        compressstring=[compressstring md.name '.qmu.in'];
     94                                end
     95                                system(compressstring);
     96                               
     97                                disp('uploading input file and queueing script');
     98                                issmscpout(md.cluster.name,md.cluster.executionpath,md.cluster.login,md.cluster.port,{[md.runtimename '.tar.gz']});
     99                        else
     100                                disp('batch mode requested: not launching job interactively');
     101                                disp('launch solution sequence on remote cluster by hand');
     102                        end
     103
    84104                 end
    85105                 %}}}

  • issm/trunk/src/m/clusters/larsen.m

    r5985 r6038  
    7676                 end
    7777                 %}}}
    78                  function command=LaunchCommand(cluster,modelruntimename,modelname)% {{{1
    79                          command=['cd ' cluster.executionpath ' && rm -rf ./' modelruntimename ' && mkdir ' modelruntimename ' && cd ' modelruntimename ' && mv ../' modelruntimename '.tar.gz ./ && tar -zxf ' modelruntimename '.tar.gz  && source  ' modelname '.queue '];
     78                 function LaunchQueueJob(cluster,md,options)%{{{1
     79                         
     80                         %lauch command, to be executed via ssh
     81                         launchcommand=['cd ' cluster.executionpath ' && rm -rf ./' md.runtimename ' && mkdir ' md.runtimename ...
     82                                        ' && cd ' md.runtimename ' && mv ../' md.runtimename '.tar.gz ./ && tar -zxf ' md.runtimename '.tar.gz  && source  ' md.name '.queue '];
     83
     84                        if ~strcmpi(options.batch,'yes'),
     85                               
     86                                %compress the files into one zip.
     87                                compressstring=['tar -zcf ' md.runtimename '.tar.gz ' md.name '.bin ' md.name '.queue '  md.name '.petsc '];
     88                                if md.qmu_analysis,
     89                                        compressstring=[compressstring md.name '.qmu.in'];
     90                                end
     91                                system(compressstring);
     92                               
     93                                disp('uploading input file and queueing script');
     94                                issmscpout(md.cluster.name,md.cluster.executionpath,md.cluster.login,md.cluster.port,{[md.runtimename '.tar.gz']});
     95                        else
     96                                disp('batch mode requested: not launching job interactively');
     97                                disp('launch solution sequence on remote cluster by hand');
     98                        end
     99
    80100                 end
    81101                 %}}}

  • issm/trunk/src/m/clusters/pfe.m

    r5985 r6038  
    1919                 codepath='/staff/elarour/trunk/bin';
    2020                 executionpath='/nobackupp10/elarour/Testing';
     21                 interactive=0;
    2122         end
    2223         properties (SetAccess=private)
    … …  
    110111                         fclose(fid);
    111112
     113
     114                         %in interactive mode, create a run file, and errlog and outlog file
     115                         if cluster.interactive,
     116                                 fid=fopen([modelname '.run'],'w');
     117                                 fprintf(fid,'mpiexec -verbose -np %i %s/issm.exe %s $PBS_O_WORKDIR %s.bin %s.petsc %s.outbin %s.lock',cluster.np,cluster.codepath,EnumToString(analysis_type),modelname,modelname,modelname,modelname);
     118                                 fclose(fid);
     119                                 fid=fopen([modelname '.errlog'],'w');
     120                                 fclose(fid);
     121                                 fid=fopen([modelname '.outlog'],'w');
     122                                 fclose(fid);
     123                         end
    112124                 end
    113125                 %}}}
    114                  function command=LaunchCommand(cluster,modelruntimename,modelname)% {{{1
    115                          command=['cd ' cluster.executionpath ' && rm -rf ./' modelruntimename ' && mkdir ' modelruntimename ' && cd ' modelruntimename ' && mv ../' modelruntimename '.tar.gz ./ && tar -zxf ' modelruntimename '.tar.gz  && qsub ' modelname '.queue '];
     126                 function LaunchQueueJob(cluster,md,options)%{{{1
     127                         
     128                         %lauch command, to be executed via ssh
     129                         if ~cluster.interactive,
     130                                launchcommand=['cd ' cluster.executionpath ' && rm -rf ./' md.runtimename ' && mkdir ' md.runtimename ...
     131                                        ' && cd ' md.runtimename ' && mv ../' md.runtimename '.tar.gz ./ && tar -zxf ' md.runtimename '.tar.gz  && qsub ' modelname '.queue '];
     132                        else
     133                                launchcommand=['cd ' cluster.executionpath '/Interactive && tar -zxf ' md.runtimename '.tar.gz'];
     134                        end
     135
     136                        if ~strcmpi(options.batch,'yes'),
     137                               
     138                                %compress the files into one zip.
     139                                compressstring=['tar -zcf ' md.runtimename '.tar.gz ' md.name '.bin ' md.name '.queue '  md.name '.petsc '];
     140                                if md.qmu_analysis,
     141                                        compressstring=[compressstring md.name '.qmu.in'];
     142                                end
     143                                if cluster.interactive,
     144                                        compressstring=[compressstring md.name '.run ' md.name '.errlog ' md.name '.outlog '];
     145                                end
     146                                system(compressstring);
     147                               
     148                                disp('uploading input file and queueing script');
     149                                if ~cluster.interactive,
     150                                        issmscpout(md.cluster.name,md.cluster.executionpath,md.cluster.login,md.cluster.port,{[md.runtimename '.tar.gz']});
     151                                else
     152                                        issmscpout(md.cluster.name,[md.cluster.executionpath '/Interactive'],md.cluster.login,md.cluster.port,{[md.runtimename '.tar.gz']});
     153                                end
     154                               
     155                                disp('launching solution sequence on remote cluster');
     156                                issmssh(md.cluster.name,md.cluster.login,md.cluster.port,launchcommand);
     157                                       
     158                                if cluster.interactive,
     159                                        error('done uploading files to interactive directory on remote cluster');
     160                                end
     161
     162                        else
     163                                disp('batch mode requested: not launching job interactively');
     164                                disp('launch solution sequence on remote cluster by hand');
     165                        end
    116166                 end
    117167                 %}}}

  • issm/trunk/src/m/clusters/pollux.m

    r5985 r6038  
    8080                 end
    8181                 %}}}
    82                  function command=LaunchCommand(cluster,modelruntimename,modelname)% {{{1
    83                          command=['cd ' cluster.executionpath ' && rm -rf ./' modelruntimename ' && mkdir ' modelruntimename ' && cd ' modelruntimename ' && mv ../' modelruntimename '.tar.gz ./ && tar -zxf ' modelruntimename '.tar.gz  && qsub ' modelname '.queue '];
     82                 function LaunchQueueJob(cluster,md,options)%{{{1
     83                         
     84                         %lauch command, to be executed via ssh
     85                         launchcommand=['cd ' cluster.executionpath ' && rm -rf ./' md.runtimename ' && mkdir ' md.runtimename ...
     86                                        ' && cd ' md.runtimename ' && mv ../' md.runtimename '.tar.gz ./ && tar -zxf ' md.runtimename '.tar.gz  && qsub ' modelname '.queue '];
     87
     88                        if ~strcmpi(options.batch,'yes'),
     89                               
     90                                %compress the files into one zip.
     91                                compressstring=['tar -zcf ' md.runtimename '.tar.gz ' md.name '.bin ' md.name '.queue '  md.name '.petsc '];
     92                                if md.qmu_analysis,
     93                                        compressstring=[compressstring md.name '.qmu.in'];
     94                                end
     95                                system(compressstring);
     96                               
     97                                disp('uploading input file and queueing script');
     98                                issmscpout(md.cluster.name,md.cluster.executionpath,md.cluster.login,md.cluster.port,{[md.runtimename '.tar.gz']});
     99                        else
     100                                disp('batch mode requested: not launching job interactively');
     101                                disp('launch solution sequence on remote cluster by hand');
     102                        end
     103
    84104                 end
    85105                 %}}}

  • issm/trunk/src/m/clusters/wilkes.m

    r5985 r6038  
    7676                 end
    7777                 %}}}
    78                  function command=LaunchCommand(cluster,modelruntimename,modelname)% {{{1
    79                          command=['cd ' cluster.executionpath ' && rm -rf ./' modelruntimename ' && mkdir ' modelruntimename ' && cd ' modelruntimename ' && mv ../' modelruntimename '.tar.gz ./ && tar -zxf ' modelruntimename '.tar.gz  && source  ' modelname '.queue '];
     78                 function LaunchQueueJob(cluster,md,options)%{{{1
     79                         
     80                         %lauch command, to be executed via ssh
     81                         launchcommand=['cd ' cluster.executionpath ' && rm -rf ./' md.runtimename ' && mkdir ' md.runtimename ...
     82                                        ' && cd ' md.runtimename ' && mv ../' md.runtimename '.tar.gz ./ && tar -zxf ' md.runtimename '.tar.gz  && source  ' md.name '.queue '];
     83
     84                        if ~strcmpi(options.batch,'yes'),
     85                               
     86                                %compress the files into one zip.
     87                                compressstring=['tar -zcf ' md.runtimename '.tar.gz ' md.name '.bin ' md.name '.queue '  md.name '.petsc '];
     88                                if md.qmu_analysis,
     89                                        compressstring=[compressstring md.name '.qmu.in'];
     90                                end
     91                                system(compressstring);
     92                               
     93                                disp('uploading input file and queueing script');
     94                                issmscpout(md.cluster.name,md.cluster.executionpath,md.cluster.login,md.cluster.port,{[md.runtimename '.tar.gz']});
     95                        else
     96                                disp('batch mode requested: not launching job interactively');
     97                                disp('launch solution sequence on remote cluster by hand');
     98                        end
     99
    80100                 end
    81101                 %}}}

  • issm/trunk/src/m/model/solveparallel.m

    r5979 r6038  
    55%      md=solveparallel(md);
    66
     7%retrieve cluster: otherwise, we can't call its methods (subsref bug)
     8cluster=md.cluster;
     9
    710%First, build a runtime name that is unique, that we will use to create
    811%directories, name jobs, etc ...
    9 c=clock;
    10 md.runtimename=sprintf('%s-%i-%i-%i-%i-%i-%i-%i',md.name,c(2),c(3),c(1),c(4),c(5),floor(c(6)),GetPId());
     12c=clock; md.runtimename=sprintf('%s-%i-%i-%i-%i-%i-%i-%i',md.name,c(2),c(3),c(1),c(4),c(5),floor(c(6)),GetPId());
    1113
    1214%Marshall model data into a binary file.
    … …  
    1921
    2022%Now, we need to build the queuing script, used by the cluster to launch the job.
    21 BuildQueueScript(md.cluster,md.name,md.analysis_type,md.mem_debug);
     23cluster.BuildQueueScript(md.name,md.analysis_type,md.mem_debug);
    2224
    2325%Now, launch the queueing script
    24 LaunchQueueJob(md,options);
     26cluster.LaunchQueueJob(md,options);
    2527
    2628if ~strcmpi(options.upload,'on'), %did we even try to run? if so, wait on lock
    … …  
    4446                system(['rm -rf qmu' num2str(GetPId)]);
    4547        end
     48else
     49        error('solveparallel done uploading test decks');
    4650end
    47 
    48 
Note: See TracChangeset for help on using the changeset viewer.