Timing mathematica code

Question

I have a collection of functions (Modules) and I wish to find out which sub-routines inside the code take up most time. I have done this by wrapping individual code blocks with

Print[Row[{"comment: ", AbsoluteTiming[ --- code --- ]}]];

This is tedious to do, and it is also tedious to remove these code blocks again once I am done with my optimization.

What I am looking for is a routine that can be turned on and off (e.g. by setting an Option), something like

timeIt[ --- code --- ,"comment"];

that can be left in place - it will simply execute the code when the Option is set to not report timing, and it will execute the code and return the timings when it is turned on.

So far, when I tried to put my Print[...] construct into an external module it worked, but it always returned a time of 0.

Here is the code that I have tried:

Clear[timeIt];
Options[timeIt] = {debugTiming -> True};
SetAttributes[timeIt, HoldFirst];
timeIt[f_, comment_: "", OptionsPattern[]] := 
  If[OptionValue[debugTiming] === True, 
   Print @ Row[{comment,": ",First@AbsoluteTiming[ReleaseHold@f]}], 
   ReleaseHold@f];

Any suggestions of how to do this properly?

Answer 1

Here is what I would do:

ClearAll[timed];
SetAttributes[timed, HoldFirst];
timed[expr_, timeItQ_] := Module[
  {
   timing,
   time,
   result
   },
  Switch[ timeItQ,
   True, (
     timing = Timing[ expr];
    Sow[ First @ timing ]; (* maybe use tags like SymbolName @ expr *)         
    result = Last@timing;
    ),
   False, result = expr
   ];
  result
  ]

Clear[myfunction];
myfunction[x_] := Table[ "Do Something";, {x}]

ClearAll[main];
Options[main] =
  {
   "timeMyFunction" -> True
   (* options for other functions *)
   };

main[opts : OptionsPattern[{main}]] := Module[
  {},
  timed[myfunction[10000000], OptionValue["timeMyFunction"] ]
  (* rest of code *)
  ]

Then you can do

Reap [ main[] ][[2]]

(* {{2.823618}} *)

I thought you wanted to time different functions and wanted to have some options to declare for which at the part of the main program. That is how this example is constructed so the Reap will collect the timings. One can use tags for the Sow expressions of course if the timings are to be collected for more than one function at any run.

To make this nicer you might put a timedMyFunction for all the possible function candidates in the main part so when different parameters are given, so that it is nicer to read.