From d720e7959c4c84a2ad5e6a063c5a4e27512433ca Mon Sep 17 00:00:00 2001 From: Ole Tange Date: Fri, 23 Nov 2012 00:57:35 +0100 Subject: [PATCH] parallel: $::opt => $opt::. Passes unittest. --- src/parallel | 732 +++++++++++----------- testsuite/wanted-results/parallel-local21 | 10 +- 2 files changed, 374 insertions(+), 368 deletions(-) diff --git a/src/parallel b/src/parallel index 42bb1594..3d14c509 100755 --- a/src/parallel +++ b/src/parallel @@ -46,7 +46,7 @@ parse_options(); my $number_of_args; if($Global::max_number_of_args) { $number_of_args=$Global::max_number_of_args; -} elsif ($::opt_X or $::opt_m) { +} elsif ($opt::X or $opt::m) { $number_of_args = undef; } else { $number_of_args = 1; @@ -62,20 +62,20 @@ if(@ARGV) { } my @fhlist; -@fhlist = map { open_or_exit($_) } @::opt_a; +@fhlist = map { open_or_exit($_) } @opt::a; if(not @fhlist) { @fhlist = (*STDIN); } -if($::opt_skip_first_line) { +if($opt::skip_first_line) { # Skip the first line for the first file handle my $fh = $fhlist[0]; <$fh>; } -if($::opt_header and not $::opt_pipe) { +if($opt::header and not $opt::pipe) { my $fh = $fhlist[0]; # split with colsep or \t # $header force $colsep = \t if undef? - my $delimiter = $::opt_colsep; + my $delimiter = $opt::colsep; $delimiter ||= '$'; my $id = 1; for my $fh (@fhlist) { @@ -98,10 +98,10 @@ if($::opt_header and not $::opt_pipe) { } # Parallel check for all hosts are up -#if(not $::opt_plain and (@::opt_sshlogin or @::opt_sshloginfile)) { -if($::opt_filter_hosts and (@::opt_sshlogin or @::opt_sshloginfile)) { - my @S = map { "-S " . ::shell_quote_scalar($_) } @::opt_sshlogin; - my @slf = map { "--slf " . ::shell_quote_scalar($_) } @::opt_sshloginfile; +#if(not $opt::plain and (@opt::sshlogin or @opt::sshloginfile)) { +if($opt::filter_hosts and (@opt::sshlogin or @opt::sshloginfile)) { + my @S = map { "-S " . ::shell_quote_scalar($_) } @opt::sshlogin; + my @slf = map { "--slf " . ::shell_quote_scalar($_) } @opt::sshloginfile; my $cmd = "$0 --plain --tag --joblog - -k --onall @S @slf " . "::: ". "'parallel --number-of-cores ' ". @@ -163,7 +163,7 @@ if($::opt_filter_hosts and (@::opt_sshlogin or @::opt_sshloginfile)) { $ncores{$sshlogin} or ::die_bug("ncores missing: ".$obj->serverlogin()); $time_to_login{$sshlogin} or ::die_bug("time_to_login missing: ".$obj->serverlogin()); $maxlen{$sshlogin} or ::die_bug("maxlen missing: ".$obj->serverlogin()); - if($::opt_use_cpus_instead_of_cores) { + if($opt::use_cpus_instead_of_cores) { $obj->set_ncpus($ncpus{$sshlogin}); } else { $obj->set_ncpus($ncores{$sshlogin}); @@ -175,7 +175,7 @@ if($::opt_filter_hosts and (@::opt_sshlogin or @::opt_sshloginfile)) { } } -if($::opt_nonall or $::opt_onall) { +if($opt::nonall or $opt::onall) { # Copy all @fhlist into tempfiles my @argfiles = (); for my $fh (@fhlist) { @@ -184,7 +184,7 @@ if($::opt_nonall or $::opt_onall) { close $outfh; push @argfiles, $name; } - if(@::opt_basefile) { setup_basefile(); } + if(@opt::basefile) { setup_basefile(); } # for each sshlogin do: # parallel -S $sshlogin $command :::: @argfiles # @@ -192,30 +192,30 @@ if($::opt_nonall or $::opt_onall) { # -P should only go to the first, and -S should not be copied at all. my $options = join(" ", - ((defined $::opt_P) ? "-P $::opt_P" : ""), - ((defined $::opt_u) ? "-u" : ""), - ((defined $::opt_group) ? "-g" : ""), - ((defined $::opt_D) ? "-D" : ""), - ((defined $::opt_plain) ? "--plain" : ""), + ((defined $opt::P) ? "-P $opt::P" : ""), + ((defined $opt::u) ? "-u" : ""), + ((defined $opt::group) ? "-g" : ""), + ((defined $opt::D) ? "-D" : ""), + ((defined $opt::plain) ? "--plain" : ""), ); my $suboptions = join(" ", - ((defined $::opt_u) ? "-u" : ""), - ((defined $::opt_group) ? "-g" : ""), - ((defined $::opt_joblog) ? "--joblog $::opt_joblog" : ""), - ((defined $::opt_colsep) ? "--colsep ".shell_quote($::opt_colsep) : ""), - ((@::opt_v) ? "-vv" : ""), - ((defined $::opt_D) ? "-D" : ""), - ((defined $::opt_timeout) ? "--timeout ".$::opt_timeout : ""), - ((defined $::opt_plain) ? "--plain" : ""), - (@::opt_env ? map { "--env ".::shell_quote_scalar($_) } @::opt_env : ""), + ((defined $opt::u) ? "-u" : ""), + ((defined $opt::group) ? "-g" : ""), + ((defined $opt::joblog) ? "--joblog $opt::joblog" : ""), + ((defined $opt::colsep) ? "--colsep ".shell_quote($opt::colsep) : ""), + ((@opt::v) ? "-vv" : ""), + ((defined $opt::D) ? "-D" : ""), + ((defined $opt::timeout) ? "--timeout ".$opt::timeout : ""), + ((defined $opt::plain) ? "--plain" : ""), + (@opt::env ? map { "--env ".::shell_quote_scalar($_) } @opt::env : ""), ); ::debug("| $0 $options\n"); open(my $parallel_fh, "|-", "$0 -j0 $options") || ::die_bug("This does not run GNU Parallel: $0 $options"); for my $sshlogin (values %Global::host) { print $parallel_fh "$0 $suboptions -j1 ". - ((defined $::opt_tag) ? + ((defined $opt::tag) ? "--tagstring ".shell_quote_scalar($sshlogin->string()) : ""). " -S ". shell_quote_scalar($sshlogin->string())." ". shell_quote_scalar($command)." :::: @argfiles\n"; @@ -223,14 +223,14 @@ if($::opt_nonall or $::opt_onall) { close $parallel_fh; $Global::exitstatus = $? >> 8; debug("--onall exitvalue ",$?); - if(@::opt_basefile) { cleanup_basefile(); } + if(@opt::basefile) { cleanup_basefile(); } unlink(@argfiles); wait_and_exit(min(undef_as_zero($Global::exitstatus),254)); } $Global::JobQueue = JobQueue->new( $command,\@fhlist,$Global::ContextReplace,$number_of_args,\@Global::ret_files); -if($::opt_eta) { +if($opt::eta) { # Count the number of jobs before starting any $Global::JobQueue->total_jobs(); } @@ -245,7 +245,7 @@ if($Global::semaphore) { } $SIG{TERM} = \&start_no_new_jobs; start_more_jobs(); -if($::opt_pipe) { +if($opt::pipe) { spreadstdin(@fhlist); } ::debug("Start draining\n"); @@ -256,7 +256,7 @@ cleanup(); if($Global::semaphore) { $sem->release(); } -if($::opt_halt_on_error) { +if($opt::halt_on_error) { wait_and_exit($Global::halt_on_error_exitstatus); } else { wait_and_exit(min(undef_as_zero($Global::exitstatus),254)); @@ -271,35 +271,35 @@ sub spreadstdin { my $record; my $buf = ""; my $header = ""; - if($::opt_header) { - my $non_greedy_regexp = $::opt_header; + if($opt::header) { + my $non_greedy_regexp = $opt::header; # ? , * , + , {} => ?? , *? , +? , {}? $non_greedy_regexp =~ s/(\?|\*|\+|\})/$1\?/g; - while(read(STDIN,substr($buf,length $buf,0),$::opt_blocksize)) { + while(read(STDIN,substr($buf,length $buf,0),$opt::blocksize)) { if($buf=~s/^(.*?$non_greedy_regexp)//) { $header = $1; last; } } } my ($recstart,$recend,$recerror); - if(defined($::opt_recstart) and defined($::opt_recend)) { + if(defined($opt::recstart) and defined($opt::recend)) { # If both --recstart and --recend is given then both must match - $recstart = $::opt_recstart; - $recend = $::opt_recend; + $recstart = $opt::recstart; + $recend = $opt::recend; $recerror = "parallel: Warning: --recend and --recstart unmatched. Is --blocksize too small?"; - } elsif(defined($::opt_recstart)) { + } elsif(defined($opt::recstart)) { # If --recstart is given it must match start of record - $recstart = $::opt_recstart; + $recstart = $opt::recstart; $recend = ""; $recerror = "parallel: Warning: --recstart unmatched. Is --blocksize too small?"; - } elsif(defined($::opt_recend)) { + } elsif(defined($opt::recend)) { # If --recend is given then it must match end of record $recstart = ""; - $recend = $::opt_recend; + $recend = $opt::recend; $recerror = "parallel: Warning: --recend unmatched. Is --blocksize too small?"; } - if($::opt_regexp) { + if($opt::regexp) { # If $recstart/$recend contains '|' this should only apply to the regexp $recstart = "(?:".$recstart.")"; $recend = "(?:".$recend.")"; @@ -323,17 +323,17 @@ sub spreadstdin { $t++) {} } else { # Read a block - read($in,substr($buf,length $buf,0),$::opt_blocksize) or last; + read($in,substr($buf,length $buf,0),$opt::blocksize) or last; # substr above = append to $buf } - if($::opt_r) { + if($opt::r) { # Remove empty lines $buf=~s/^\s*\n//gm; if(length $buf == 0) { next; } } - if($::opt_regexp) { + if($opt::regexp) { if($Global::max_number_of_args) { # -N => (start..*?end){n} while($buf =~ s/((?:$recstart.*?$recend){$Global::max_number_of_args})($recstart.*)$/$2/os) { @@ -417,7 +417,7 @@ sub write_record_to_pipe { # be removed. my $record = substr($$record_ref,0,$endpos); # Remove rec_sep - if($::opt_remove_rec_sep) { + if($opt::remove_rec_sep) { # Remove record separator $record =~ s/$recend$recstart//gos; $record =~ s/^$recstart//os; @@ -468,116 +468,116 @@ sub __PARSE_OPTIONS__ {} sub options_hash { # Returns a hash of the GetOptions config return - ("debug|D" => \$::opt_D, - "xargs" => \$::opt_xargs, - "m" => \$::opt_m, - "X" => \$::opt_X, - "v" => \@::opt_v, - "joblog=s" => \$::opt_joblog, - "results|result|res=s" => \$::opt_results, - "resume" => \$::opt_resume, - "silent" => \$::opt_silent, - #"silent-error|silenterror" => \$::opt_silent_error, - "keep-order|keeporder|k" => \$::opt_k, - "group" => \$::opt_group, - "g" => \$::opt_retired, - "ungroup|u" => \$::opt_u, - "null|0" => \$::opt_0, - "quote|q" => \$::opt_q, - "I=s" => \$::opt_I, - "extensionreplace|er=s" => \$::opt_U, - "U=s" => \$::opt_retired, - "basenamereplace|bnr=s" => \$::opt_basenamereplace, - "dirnamereplace|dnr=s" => \$::opt_dirnamereplace, - "basenameextensionreplace|bner=s" => \$::opt_basenameextensionreplace, - "seqreplace=s" => \$::opt_seqreplace, - "jobs|j=s" => \$::opt_P, - "load=s" => \$::opt_load, - "noswap" => \$::opt_noswap, - "max-line-length-allowed" => \$::opt_max_line_length_allowed, - "number-of-cpus" => \$::opt_number_of_cpus, - "number-of-cores" => \$::opt_number_of_cores, - "use-cpus-instead-of-cores" => \$::opt_use_cpus_instead_of_cores, - "shellquote|shell_quote|shell-quote" => \$::opt_shellquote, - "nice=i" => \$::opt_nice, - "timeout=i" => \$::opt_timeout, - "tag" => \$::opt_tag, - "tagstring=s" => \$::opt_tagstring, - "onall" => \$::opt_onall, - "nonall" => \$::opt_nonall, - "filter-hosts|filterhosts|filter-host" => \$::opt_filter_hosts, - "sshlogin|S=s" => \@::opt_sshlogin, - "sshloginfile|slf=s" => \@::opt_sshloginfile, - "controlmaster|M" => \$::opt_controlmaster, - "return=s" => \@::opt_return, - "trc=s" => \@::opt_trc, - "transfer" => \$::opt_transfer, - "cleanup" => \$::opt_cleanup, - "basefile|bf=s" => \@::opt_basefile, - "B=s" => \$::opt_retired, - "workdir|wd=s" => \$::opt_workdir, - "W=s" => \$::opt_retired, - "tmpdir=s" => \$::opt_tmpdir, - "tempdir=s" => \$::opt_tmpdir, - "tty" => \$::opt_tty, - "T" => \$::opt_retired, - "halt-on-error|halt=i" => \$::opt_halt_on_error, - "H=i" => \$::opt_retired, - "retries=i" => \$::opt_retries, - "dry-run|dryrun" => \$::opt_dryrun, - "progress" => \$::opt_progress, - "eta" => \$::opt_eta, - "arg-sep|argsep=s" => \$::opt_arg_sep, - "arg-file-sep|argfilesep=s" => \$::opt_arg_file_sep, - "trim=s" => \$::opt_trim, - "env=s" => \@::opt_env, - "plain" => \$::opt_plain, - "profile|J=s" => \@::opt_profile, - "pipe|spreadstdin" => \$::opt_pipe, - "recstart=s" => \$::opt_recstart, - "recend=s" => \$::opt_recend, - "regexp|regex" => \$::opt_regexp, - "remove-rec-sep|removerecsep|rrs" => \$::opt_remove_rec_sep, - "files|output-as-files|outputasfiles" => \$::opt_files, - "block|block-size|blocksize=s" => \$::opt_blocksize, - "tollef" => \$::opt_tollef, - "gnu" => \$::opt_gnu, - "xapply" => \$::opt_xapply, - "bibtex" => \$::opt_bibtex, + ("debug|D" => \$opt::D, + "xargs" => \$opt::xargs, + "m" => \$opt::m, + "X" => \$opt::X, + "v" => \@opt::v, + "joblog=s" => \$opt::joblog, + "results|result|res=s" => \$opt::results, + "resume" => \$opt::resume, + "silent" => \$opt::silent, + #"silent-error|silenterror" => \$opt::silent_error, + "keep-order|keeporder|k" => \$opt::k, + "group" => \$opt::group, + "g" => \$opt::retired, + "ungroup|u" => \$opt::u, + "null|0" => \$opt::0, + "quote|q" => \$opt::q, + "I=s" => \$opt::I, + "extensionreplace|er=s" => \$opt::U, + "U=s" => \$opt::retired, + "basenamereplace|bnr=s" => \$opt::basenamereplace, + "dirnamereplace|dnr=s" => \$opt::dirnamereplace, + "basenameextensionreplace|bner=s" => \$opt::basenameextensionreplace, + "seqreplace=s" => \$opt::seqreplace, + "jobs|j=s" => \$opt::P, + "load=s" => \$opt::load, + "noswap" => \$opt::noswap, + "max-line-length-allowed" => \$opt::max_line_length_allowed, + "number-of-cpus" => \$opt::number_of_cpus, + "number-of-cores" => \$opt::number_of_cores, + "use-cpus-instead-of-cores" => \$opt::use_cpus_instead_of_cores, + "shellquote|shell_quote|shell-quote" => \$opt::shellquote, + "nice=i" => \$opt::nice, + "timeout=i" => \$opt::timeout, + "tag" => \$opt::tag, + "tagstring=s" => \$opt::tagstring, + "onall" => \$opt::onall, + "nonall" => \$opt::nonall, + "filter-hosts|filterhosts|filter-host" => \$opt::filter_hosts, + "sshlogin|S=s" => \@opt::sshlogin, + "sshloginfile|slf=s" => \@opt::sshloginfile, + "controlmaster|M" => \$opt::controlmaster, + "return=s" => \@opt::return, + "trc=s" => \@opt::trc, + "transfer" => \$opt::transfer, + "cleanup" => \$opt::cleanup, + "basefile|bf=s" => \@opt::basefile, + "B=s" => \$opt::retired, + "workdir|wd=s" => \$opt::workdir, + "W=s" => \$opt::retired, + "tmpdir=s" => \$opt::tmpdir, + "tempdir=s" => \$opt::tmpdir, + "tty" => \$opt::tty, + "T" => \$opt::retired, + "halt-on-error|halt=i" => \$opt::halt_on_error, + "H=i" => \$opt::retired, + "retries=i" => \$opt::retries, + "dry-run|dryrun" => \$opt::dryrun, + "progress" => \$opt::progress, + "eta" => \$opt::eta, + "arg-sep|argsep=s" => \$opt::arg_sep, + "arg-file-sep|argfilesep=s" => \$opt::arg_file_sep, + "trim=s" => \$opt::trim, + "env=s" => \@opt::env, + "plain" => \$opt::plain, + "profile|J=s" => \@opt::profile, + "pipe|spreadstdin" => \$opt::pipe, + "recstart=s" => \$opt::recstart, + "recend=s" => \$opt::recend, + "regexp|regex" => \$opt::regexp, + "remove-rec-sep|removerecsep|rrs" => \$opt::remove_rec_sep, + "files|output-as-files|outputasfiles" => \$opt::files, + "block|block-size|blocksize=s" => \$opt::blocksize, + "tollef" => \$opt::tollef, + "gnu" => \$opt::gnu, + "xapply" => \$opt::xapply, + "bibtex" => \$opt::bibtex, # xargs-compatibility - implemented, man, testsuite - "max-procs|P=s" => \$::opt_P, - "delimiter|d=s" => \$::opt_d, - "max-chars|s=i" => \$::opt_s, - "arg-file|a=s" => \@::opt_a, - "no-run-if-empty|r" => \$::opt_r, - "replace|i:s" => \$::opt_i, - "E=s" => \$::opt_E, - "eof|e:s" => \$::opt_E, - "max-args|n=i" => \$::opt_n, - "max-replace-args|N=i" => \$::opt_N, - "colsep|col-sep|C=s" => \$::opt_colsep, - "help|h" => \$::opt_help, - "L=f" => \$::opt_L, - "max-lines|l:f" => \$::opt_l, - "interactive|p" => \$::opt_p, - "verbose|t" => \$::opt_verbose, - "version|V" => \$::opt_version, - "minversion|min-version=i" => \$::opt_minversion, - "show-limits|showlimits" => \$::opt_show_limits, - "exit|x" => \$::opt_x, + "max-procs|P=s" => \$opt::P, + "delimiter|d=s" => \$opt::d, + "max-chars|s=i" => \$opt::s, + "arg-file|a=s" => \@opt::a, + "no-run-if-empty|r" => \$opt::r, + "replace|i:s" => \$opt::i, + "E=s" => \$opt::E, + "eof|e:s" => \$opt::E, + "max-args|n=i" => \$opt::n, + "max-replace-args|N=i" => \$opt::N, + "colsep|col-sep|C=s" => \$opt::colsep, + "help|h" => \$opt::help, + "L=f" => \$opt::L, + "max-lines|l:f" => \$opt::l, + "interactive|p" => \$opt::p, + "verbose|t" => \$opt::verbose, + "version|V" => \$opt::version, + "minversion|min-version=i" => \$opt::minversion, + "show-limits|showlimits" => \$opt::show_limits, + "exit|x" => \$opt::x, # Semaphore - "semaphore" => \$::opt_semaphore, - "semaphoretimeout=i" => \$::opt_semaphoretimeout, - "semaphorename|id=s" => \$::opt_semaphorename, - "fg" => \$::opt_fg, - "bg" => \$::opt_bg, - "wait" => \$::opt_wait, + "semaphore" => \$opt::semaphore, + "semaphoretimeout=i" => \$opt::semaphoretimeout, + "semaphorename|id=s" => \$opt::semaphorename, + "fg" => \$opt::fg, + "bg" => \$opt::bg, + "wait" => \$opt::wait, # Shebang #!/usr/bin/parallel --shebang - "shebang|hashbang" => \$::opt_shebang, - "--internal-pipe-means-argfiles" => \$::opt_internal_pipe_means_argfiles, - "Y" => \$::opt_retired, - "skip-first-line" => \$::opt_skip_first_line, - "header=s" => \$::opt_header, + "shebang|hashbang" => \$opt::shebang, + "--internal-pipe-means-argfiles" => \$opt::internal_pipe_means_argfiles, + "Y" => \$opt::retired, + "skip-first-line" => \$opt::skip_first_line, + "header=s" => \$opt::header, ); } @@ -636,7 +636,7 @@ sub parse_options { @ARGV=read_options(); - if(defined $::opt_retired) { + if(defined $opt::retired) { ::error("-g has been retired. Use --group.\n"); ::error("-B has been retired. Use --bf.\n"); ::error("-T has been retired. Use --tty.\n"); @@ -646,84 +646,84 @@ sub parse_options { ::error("-H has been retired. Use --halt.\n"); ::wait_and_exit(255); } - if(@::opt_v) { $Global::verbose = $#::opt_v+1; } # Convert -v -v to v=2 - $Global::debug = (defined $::opt_D); - if(defined $::opt_X) { $Global::ContextReplace = 1; } - if(defined $::opt_silent) { $Global::verbose = 0; } - if(defined $::opt_k) { $Global::keeporder = 1; } - if(defined $::opt_group) { $Global::grouped = 1; } - if(defined $::opt_u) { $Global::grouped = 0; } - if(defined $::opt_0) { $/ = "\0"; } - if(defined $::opt_d) { my $e="sprintf \"$::opt_d\""; $/ = eval $e; } - if(defined $::opt_p) { $Global::interactive = $::opt_p; } - if(defined $::opt_q) { $Global::quoting = 1; } - if(defined $::opt_r) { $Global::ignore_empty = 1; } - if(defined $::opt_verbose) { $Global::stderr_verbose = 1; } - if(defined $::opt_I) { $Global::replace{'{}'} = $::opt_I; } - if(defined $::opt_U) { $Global::replace{'{.}'} = $::opt_U; } - if(defined $::opt_i) { - $Global::replace{'{}'} = $::opt_i eq "" ? "{}" : $::opt_i; + if(@opt::v) { $Global::verbose = $#opt::v+1; } # Convert -v -v to v=2 + $Global::debug = (defined $opt::D); + if(defined $opt::X) { $Global::ContextReplace = 1; } + if(defined $opt::silent) { $Global::verbose = 0; } + if(defined $opt::k) { $Global::keeporder = 1; } + if(defined $opt::group) { $Global::grouped = 1; } + if(defined $opt::u) { $Global::grouped = 0; } + if(defined $opt::0) { $/ = "\0"; } + if(defined $opt::d) { my $e="sprintf \"$opt::d\""; $/ = eval $e; } + if(defined $opt::p) { $Global::interactive = $opt::p; } + if(defined $opt::q) { $Global::quoting = 1; } + if(defined $opt::r) { $Global::ignore_empty = 1; } + if(defined $opt::verbose) { $Global::stderr_verbose = 1; } + if(defined $opt::I) { $Global::replace{'{}'} = $opt::I; } + if(defined $opt::U) { $Global::replace{'{.}'} = $opt::U; } + if(defined $opt::i) { + $Global::replace{'{}'} = $opt::i eq "" ? "{}" : $opt::i; } - if(defined $::opt_basenamereplace) { $Global::replace{'{/}'} = $::opt_basenamereplace; } - if(defined $::opt_dirnamereplace) { $Global::replace{'{//}'} = $::opt_dirnamereplace; } - if(defined $::opt_basenameextensionreplace) { - $Global::replace{'{/.}'} = $::opt_basenameextensionreplace; + if(defined $opt::basenamereplace) { $Global::replace{'{/}'} = $opt::basenamereplace; } + if(defined $opt::dirnamereplace) { $Global::replace{'{//}'} = $opt::dirnamereplace; } + if(defined $opt::basenameextensionreplace) { + $Global::replace{'{/.}'} = $opt::basenameextensionreplace; } - if(defined $::opt_seqreplace) { - $Global::replace{'{#}'} = $::opt_seqreplace; + if(defined $opt::seqreplace) { + $Global::replace{'{#}'} = $opt::seqreplace; } - if(defined $::opt_E) { $Global::end_of_file_string = $::opt_E; } - if(defined $::opt_n) { $Global::max_number_of_args = $::opt_n; } - if(defined $::opt_timeout) { $Global::timeoutq = TimeoutQueue->new($::opt_timeout); } - if(defined $::opt_tmpdir) { $ENV{'TMPDIR'} = $::opt_tmpdir; } - if(defined $::opt_help) { die_usage(); } - if(defined $::opt_colsep) { $Global::trim = 'lr'; } -# if(defined $::opt_header) { $::opt_colsep = defined $::opt_colsep ? $::opt_colsep : "\t"; } - if(defined $::opt_trim) { $Global::trim = $::opt_trim; } - if(defined $::opt_arg_sep) { $Global::arg_sep = $::opt_arg_sep; } - if(defined $::opt_arg_file_sep) { $Global::arg_file_sep = $::opt_arg_file_sep; } - if(defined $::opt_number_of_cpus) { print SSHLogin::no_of_cpus(),"\n"; wait_and_exit(0); } - if(defined $::opt_number_of_cores) { + if(defined $opt::E) { $Global::end_of_file_string = $opt::E; } + if(defined $opt::n) { $Global::max_number_of_args = $opt::n; } + if(defined $opt::timeout) { $Global::timeoutq = TimeoutQueue->new($opt::timeout); } + if(defined $opt::tmpdir) { $ENV{'TMPDIR'} = $opt::tmpdir; } + if(defined $opt::help) { die_usage(); } + if(defined $opt::colsep) { $Global::trim = 'lr'; } +# if(defined $opt::header) { $opt::colsep = defined $opt::colsep ? $opt::colsep : "\t"; } + if(defined $opt::trim) { $Global::trim = $opt::trim; } + if(defined $opt::arg_sep) { $Global::arg_sep = $opt::arg_sep; } + if(defined $opt::arg_file_sep) { $Global::arg_file_sep = $opt::arg_file_sep; } + if(defined $opt::number_of_cpus) { print SSHLogin::no_of_cpus(),"\n"; wait_and_exit(0); } + if(defined $opt::number_of_cores) { print SSHLogin::no_of_cores(),"\n"; wait_and_exit(0); } - if(defined $::opt_max_line_length_allowed) { + if(defined $opt::max_line_length_allowed) { print Limits::Command::real_max_length(),"\n"; wait_and_exit(0); } - if(defined $::opt_version) { version(); wait_and_exit(0); } - if(defined $::opt_bibtex) { bibtex(); wait_and_exit(0); } - if(defined $::opt_show_limits) { show_limits(); } - if(@::opt_sshlogin) { @Global::sshlogin = @::opt_sshlogin; } - if(@::opt_sshloginfile) { read_sshloginfiles(@::opt_sshloginfile); } - if(@::opt_return) { push @Global::ret_files, @::opt_return; } - if(not defined $::opt_recstart and - not defined $::opt_recend) { $::opt_recend = "\n"; } - if(not defined $::opt_blocksize) { $::opt_blocksize = "1M"; } - $::opt_blocksize = multiply_binary_prefix($::opt_blocksize); - if(defined $::opt_semaphore) { $Global::semaphore = 1; } - if(defined $::opt_semaphoretimeout) { $Global::semaphore = 1; } - if(defined $::opt_semaphorename) { $Global::semaphore = 1; } - if(defined $::opt_fg) { $Global::semaphore = 1; } - if(defined $::opt_bg) { $Global::semaphore = 1; } - if(defined $::opt_wait) { $Global::semaphore = 1; } - if(defined $::opt_minversion) { + if(defined $opt::version) { version(); wait_and_exit(0); } + if(defined $opt::bibtex) { bibtex(); wait_and_exit(0); } + if(defined $opt::show_limits) { show_limits(); } + if(@opt::sshlogin) { @Global::sshlogin = @opt::sshlogin; } + if(@opt::sshloginfile) { read_sshloginfiles(@opt::sshloginfile); } + if(@opt::return) { push @Global::ret_files, @opt::return; } + if(not defined $opt::recstart and + not defined $opt::recend) { $opt::recend = "\n"; } + if(not defined $opt::blocksize) { $opt::blocksize = "1M"; } + $opt::blocksize = multiply_binary_prefix($opt::blocksize); + if(defined $opt::semaphore) { $Global::semaphore = 1; } + if(defined $opt::semaphoretimeout) { $Global::semaphore = 1; } + if(defined $opt::semaphorename) { $Global::semaphore = 1; } + if(defined $opt::fg) { $Global::semaphore = 1; } + if(defined $opt::bg) { $Global::semaphore = 1; } + if(defined $opt::wait) { $Global::semaphore = 1; } + if(defined $opt::minversion) { print $Global::version,"\n"; - if($Global::version < $::opt_minversion) { + if($Global::version < $opt::minversion) { wait_and_exit(255); } else { wait_and_exit(0); } } - if($::opt_tollef and not $::opt_gnu and not $::opt_plain) { + if($opt::tollef and not $opt::gnu and not $opt::plain) { # Behave like tollef parallel (from moreutils) - $::opt_u = 1; + $opt::u = 1; $Global::grouped = 0; $Global::quoting = 1; - $::opt_q = 1; - if(defined $::opt_l) { - $::opt_load = $::opt_l; - $::opt_l = undef; + $opt::q = 1; + if(defined $opt::l) { + $opt::load = $opt::l; + $opt::l = undef; } - if(not defined $::opt_arg_sep) { + if(not defined $opt::arg_sep) { $Global::arg_sep = "--"; } if(not grep(/$Global::arg_sep/, @ARGV)) { @@ -731,51 +731,51 @@ sub parse_options { } } - if(defined $::opt_nonall) { + if(defined $opt::nonall) { # Append a dummy empty argument push @ARGV, $Global::arg_sep, ""; } - if(defined $::opt_tty) { + if(defined $opt::tty) { # Defaults for --tty: -j1 -u # Can be overridden with -jXXX -g - if(not defined $::opt_P) { - $::opt_P = 1; + if(not defined $opt::P) { + $opt::P = 1; } - if(not defined $::opt_group) { + if(not defined $opt::group) { $Global::grouped = 0; } } - if(@::opt_trc) { - push @Global::ret_files, @::opt_trc; - $::opt_transfer = 1; - $::opt_cleanup = 1; + if(@opt::trc) { + push @Global::ret_files, @opt::trc; + $opt::transfer = 1; + $opt::cleanup = 1; } - if(defined $::opt_l) { - if($::opt_l eq "-0") { + if(defined $opt::l) { + if($opt::l eq "-0") { # -l -0 (swallowed -0) - $::opt_l = 1; - $::opt_0 = 1; + $opt::l = 1; + $opt::0 = 1; $/ = "\0"; - } elsif ($::opt_l == 0) { + } elsif ($opt::l == 0) { # If not given (or if 0 is given) => 1 - $::opt_l = 1; + $opt::l = 1; } - $Global::max_lines = $::opt_l; + $Global::max_lines = $opt::l; $Global::max_number_of_args ||= $Global::max_lines; } # Read more than one arg at a time (-L, -N) - if(defined $::opt_L) { - $Global::max_lines = $::opt_L; + if(defined $opt::L) { + $Global::max_lines = $opt::L; $Global::max_number_of_args ||= $Global::max_lines; } - if(defined $::opt_N) { - $Global::max_number_of_args = $::opt_N; + if(defined $opt::N) { + $Global::max_number_of_args = $opt::N; $Global::ContextReplace = 1; } - if((defined $::opt_L or defined $::opt_N) + if((defined $opt::L or defined $opt::N) and - not ($::opt_xargs or $::opt_m)) { + not ($opt::xargs or $opt::m)) { $Global::ContextReplace = 1; } @@ -783,8 +783,8 @@ sub parse_options { $Global::replace{$_} = ::maybe_quote($Global::replace{$_}); } %Global::replace_rev = reverse %Global::replace; - if(defined $::opt_tag and not defined $::opt_tagstring) { - $::opt_tagstring = $Global::replace{'{}'}; + if(defined $opt::tag and not defined $opt::tagstring) { + $opt::tagstring = $Global::replace{'{}'}; } if(grep /^$Global::arg_sep$|^$Global::arg_file_sep$/o, @ARGV) { @@ -798,43 +798,43 @@ sub parse_options { $Global::semaphore ||= ($0 =~ m:(^|/)sem$:); # called as 'sem' if($Global::semaphore) { # A semaphore does not take input from neither stdin nor file - @::opt_a = ("/dev/null"); + @opt::a = ("/dev/null"); push(@Global::unget_argv, [Arg->new("")]); - $Semaphore::timeout = $::opt_semaphoretimeout || 0; - if(defined $::opt_semaphorename) { - $Semaphore::name = $::opt_semaphorename; + $Semaphore::timeout = $opt::semaphoretimeout || 0; + if(defined $opt::semaphorename) { + $Semaphore::name = $opt::semaphorename; } else { $Semaphore::name = `tty`; chomp $Semaphore::name; } - $Semaphore::fg = $::opt_fg; - $Semaphore::wait = $::opt_wait; + $Semaphore::fg = $opt::fg; + $Semaphore::wait = $opt::wait; $Global::default_simultaneous_sshlogins = 1; - if(not defined $::opt_P) { - $::opt_P = 1; + if(not defined $opt::P) { + $opt::P = 1; } - if($Global::interactive and $::opt_bg) { + if($Global::interactive and $opt::bg) { ::error("Jobs running in the ". "background cannot be interactive.\n"); ::wait_and_exit(255); } } - if(defined $::opt_eta) { - $::opt_progress = $::opt_eta; + if(defined $opt::eta) { + $opt::progress = $opt::eta; } parse_sshlogin(); parse_env_var(); - if(remote_hosts() and ($::opt_X or $::opt_m or $::opt_xargs)) { + if(remote_hosts() and ($opt::X or $opt::m or $opt::xargs)) { # As we do not know the max line length on the remote machine # long commands generated by xargs may fail # If opt_N is set, it is probably safe ::warning("Using -X or -m with --sshlogin may fail.\n"); } - if(not defined $::opt_P) { - $::opt_P = "100%"; + if(not defined $opt::P) { + $opt::P = "100%"; } open_joblog(); } @@ -851,7 +851,7 @@ sub parse_env_var { # Returns: N/A $Global::envvar = ""; my @vars = (); - for my $varstring (@::opt_env) { + for my $varstring (@opt::env) { # Split up --env VAR1,VAR2 push @vars, split /,/, $varstring; } @@ -876,13 +876,13 @@ sub parse_env_var { sub open_joblog { my $append = 0; - if($::opt_resume and not $::opt_joblog) { + if($opt::resume and not $opt::joblog) { ::error("--resume requires --joblog.\n"); ::wait_and_exit(255); } - if($::opt_joblog) { - if($::opt_resume) { - if(open(my $joblog_fh, "<", $::opt_joblog)) { + if($opt::joblog) { + if($opt::resume) { + if(open(my $joblog_fh, "<", $opt::joblog)) { # Read the joblog $append = <$joblog_fh>; # If there is a header: Open as append later while(<$joblog_fh>) { @@ -890,7 +890,7 @@ sub open_joblog { # This is 30% faster than set_job_already_run($1); vec($Global::job_already_run,$1,1) = 1; } else { - ::error("Format of '$::opt_joblog' is wrong.\n"); + ::error("Format of '$opt::joblog' is wrong.\n"); ::wait_and_exit(255); } } @@ -899,14 +899,14 @@ sub open_joblog { } if($append) { # Append to joblog - if(not open($Global::joblog, ">>", $::opt_joblog)) { - ::error("Cannot append to --joblog $::opt_joblog.\n"); + if(not open($Global::joblog, ">>", $opt::joblog)) { + ::error("Cannot append to --joblog $opt::joblog.\n"); ::wait_and_exit(255); } } else { # Overwrite the joblog - if(not open($Global::joblog, ">", $::opt_joblog)) { - ::error("Cannot write to --joblog $::opt_joblog.\n"); + if(not open($Global::joblog, ">", $opt::joblog)) { + ::error("Cannot write to --joblog $opt::joblog.\n"); ::wait_and_exit(255); } else { print $Global::joblog @@ -928,17 +928,17 @@ sub read_options { $ARGV[0]=~/^--hashbang /)) { # Program is called from #! line in script # remove --shebang-wrap if it is set - $::opt_shebang_wrap = ($ARGV[0]=~s/^--shebang-?wrap *//); + $opt::shebang_wrap = ($ARGV[0]=~s/^--shebang-?wrap *//); # remove --shebang if it is set - $::opt_shebang = ($ARGV[0]=~s/^--shebang *//); + $opt::shebang = ($ARGV[0]=~s/^--shebang *//); # remove --hashbang if it is set - $::opt_shebang .= ($ARGV[0]=~s/^--hashbang *//); - if($::opt_shebang) { + $opt::shebang .= ($ARGV[0]=~s/^--hashbang *//); + if($opt::shebang) { my $argfile = shell_quote_scalar(pop @ARGV); # exec myself to split $ARGV[0] into separate fields exec "$0 --skip-first-line -a $argfile @ARGV"; } - if($::opt_shebang_wrap) { + if($opt::shebang_wrap) { my $parser = shift @ARGV; my $scriptfile = shell_quote_scalar(shift @ARGV); # exec myself to split $ARGV[0] into separate fields @@ -947,22 +947,22 @@ sub read_options { } Getopt::Long::Configure("bundling","pass_through"); - # Check if there is a --profile to set @::opt_profile - GetOptions("profile|J=s" => \@::opt_profile, - "plain" => \$::opt_plain) || die_usage(); + # Check if there is a --profile to set @opt::profile + GetOptions("profile|J=s" => \@opt::profile, + "plain" => \$opt::plain) || die_usage(); my @ARGV_profile = (); my @ARGV_env = (); - if(not $::opt_plain) { + if(not $opt::plain) { # Add options from .parallel/config and other profiles my @config_profiles = ( "/etc/parallel/config", $ENV{'HOME'}."/.parallel/config", $ENV{'HOME'}."/.parallelrc"); my @profiles = @config_profiles; - if(@::opt_profile) { + if(@opt::profile) { # --profile overrides default profiles @profiles = (); - for my $profile (@::opt_profile) { + for my $profile (@opt::profile) { push @profiles, $ENV{'HOME'}."/.parallel/".$profile; } } @@ -1030,11 +1030,11 @@ sub read_args_from_command_line { } if($group eq $Global::arg_file_sep - or ($::opt_internal_pipe_means_argfiles and $::opt_pipe) + or ($opt::internal_pipe_means_argfiles and $opt::pipe) ) { # Group of file names on the command line. # Append args into -a - push @::opt_a, @group; + push @opt::a, @group; } elsif($group eq $Global::arg_sep) { # Group of arguments on the command line. # Put them into a file. @@ -1045,7 +1045,7 @@ sub read_args_from_command_line { print $outfh map { $_,$/ } @group; seek $outfh, 0, 0; # Append filehandle to -a - push @::opt_a, $outfh; + push @opt::a, $outfh; } else { ::die_bug("Unknown command line group: $group"); } @@ -1065,7 +1065,7 @@ sub read_args_from_command_line { sub cleanup { # Returns: N/A - if(@::opt_basefile) { cleanup_basefile(); } + if(@opt::basefile) { cleanup_basefile(); } } sub __QUOTING_ARGUMENTS_FOR_SHELL__ {} @@ -1205,7 +1205,7 @@ sub init_run_jobs { $Global::tty_taken = 0; $SIG{USR1} = \&list_running_jobs; $SIG{USR2} = \&toggle_progress; - if(@::opt_basefile) { setup_basefile(); } + if(@opt::basefile) { setup_basefile(); } } sub start_more_jobs { @@ -1234,11 +1234,11 @@ sub start_more_jobs { for my $sshlogin (values %Global::host) { debug("Running jobs before on ".$sshlogin->string().": ".$sshlogin->jobs_running()."\n"); - if($::opt_load and $sshlogin->loadavg_too_high()) { + if($opt::load and $sshlogin->loadavg_too_high()) { # The load is too high or unknown next; } - if($::opt_noswap and $sshlogin->swapping()) { + if($opt::noswap and $sshlogin->swapping()) { # The server is swapping next; } @@ -1246,7 +1246,7 @@ sub start_more_jobs { next; } while ($sshlogin->jobs_running() < $sshlogin->max_jobs_running()) { - if($Global::JobQueue->empty() and not $::opt_pipe) { + if($Global::JobQueue->empty() and not $opt::pipe) { last; } debug($sshlogin->string()." has ".$sshlogin->jobs_running() @@ -1278,7 +1278,7 @@ sub start_another_job { my $sshlogin = shift; # Do we have enough file handles to start another job? if(enough_file_handles()) { - if($Global::JobQueue->empty() and not $::opt_pipe) { + if($Global::JobQueue->empty() and not $opt::pipe) { # No more commands to run debug("Not starting: JobQueue empty\n"); return 0; @@ -1295,7 +1295,7 @@ sub start_another_job { debug("Command to run on '".$job->sshlogin()."': '".$job->replaced()."'\n"); if($job->start()) { $Global::running{$job->pid()} = $job; - if($::opt_pipe) { + if($opt::pipe) { push(@Global::virgin_jobs,$job); } debug("Started as seq ",$job->seq()," pid:",$job->pid(),"\n"); @@ -1335,7 +1335,7 @@ sub init_progress { sub drain_job_queue { # Returns: N/A $Private::first_completed ||= time; - if($::opt_progress) { + if($opt::progress) { print $Global::original_stderr init_progress(); } my $last_header=""; @@ -1344,14 +1344,14 @@ sub drain_job_queue { while($Global::total_running > 0) { debug($Global::total_running, "==", scalar keys %Global::running," slots: ", $Global::max_jobs_running); - if($::opt_pipe) { + if($opt::pipe) { # When using --pipe sometimes file handles are not closed properly for my $job (values %Global::running) { my $fh = $job->stdin(); close $fh; } } - if($::opt_progress) { + if($opt::progress) { my %progress = progress(); if($last_header ne $progress{'header'}) { print $Global::original_stderr "\n", $progress{'header'}, "\n"; @@ -1377,7 +1377,7 @@ sub drain_job_queue { } while ($Global::total_running > 0 or not $Global::start_no_new_jobs and not $Global::JobQueue->empty()); - if($::opt_progress) { + if($opt::progress) { my %progress = progress(); print $Global::original_stderr "\r", $progress{'status'}, "\n"; } @@ -1386,8 +1386,8 @@ sub drain_job_queue { sub toggle_progress { # Turn on/off progress view # Returns: N/A - $::opt_progress = not $::opt_progress; - if($::opt_progress) { + $opt::progress = not $opt::progress; + if($opt::progress) { print $Global::original_stderr init_progress(); } } @@ -1411,7 +1411,7 @@ sub progress { $Global::host{$w}->max_jobs_running()."\n"; } my $eta = ""; - if($::opt_eta) { + if($opt::eta) { my $completed = 0; for(@workers) { $completed += $Global::host{$_}->jobs_completed() } if($completed) { @@ -1596,7 +1596,7 @@ sub get_job_with_sshlogin { } } $job->set_sshlogin($sshlogin); - if($::opt_retries and $clean_command and + if($opt::retries and $clean_command and $job->failed_here()) { # This command with these args failed for this sshlogin my ($no_of_failed_sshlogins,$min_failures) = $job->min_failed(); @@ -1682,18 +1682,18 @@ sub parse_sshlogin { $Global::host{$sshlogin->string()} = $sshlogin; } debug("sshlogin: ", my_dump(%Global::host),"\n"); - if($::opt_transfer or @::opt_return or $::opt_cleanup or @::opt_basefile) { + if($opt::transfer or @opt::return or $opt::cleanup or @opt::basefile) { if(not remote_hosts()) { # There are no remote hosts - if(@::opt_trc) { + if(@opt::trc) { ::warning("--trc ignored as there are no remote --sshlogin.\n"); - } elsif (defined $::opt_transfer) { + } elsif (defined $opt::transfer) { ::warning("--transfer ignored as there are no remote --sshlogin.\n"); - } elsif (@::opt_return) { + } elsif (@opt::return) { ::warning("--return ignored as there are no remote --sshlogin.\n"); - } elsif (defined $::opt_cleanup) { + } elsif (defined $opt::cleanup) { ::warning("--cleanup ignored as there are no remote --sshlogin.\n"); - } elsif (@::opt_basefile) { + } elsif (@opt::basefile) { ::warning("--basefile ignored as there are no remote --sshlogin.\n"); } } @@ -1717,7 +1717,7 @@ sub setup_basefile { my $sshcmd = $sshlogin->sshcommand(); my $serverlogin = $sshlogin->serverlogin(); my $rsync_opt = "-rlDzR -e".shell_quote_scalar($sshcmd); - for my $file (@::opt_basefile) { + for my $file (@opt::basefile) { my $f = $file; my $relpath = ($f !~ m:^/:); # Is the path relative? # Use different subdirs depending on abs or rel path @@ -1740,7 +1740,7 @@ sub cleanup_basefile { if($sshlogin->string() eq ":") { next } my $sshcmd = $sshlogin->sshcommand(); my $serverlogin = $sshlogin->serverlogin(); - for my $file (@::opt_basefile) { + for my $file (@opt::basefile) { $cmd .= "$sshcmd $serverlogin rm -f ".shell_quote_scalar(shell_quote_scalar($file))."&"; } } @@ -1798,7 +1798,7 @@ sub reaper { if(not $job->should_be_retried()) { # Force printing now if the job failed and we are going to exit my $print_now = ($job->exitstatus() and - $::opt_halt_on_error and $::opt_halt_on_error == 2); + $opt::halt_on_error and $opt::halt_on_error == 2); if($Global::keeporder and not $print_now) { $Private::print_later{$job->seq()} = $job; $Private::job_end_sequence ||= 1; @@ -1816,8 +1816,8 @@ sub reaper { if($job->exitstatus()) { # The jobs had a exit status <> 0, so error $Global::exitstatus++; - if($::opt_halt_on_error) { - if($::opt_halt_on_error == 1) { + if($opt::halt_on_error) { + if($opt::halt_on_error == 1) { # If halt on error == 1 we should gracefully exit print $Global::original_stderr ("$Global::progname: Starting no more jobs. ", @@ -1826,7 +1826,7 @@ sub reaper { $job->replaced(),"\n"); $Global::start_no_new_jobs++; $Global::halt_on_error_exitstatus = $job->exitstatus(); - } elsif($::opt_halt_on_error == 2) { + } elsif($opt::halt_on_error == 2) { # If halt on error == 2 we should exit immediately print $Global::original_stderr ("$Global::progname: This job failed:\n", @@ -1950,7 +1950,7 @@ sub die_bug { sub version { # Returns: N/A - if($::opt_tollef and not $::opt_gnu) { + if($opt::tollef and not $opt::gnu) { print "WARNING: YOU ARE USING --tollef. IF THINGS ARE ACTING WEIRD USE --gnu.\n"; } print join("\n", @@ -1969,7 +1969,7 @@ sub version { sub bibtex { # Returns: N/A - if($::opt_tollef and not $::opt_gnu) { + if($opt::tollef and not $opt::gnu) { print "WARNING: YOU ARE USING --tollef. IF THINGS ARE ACTING WEIRD USE --gnu.\n"; } print join("\n", @@ -2078,7 +2078,7 @@ sub usleep { my $secs = shift; ::debug(int($secs),"ms "); select(undef, undef, undef, $secs/1000); - if($::opt_timeout) { + if($opt::timeout) { ::debug(my_dump($Global::timeoutq)); $Global::timeoutq->process_timeouts(); } @@ -2454,7 +2454,7 @@ sub max_loadavg { my $self = shift; if(not defined $self->{'max_loadavg'}) { $self->{'max_loadavg'} = - $self->compute_max_loadavg($::opt_load); + $self->compute_max_loadavg($opt::load); } ::debug("max_loadavg: ".$self->string()." ".$self->{'max_loadavg'}); return $self->{'max_loadavg'}; @@ -2524,7 +2524,7 @@ sub set_time_to_login { sub max_jobs_running { my $self = shift; if(not defined $self->{'max_jobs_running'}) { - my $nproc = $self->compute_number_of_processes($::opt_P); + my $nproc = $self->compute_number_of_processes($opt::P); $self->set_max_jobs_running($nproc); } return $self->{'max_jobs_running'}; @@ -2602,12 +2602,12 @@ sub processes_available_by_system_limit { my $before_getting_arg = time; if($Global::semaphore) { # Skip - } elsif(defined $::opt_retries and $count_jobs_already_read) { + } elsif(defined $opt::retries and $count_jobs_already_read) { # For retries we may need to run all jobs on this sshlogin # so include the already read jobs for this sshlogin $count_jobs_already_read--; } else { - if($::opt_X or $::opt_m) { + if($opt::X or $opt::m) { # The arguments may have to be re-spread over several jobslots # So pessimistically only read one arg per jobslot # instead of a full commandline @@ -2815,14 +2815,14 @@ sub ncpus { my $sshcmd = $self->sshcommand(); my $serverlogin = $self->serverlogin(); if($serverlogin eq ":") { - if($::opt_use_cpus_instead_of_cores) { + if($opt::use_cpus_instead_of_cores) { $self->{'ncpus'} = no_of_cpus(); } else { $self->{'ncpus'} = no_of_cores(); } } else { my $ncpu; - if($::opt_use_cpus_instead_of_cores) { + if($opt::use_cpus_instead_of_cores) { $ncpu = qx(echo|$sshcmd $serverlogin parallel --number-of-cpus); } else { $ncpu = qx(echo|$sshcmd $serverlogin parallel --number-of-cores); @@ -3088,7 +3088,7 @@ sub sshcommand_of_sshlogin { $sshcmd = $1; $serverlogin = $2; } else { # Normal ssh - if($::opt_controlmaster) { + if($opt::controlmaster) { # Use control_path to make ssh faster my $control_path = $self->control_path_dir()."/ssh-%r@%h:%p"; $sshcmd = "ssh -S ".$control_path; @@ -3250,13 +3250,13 @@ sub openresultsfile { my $self = shift; my $args_as_filename = $self->{'commandline'}->args_as_filename(); my ($outfh,$errfh,$name); - $name = $::opt_results."stdout\t".$args_as_filename; + $name = $opt::results."stdout\t".$args_as_filename; if(not open($outfh,"+>",$name)) { ::error("Cannot write to `$name'.\n"); ::wait_and_exit(255); } $self->set_stdoutfilename($name); - $name = $::opt_results."stderr\t".$args_as_filename; + $name = $opt::results."stderr\t".$args_as_filename; if(not open($errfh,"+>",$name)) { ::error("Cannot write to `$name'.\n"); ::wait_and_exit(255); @@ -3540,7 +3540,7 @@ sub sshlogin_wrap { . q{ setenv PARALLEL_PID '$PARALLEL_PID' } . q{ || echo PARALLEL_SEQ='$PARALLEL_SEQ'\;export PARALLEL_SEQ\; } . q{ PARALLEL_PID='$PARALLEL_PID'\;export PARALLEL_PID` ;' }); - if($::opt_workdir) { + if($opt::workdir) { $self->{'sshlogin_wrap'} = ($pre . "$sshcmd $serverlogin $parallel_env " . ::shell_quote_scalar("cd ".$self->workdir()." && ") @@ -3560,7 +3560,7 @@ sub transfer { my $self = shift; my @transfer = (); $self->{'transfersize'} = 0; - if($::opt_transfer) { + if($opt::transfer) { for my $record (@{$self->{'commandline'}{'arg_list'}}) { # Merge arguments from records into args for my $arg (@$record) { @@ -3653,7 +3653,7 @@ sub sshreturn { my @cmd = (); my $rsync_destdir = ($relpath ? "./" : "/"); my $ret_file = $file; - my $remove = $::opt_cleanup ? "--remove-source-files" : ""; + my $remove = $opt::cleanup ? "--remove-source-files" : ""; # If relative path: prepend workdir/./ to avoid problems # if the dir contains ':' and to get the right relative return path my $replaced = ($relpath ? $self->workdir()."/./" : "") . $file; @@ -3698,7 +3698,7 @@ sub cleanup { # Returns: # Files to remove at cleanup my $self = shift; - if($::opt_cleanup) { + if($opt::cleanup) { my @transfer = $self->transfer(); return @transfer; } else { @@ -3712,13 +3712,13 @@ sub workdir { my $self = shift; if(not defined $self->{'workdir'}) { my $workdir; - if(defined $::opt_workdir) { - if($::opt_workdir eq ".") { + if(defined $opt::workdir) { + if($opt::workdir eq ".") { # . means current dir my $home = $ENV{'HOME'}; eval 'use Cwd'; my $cwd = cwd(); - $::opt_workdir = $cwd; + $opt::workdir = $cwd; if($home) { # If homedir exists: remove the homedir from # workdir if cwd starts with homedir @@ -3734,16 +3734,16 @@ sub workdir { my ($parent_dev, $parent_ino) = (stat($parent))[0,1]; if($parent_dev == $home_dev and $parent_ino == $home_ino) { # dev and ino is the same: We found the homedir. - $::opt_workdir = join("/",@dir_parts); + $opt::workdir = join("/",@dir_parts); last; } } } - } elsif($::opt_workdir eq "...") { + } elsif($opt::workdir eq "...") { $workdir = ".parallel/tmp/" . ::hostname() . "-" . $$ . "-" . $self->seq(); } else { - $workdir = $::opt_workdir; + $workdir = $opt::workdir; # Rsync treats /./ special. We dont want that $workdir =~ s:/\./:/:g; # Remove /./ $workdir =~ s:/+$::; # Remove ending / if any @@ -3794,7 +3794,7 @@ sub start { local (*IN,*OUT,*ERR); my $pid; - if($::opt_results) { + if($opt::results) { $job->openresultsfile(); } elsif($Global::grouped) { my ($outfh,$errfh,$name); @@ -3802,7 +3802,7 @@ sub start { # To avoid the cleanup unlink the files immediately (but keep them open) ($outfh,$name) = ::tempfile(SUFFIX => ".par"); $job->set_stdoutfilename($name); - $::opt_files or unlink $name; + $opt::files or unlink $name; ($errfh,$name) = ::tempfile(SUFFIX => ".par"); unlink $name; @@ -3814,7 +3814,7 @@ sub start { (*OUT,*ERR)=(*STDOUT,*STDERR); } - if(($::opt_dryrun or $Global::verbose) and not $Global::grouped) { + if(($opt::dryrun or $Global::verbose) and not $Global::grouped) { if($Global::verbose <= 1) { print OUT $job->replaced(),"\n"; } else { @@ -3822,14 +3822,14 @@ sub start { print OUT $command,"\n"; } } - if($::opt_dryrun) { + if($opt::dryrun) { $command = "true"; } $ENV{'PARALLEL_SEQ'} = $job->seq(); $ENV{'PARALLEL_PID'} = $$; ::debug("$Global::total_running processes. Starting (" . $job->seq() . "): $command\n"); - if($::opt_pipe) { + if($opt::pipe) { my ($in); # The eval is needed to catch exception from open3 eval { @@ -3838,7 +3838,7 @@ sub start { 1; }; $job->set_stdin($in); - } elsif(@::opt_a and not $Global::stdin_in_opt_a and $job->seq() == 1 + } elsif(@opt::a and not $Global::stdin_in_opt_a and $job->seq() == 1 and $job->sshlogin()->string() eq ":") { # Give STDIN to the first job if using -a (but only if running # locally - otherwise CTRL-C does not work for other jobs Bug#36585) @@ -3852,7 +3852,7 @@ sub start { # Re-open to avoid complaining open STDIN, "<&", $Global::original_stdin or ::die_bug("dup-\$Global::original_stdin: $!"); - } elsif ($::opt_tty and not $Global::tty_taken and -c "/dev/tty" and + } elsif ($opt::tty and not $Global::tty_taken and -c "/dev/tty" and open(my $devtty_fh, "<", "/dev/tty")) { # Give /dev/tty to the command if no one else is using it *IN = $devtty_fh; @@ -3877,9 +3877,9 @@ sub start { $Global::total_started++; $job->set_pid($pid); $job->set_starttime(); - if($::opt_timeout) { + if($opt::timeout) { # Timeout must be set before inserting into queue - $job->set_timeout($::opt_timeout); + $job->set_timeout($opt::timeout); $Global::timeoutq->insert($job); } return $job; @@ -3906,7 +3906,7 @@ sub should_be_retried { # 0 - do not retry # 1 - job queued for retry my $self = shift; - if (not $::opt_retries) { + if (not $opt::retries) { return 0; } if(not $self->exitstatus()) { @@ -3916,7 +3916,7 @@ sub should_be_retried { } else { # The job failed. Should it be retried? $self->add_failed_here(); - if($self->total_failed() == $::opt_retries) { + if($self->total_failed() == $opt::retries) { # This has been retried enough return 0; } else { @@ -3958,7 +3958,7 @@ sub print { $self->set_job_in_joblog(); } - if(($::opt_dryrun or $Global::verbose) and $Global::grouped) { + if(($opt::dryrun or $Global::verbose) and $Global::grouped) { if($Global::verbose <= 1) { print STDOUT $self->replaced(),"\n"; } else { @@ -3974,7 +3974,7 @@ sub print { if($Global::debug) { print STDERR "ERR:\n"; } - if($::opt_tag or defined $::opt_tagstring) { + if($opt::tag or defined $opt::tagstring) { my $tag = $self->tag(); while(<$err>) { print STDERR $tag,$_; @@ -3987,7 +3987,7 @@ sub print { } flush STDERR; - if($::opt_files) { + if($opt::files) { print STDOUT $self->{'stdoutfilename'},"\n"; } else { my $buf; @@ -3995,7 +3995,7 @@ sub print { if($Global::debug) { print STDOUT "OUT:\n"; } - if($::opt_tag or defined $::opt_tagstring) { + if($opt::tag or defined $opt::tagstring) { my $tag = $self->tag(); while(<$out>) { print STDOUT $tag,$_; @@ -4017,7 +4017,7 @@ sub tag { my $self = shift; if(not defined $self->{'tag'}) { $self->{'tag'} = $self->{'commandline'}-> - replace_placeholders($::opt_tagstring,0)."\t"; + replace_placeholders($opt::tagstring,0)."\t"; } return $self->{'tag'}; } @@ -4084,11 +4084,11 @@ sub new { ($sum,$len->{'no_args'},$len->{'context'},$len->{'contextgroups'}, %replacecount) = number_of_replacements($command,$context_replace); } - if(defined $::opt_tagstring) { + if(defined $opt::tagstring) { my ($dummy1,$dummy2,$dummy3,$dummy4,%repcount) = - number_of_replacements($::opt_tagstring,$context_replace); + number_of_replacements($opt::tagstring,$context_replace); # Merge %repcount with %replacecount to get the keys - # for replacing replacement strings in $::opt_tagstring + # for replacing replacement strings in $opt::tagstring # The number, however, does not matter. for (keys %repcount) { $replacecount{$_} ||= 0; @@ -4129,7 +4129,7 @@ sub populate { # Add arguments from arg_queue until the number of arguments or # max line length is reached my $self = shift; - if($::opt_pipe) { + if($opt::pipe) { # Do no read any args $self->push([Arg->new("")]); return; @@ -4167,7 +4167,7 @@ sub populate { } } } - if(($::opt_m or $::opt_X) and not $CommandLine::already_spread + if(($opt::m or $opt::X) and not $CommandLine::already_spread and $self->{'arg_queue'}->empty() and $Global::max_jobs_running) { # -m or -X and EOF => Spread the arguments over all jobslots # (unless they are already spread) @@ -4310,12 +4310,12 @@ sub len { } } } - if($::opt_nice) { + if($opt::nice) { # Pessimistic length if --nice is set # Worse than worst case: every char needs to be quoted with \ $len *= 2; } - if($::opt_shellquote) { + if($opt::shellquote) { # Pessimistic length if --shellquote is set # Worse than worst case: every char needs to be quoted with \ twice $len *= 4; @@ -4408,14 +4408,14 @@ sub replaced { ::wait_and_exit(255); } } - if($::opt_nice) { + if($opt::nice) { # Prepend nice -n19 $SHELL -c # and quote - $self->{'replaced'} = nice() ." -n" . $::opt_nice . " " + $self->{'replaced'} = nice() ." -n" . $opt::nice . " " . $ENV{SHELL}." -c " . ::shell_quote_scalar($self->{'replaced'}); } - if($::opt_shellquote) { + if($opt::shellquote) { # Prepend echo # and quote twice $self->{'replaced'} = "echo " . @@ -4643,7 +4643,7 @@ sub new { return bless { 'unget' => \@unget, 'command' => $command, - 'arg_queue' => RecordQueue->new($read_from,$::opt_colsep), + 'arg_queue' => RecordQueue->new($read_from,$opt::colsep), 'context_replace' => $context_replace, 'max_number_of_args' => $max_number_of_args, 'size' => undef, @@ -4668,7 +4668,7 @@ sub get { ); $cmd_line->populate(); ::debug("cmd_line->number_of_args ".$cmd_line->number_of_args()."\n"); - if($::opt_pipe) { + if($opt::pipe) { if($cmd_line->replaced() eq "") { # Empty command - pipe requires a command ::error("--pipe must have a command to pipe into (e.g. 'cat').\n"); @@ -4741,15 +4741,15 @@ sub max_length { # Returns: # number of chars on the longest command line allowed if(not $Limits::Command::line_max_len) { - if($::opt_s) { - if(is_acceptable_command_line_length($::opt_s)) { - $Limits::Command::line_max_len = $::opt_s; + if($opt::s) { + if(is_acceptable_command_line_length($opt::s)) { + $Limits::Command::line_max_len = $opt::s; } else { # -s is too long: Find the correct - $Limits::Command::line_max_len = binary_find_max_length(0,$::opt_s); + $Limits::Command::line_max_len = binary_find_max_length(0,$opt::s); } - if($::opt_s <= $Limits::Command::line_max_len) { - $Limits::Command::line_max_len = $::opt_s; + if($opt::s <= $Limits::Command::line_max_len) { + $Limits::Command::line_max_len = $opt::s; } else { ::warning("Value for -s option ", "should be < $Limits::Command::line_max_len.\n"); @@ -4902,7 +4902,7 @@ sub get { my $line = $arg->orig(); ::debug("line='$line'\n"); if($line ne "") { - for my $s (split /$::opt_colsep/o, $line, -1) { + for my $s (split /$opt::colsep/o, $line, -1) { push @out_record, Arg->new($s); } } else { @@ -4938,7 +4938,7 @@ sub new { my $fhs = shift; for my $fh (@$fhs) { if(-t $fh) { - if($::opt_tollef and not $::opt_gnu) { + if($opt::tollef and not $opt::gnu) { ::warning("YOU ARE USING --tollef. " . "IF THINGS ARE ACTING WEIRD USE --gnu."); } @@ -4956,7 +4956,7 @@ sub new { sub get { my $self = shift; - if($::opt_xapply) { + if($opt::xapply) { return $self->xapply_get(); } else { return $self->nest_get(); @@ -5354,8 +5354,8 @@ sub acquire { $sleep = ($sleep < 1000) ? ($sleep * 1.1) : ($sleep); # Random to avoid every sleeping job waking up at the same time ::usleep(rand()*$sleep); - if(defined($::opt_timeout) and - $start_time + $::opt_timeout > time) { + if(defined($opt::timeout) and + $start_time + $opt::timeout > time) { # Acquire the lock anyway if(not -e $self->{'idfile'}) { open (my $fh, ">", $self->{'idfile'}) or @@ -5463,6 +5463,6 @@ sub mkdir_or_die { } # Keep perl -w happy -$::opt_x = $Semaphore::timeout = $Semaphore::wait = $::opt_shebang = +$opt::x = $Semaphore::timeout = $Semaphore::wait = $opt::shebang = 0; diff --git a/testsuite/wanted-results/parallel-local21 b/testsuite/wanted-results/parallel-local21 index 46be55c1..0e8e4d63 100644 --- a/testsuite/wanted-results/parallel-local21 +++ b/testsuite/wanted-results/parallel-local21 @@ -47,6 +47,7 @@ Shebang from perl with args Shebang from perl with args 5 ### Test --shebang-wrap --pipe with parser options +Suboptimal Shebang from perl with args 1 Shebang from perl with args @@ -55,10 +56,15 @@ Shebang from perl with args 4 Shebang from perl with args 5 +Optimal Shebang from perl with args -/tmp/in12 +1 Shebang from perl with args -/tmp/in45 +2 +Shebang from perl with args +4 +Shebang from perl with args +5 ### Same as Shebang from perl with args 1