Profiling from Mathematica

Question

I've always wished I could do some profiling like you get in Wolfram Workbench, but directly from Mathematica, without using or having Workbench. If it is possible, how can I do it?

Answer 1

You can put your Mathematica session in debug mode by going to Evaluation->Debugger

Then, make some definitions and wrap the profiled code in RuntimeTools`Profile

For example, in debug mode, run

f[x_] := x^2

Table[f[x], {100000}]; // RuntimeTools`Profile

and you get a nice

As @acl mentioned in the comments, clicking in the gray area in the output notebook's lines takes you to the related code

Answer 2

Not knowing about the built in functions for this, I compiled these two functions. Hope they help someone.

(* Test Performance of expression evaluation *)
benchmark[locals_,expr_,opts:OptionsPattern[]]:=Module[
{timeLst,funcs,stats,totalTime,times=OptionValue[times],run},
progressBar[Dynamic[run],times];
totalTime=AbsoluteTiming[
    timeLst=Table[
        Module[locals,
            ReleaseHold@AbsoluteTiming[expr]][[1]],
        {run,times}]][[1]];
If[OptionValue[printStats],
    styledPrint[{"Stats for ",times," runs of '", HoldForm[expr] ,"':"},Bold,20];
    statsSummary[timeLst];
    (styledPrint[{"Total Time: ", NumberForm[totalTime,3]},16])];
Return[{stats,timeLst}]
];

SetAttributes[benchmark,HoldAll];
Options[benchmark]={printStats->True,times->9};
benchmark::usage="benchmark[locals_,expr_,OptionsPattern[]] takes a list of localized var=val assignments (which are evaluated anew each run) (lexical, via Module). The expression is evaluated the given number of times, and statistics are printed about it.
The {list of statistics, list of individual runtimes} are returnd.

Example:
benchmark[{n=RandomInteger[10^3,10^5]},FactorInteger[n],times->10]

Options:
times:9 # to run the expression and collect runtime data
printStats:True Wether to print statistics about the distribution of times.
";

(* Compare performance of two expressions *)
compareRunTimes[locals_,base_,comp_,opts:OptionsPattern[]]:=Module[
{timeLst,baseTimeLst,compTimeLst,totalTime,ratio,times=OptionValue[times],runtimes=0,llocs},
progressBar[Dynamic[runtimes],times];
totalTime=AbsoluteTiming[
    timeLst=Map[
        With[locals,
            Evaluate[ReleaseHold@OptionValue[init]];runtimes=#;
            {ReleaseHold@AbsoluteTiming[base][[1]],
             ReleaseHold@AbsoluteTiming[comp][[1]]}]&,
        Range[times]]][[1]];
{baseTimeLst,compTimeLst}=Transpose@timeLst;
If[OptionValue[printStats],
    ratio=(Plus @@ compTimeLst)/(Plus @@ baseTimeLst);
    Quiet[styledPrint[{HoldForm[comp], Style[" (right)",Blue], " took ", Style[(ToString@NumberForm[100. ratio,3]) <> "%", If[ratio>1,Red,Green]], " as much time to evaluate as much as ", HoldForm[base], Style[" (left)", Blue], "!"},24,Bold],{NumberForm::sigz}];
    styledPrint[{"Stats for time ratios for ",times," runs of '", HoldForm[comp], "' and '", HoldForm[base] ,"':"},Bold,20];
    statsSummary[compTimeLst/baseTimeLst,total->False];
    styledPrint[{"Stats for ",times," runs of '", HoldForm[base] ,"':"},Bold,20];
    statsSummary[baseTimeLst];
    styledPrint[{"Stats for ",times," runs of '", HoldForm[comp] ,"':"},Bold,20];
    statsSummary[compTimeLst];];
Return[{baseTimeLst,compTimeLst}]
];

Options[compareRunTimes]={printStats->True,times->9,init->Null};
SetAttributes[compareRunTimes,HoldAll];
compareRunTimes::usage="compareRunTimes[locals_,base_,comp_,OptionsPattern[]] takes a list of localized var=val assignments (which are evaluated anew each run) (lexical, via Module). The expressions base and comp is evaluated the given number of times (with the same local calculated values for both), and statistics are printed about it.
The {list of statistics, list of individual runtimes} are returnd.

Example:
compareRunTimes[{s=RandomInteger[10^5,100000]},FactorInteger[s],FactorInteger[s (s+1)],times\[Rule]10]

Options:
times:9 # to run the expression and collect runtime data
printStats:True Wether to print statistics about the distribution of times.
";

Answer 3

Since at least 2020, Wolfram provides Instrumentation package for profiling Wolfram Language code.

It seems to provide a very detailed report, e.g. I've got the following by profiling couple of my packages: