Efficiently evaluating a held expression directly from a list

Question

I am able to evaluate a held expression that I have put on a list by:

ReleaseHold[expressionList[[1]]]

and

expression1 := ReleaseHold[expressionList[[1]]];
expression1

Using expression1 is more efficient than ReleaseHold[expressionList[[1]]], but I loose the ability to use it in Map (or so I think). I would like to be able to use the held expression directly from a list, i.e. expressionList[[1]] .

Any suggestions?

A test harness follows. You can change the expressions being tested see AddExpression[1];, which is currently 1 to Pause[$TimeUnit], Range[1, 1000], ... .

---

SetAttributes[AddExpression, HoldAll];
AddExpression[expression_] := AppendTo[expressionList, Hold[expression]];

EvaluateExpressions[] :=
 (
  expression1 := ReleaseHold[expressionList[[1]]];
  expression2 := ReleaseHold[expressionList[[2]]];

  totalRunTimeDo = AbsoluteTiming[
     Do[(expression1; expression2;), {iterations}];
     ][[1]];

  Print["Do      total: ", totalRunTimeDo, "   per iteration: ", 
   totalRunTimeDo/ iterations];

  (* -------------------------------------------------*)

  totalRunTimeDoMap = AbsoluteTiming[
     Do[Map[ReleaseHold[#] &, expressionList], {iterations}];
     ][[1]];

  Print["DoMap   total: ", totalRunTimeDoMap, "   per iteration: ", 
   totalRunTimeDoMap/ iterations];
  )

iterations = 10000000;
expressionList = {};
AddExpression[1];
AddExpression[1];
EvaluateExpressions[];

Results:

Do      total: 12.526729   per iteration: 1.2526729*10^-6
DoMap   total: 19.018290   per iteration: 1.9018290*10^-6

Obviously, you can see why I want to pull it directly from the list.

Background

The above test harness was boiled down from something I was using to benchmark code.

iterations = 10000000;
expressionList = {Hold[1], Hold[1]};

I started here:

expressionTimingsByIteration =
  Map[Map[AbsoluteTiming[ReleaseHold[#]][[1]] &, expressionList] &,
   Range[1, iterations]];
iterationsTimingsByExpression = Transpose[expressionTimingsByIteration];

Refactored to this:

iterationsTimingsByExpression =
  Map[
   (
     expression := ReleaseHold[#];
     Map[AbsoluteTiming[expression][[1]] &, Range[1, iterations]] 
     ) &
   , expressionList];

However evaluating code whose AbsoluteTiming < $TimeUnit is prone to error. Which I refactored for those cases to:

totalTimingByExpression =
  Map[
   (
     expression := ReleaseHold[#];
     AbsoluteTiming[Do[expression, {iterations}]][[1]]
     ) &, expressionList];
totalTimingByExpression

Answer 1

What costs you so much time is your unnecessary packaging of ReleaseHold into an anonymous function. ReleaseHold[#]& is semantically identical to ReleaseHold but much more time expensive. If you replace it with ReleaseHold, the map version is only slightly slower than the direct version (and I guess that's because of the Map logic which has to work with lists of arbitrary length).

Here's what I get after removing the unnecessary anonymous function:

Do      total: 22.849438   per iteration: 2.2849438*10^-6
DoMap   total: 24.159825   per iteration: 2.4159825*10^-6

Answer 2

I think that, first, there is a simpler way to do what you intend, and second, the benchmarks and timing results will significantly depend on the total length of the expression list. For small expression lists, a large part of the total running time is not related to expressions evaluation, but to the overall overhead of things like CompoundExpression etc.

First, here is how I'd do this:

ClearAll[$expressionList, addExpression, clearExpressions];
$expressionList = Hold[];
SetAttributes[addExpression, HoldAll];
addExpression[expression_] :=
     $expressionList = Append[$expressionList, Unevaluated[expression]];
clearExpressions[] := $expressionList = Hold[];

Basically, the idea is to store all expressions in unevaluated form in a single Hold (you can use HoldComplete if you wish). Then, evaluation of a given held expression is just a matter of extracting the relevant part, while evaluating them all is just as easy as applying ReleaseHold to $expressionList.

I will now populate $expressionList with 1000 unevaluated expressions:

iterations = 20000;
clearExpressions[];
Do[With[{i = i}, addExpression[i*i]], {i, 1, 1000}];

(I had to reduce the number of interations accordingly). Now, sequential evaluation is somewhat faster (about 1.5 times) than in your constructs, both for loops and Scan (can not use Map here however, won't evaluate inside held expression by itself)

AbsoluteTiming[
    Do[Do[$expressionList[[i]],{i,1,Length[$expressionList]}],{iterations}];][[1]]
AbsoluteTiming[Do[Scan[#&,$expressionList],{iterations}];][[1]]

(* 
  ==> 11.3134766
  ==> 10.2519531
*)

However, evaluating expressions "wholesale" is even much faster:

AbsoluteTiming[Do[ReleaseHold@$expressionList;, {iterations}];][[1]]

(* 
  ==> 3.2216797
*)