Question

In a bash script I would like to assign the output of the times builtin to an array variable, but I found no better way than

tempnam=/tmp/aaa_$$_$RANDOM
times > ${tempnam}
mapfile -t times_a < ${tempnam}

I write the output to a temp file and read it back in array times_a because pipelines or $(times) would execute in a subshell and return the wrong values.

Any better solution without the temp file?

Answer 1

The fundamental problem that you need to solve is how to get both the execution of time and the variable assignment to happen in the same shell, without a temporary file. Almost every method Bash provides of piping the output of one thing to another, or capturing the output of a command, has one side working in a subshell.

Here is one way you can do it without a temporary file, but I’ll warn you, it’s not pretty, it’s not portable to other shells, and it requires at least Bash 4:

coproc co { cat; }; times 1>&${co[1]}; eval "exec ${co[1]}>&-"; mapfile -tu ${co[0]} times_a

I’ll break this down for you:

coproc co { cat; }

This creates a coprocess; a process which runs in the background, but you are given pipes to talk to its standard input and standard output, which are the FDs ${co[0]} (standard out of cat) and ${co[1]} (standard in of cat). The commands are executed in a subshell, so we can’t do either of our goals in there (running times or reading into a variable), but we can use cat to simply pass the input through to the output, and then use that pipe to talk to times and mapfile in the current shell.

times >&${co[1]};

Run times, redirecting its standard out to the standard in of the cat command.

eval "exec ${co[1]}>&-"

Close the input end of the cat command. If we don’t do this, cat will continue waiting for input, keeping its output open, and mapfile will continue waiting for that, causing your shell to hang. exec, when passed no commands, simply applies its redirections to the current shell; redirecting to - closes an FD. We need to use eval because Bash seems to have trouble with exec ${co[1]}>&-, interpreting the FD as the command instead of part of the redirection; using eval allows that variable to be substituted first, and then then executed.

mapfile -tu ${co[0]} times_a

Finally we actually read the data from the standard out of the coprocess. We’ve managed to run both the times and the mapfile command in this shell, and used no temporary files, though we did use a temporary process as a pipeline between the two commands.

Note that this has a subtle race. If you execute these commands one by one, instead of all as one command, the last one fails; because when you close cats standard in, it exits, causing the coprocess to exit and FDs to be closed. It appears that when executed all on one line, mapfile is executed quickly enough that the coprocess is still open when it runs, and thus it can read from the pipe; but I may be getting lucky. I haven’t figured out a good way around this.

All told, it’s much simpler just to write out the temp file. I would use mktemp to generate a filename, and if you’re in a script, add a trap to ensure that you clean up your tempfile before exiting:

tempnam=$(mktemp)
trap "rm '$tempnam'" EXIT
times > ${tempnam}
mapfile -t times_a < ${tempnam}