Shell Programming and Scripting

I was looking for samething more compact than this:

Code:

$: a=`ls`
$: declare -i num=0
$: for x in $a; do num=$num+1;  echo "$num ..... $x"; echo "$num       $x">fl_tmp; done

And jump in my mind to use parallel but look at the performance:

Code:

$: a=`ls`
$: time for n in {1..10}; do parallel 'printf "%i      %s\n" {#} {} > fl_tmp; echo {#}.....{}' ::: $a; done

real	0m7.120s
user	0m4.260s
sys	0m1.680s

$: time for n in {1..10}; do declare -i num=0; for x in $a; do num=$num+1;  echo "$num ..... $x"; echo "$num       $x">fl_tmp; done; done

real	0m0.748s
user	0m0.060s
sys	0m0.100s

Maybee it was expectable that parallel in this occasion could not give the best performance, but the result is really depressive, isn't it!

So if you got a compact and clever way to do that let me know
or if you understand what is so wrong with parallel let me know as well!

Sticking 'parallel' in front of a line doesn't make it go faster. You haven't made the loop run in parallel -- you're running 'parallel' 10 times.

I don't think you can parallelize this much, there's not much there, there's lots of I/O you don't want to overlap each other, the order of output might get mixed up, 'parallel' is not a shell keyword but launches whole new entire shells, and each loop depends on the last anyway.

Look my code dose preciselly what I intended to do:
The repetition of 10 time is for testing porpouse.

It was just an experiment.
It was something like a tee command where each argument was process in parallel.
The command take each argument in a$, making a new job that process it in two different layout.

Any good idea for obtaing (maybee using "xargs" or something) a quality and compact code, to use instead of the first option?

For me it was an interesting experiment. I belived that initialising new process was not so much expensive in time.

There's a lot involved in splitting off processes, yes. Allocating and destroying lots of memory. Looking up paths, opening files, parsing libraries. Stopping and starting the "universe" (program context) multiple times. If you create a process, it's a good idea to let it do as much work as possible before killing it or getting in its way.

xargs isn't terribly useful here, again, it ends up creating processes so suffers the same drawback. It's nice for when you need to create processes, or can bundle multiple calls into one big call.

For high compactness, fewer externals, and the ability to handle spaces in filenames:

Code:

N=0 ; for x in * ; do printf "%d %s\n" $((++N)) "$x" ; done

To bundle it all in one enormous printf, which might be more i/o efficient:

Code:

s=""
n=0
for x in * ; do  s="$s $x $((++n))" ; done

for n in {1..10} ; do printf "%d %s\n" $s ; done