👤
Home Man
Search
Today's Posts
Register

Linux & Unix Commands - Search Man Pages
Man Page or Keyword Search:
Select Section of Man Page:
Select Man Page Repository:

Linux 2.6 - man page for cprof (linux section 3erl)

cprof(3erl)			     Erlang Module Definition			      cprof(3erl)

NAME
       cprof  -  A simple Call Count Profiling Tool using breakpoints for minimal runtime perfor-
       mance impact.

DESCRIPTION
       The cprof module is used to profile a program to find out how many times  different  func-
       tions  are  called. Breakpoints similar to local call trace, but containing a counter, are
       used to minimise runtime performance impact.

       Since breakpoints are used there is no need for special compilation of any  module  to  be
       profiled. For now these breakpoints can only be set on BEAM code so s cannot be call count
       traced.

       The size of the call counters is the host machine word size. One bit is used when  pausing
       the counter, so the maximum counter value for a 32-bit host is 2147483647.

       The  profiling  result is delivered as a term containing a sorted list of entries, one per
       module. Each module entry contains a sorted list of functions. The sorting order  in  both
       cases is of decreasing call count.

       Call  count  tracing is very lightweight compared to other forms of tracing since no trace
       message has to be generated. Some measurements indicates performance  degradation  in  the
       vicinity of 10 percent.

EXPORTS
       analyse() -> {AllCallCount, ModAnalysisList}
       analyse(Limit) -> {AllCallCount, ModAnalysisList}
       analyse(Mod) -> ModAnlysis
       analyse(Mod, Limit) -> ModAnalysis

	      Types  Limit = integer()
		     Mod = atom()
		     AllCallCount = integer()
		     ModAnalysisList = [ModAnalysis]
		     ModAnalysis = {Mod, ModCallCount, FuncAnalysisList}
		     ModCallCount = integer()
		     FuncAnalysisList = [{{Mod, Func, Arity}, FuncCallCount}]
		     Func = atom()
		     Arity = integer()
		     FuncCallCount = integer()

	      Collects and analyses the call counters presently in the node for either module Mod
	      , or for all modules (except cprof itself), and returns:

		FuncAnalysisList :
		  A list of tuples, one for each function in a module,	in  decreasing	FuncCall-
		  Count order.

		ModCallCount :
		  The sum of FuncCallCount values for all functions in module Mod .

		AllCallCount :
		  The sum of ModCallCount values for all modules concerned in ModAnalysisList .

		ModAnalysisList :
		  A list of tuples, one for each module except cprof , in decreasing ModCallCount
		  order.

	      If call counters are still running while analyse/0..2 is executing, you  might  get
	      an  inconsistent	result.  This  happens if the process executing analyse/0..2 gets
	      scheduled out so some other process can increment the counters that are being  ana-
	      lysed, Calling pause() before analysing takes care of the problem.

	      If  the  Mod  argument is given, the result contains a ModAnalysis tuple for module
	      Mod only, otherwise the result contains  one  ModAnalysis  tuple	for  all  modules
	      returned from code:all_loaded() except cprof itself.

	      All functions with a FuncCallCount lower than Limit are excluded from FuncAnalysis-
	      List . They are still included in ModCallCount ,	though.  The  default  value  for
	      Limit is 1 .

       pause() -> integer()

	      Pause call count tracing for all functions in all modules and stop it for all func-
	      tions    in    modules	to    be    loaded.    This    is     the     same     as
	      (pause({'_','_','_'})+stop({on_load})) .

	      See also pause/1..3 below.

       pause(FuncSpec) -> integer()
       pause(Mod, Func) -> integer()
       pause(Mod, Func, Arity) -> integer()

	      Types  FuncSpec = Mod | {Mod,Func,Arity}, {FS}
		     Mod = atom()
		     Func = atom()
		     Arity = integer()
		     FS = term()

	      Pause call counters for matching functions in matching modules. The FS argument can
	      be used to specify the first argument to erlang:trace_pattern/3 . See erlang(3erl).

	      The call counters for all matching functions that has got  call  count  breakpoints
	      are paused at their current count.

	      Return  the  number of matching functions that can have call count breakpoints, the
	      same as start/0..3 with the same arguments would have returned.

       restart() -> integer()
       restart(FuncSpec) -> integer()
       restart(Mod, Func) -> integer()
       restart(Mod, Func, Arity) -> integer()

	      Types  FuncSpec = Mod | {Mod,Func,Arity}, {FS}
		     Mod = atom()
		     Func = atom()
		     Arity = integer()
		     FS = term()

	      Restart call counters for the matching functions in matching modules that are  call
	      count  traced.  The  FS  argument  can  be  used	to  specify the first argument to
	      erlang:trace_pattern/3 . See erlang(3erl).

	      The call counters for all matching functions that has got  call  count  breakpoints
	      are set to zero and running.

	      Return  the  number of matching functions that can have call count breakpoints, the
	      same as start/0..3 with the same arguments would have returned.

       start() -> integer()

	      Start call count tracing for all functions in all modules, and also for  all  func-
	      tions	in     modules	   to	 be    loaded.	  This	  is	the    same    as
	      (start({'_','_','_'})+start({on_load})) .

	      See also start/1..3 below.

       start(FuncSpec) -> integer()
       start(Mod, Func) -> integer()
       start(Mod, Func, Arity) -> integer()

	      Types  FuncSpec = Mod | {Mod,Func,Arity}, {FS}
		     Mod = atom()
		     Func = atom()
		     Arity = integer()
		     FS = term()

	      Start call count tracing for matching functions in matching modules. The	FS  argu-
	      ment  can  be  used  to  specify the first argument to erlang:trace_pattern/3 , for
	      example on_load . See erlang(3erl).

	      Set call count breakpoints on the matching functions that has no call count  break-
	      points. Call counters are set to zero and running for all matching functions.

	      Return the number of matching functions that has got call count breakpoints.

       stop() -> integer()

	      Stop  call  count  tracing for all functions in all modules, and also for all func-
	      tions    in    modules	to    be    loaded.    This    is     the     same     as
	      (stop({'_','_','_'})+stop({on_load})) .

	      See also stop/1..3 below.

       stop(FuncSpec) -> integer()
       stop(Mod, Func) -> integer()
       stop(Mod, Func, Arity) -> integer()

	      Types  FuncSpec = Mod | {Mod,Func,Arity}, {FS}
		     Mod = atom()
		     Func = atom()
		     Arity = integer()
		     FS = term()

	      Stop call count tracing for matching functions in matching modules. The FS argument
	      can be used to specify the first argument to erlang:trace_pattern/3 ,  for  example
	      on_load . See erlang(3erl).

	      Remove  call  count  breakpoints	from  the  matching functions that has call count
	      breakpoints.

	      Return the number of matching functions that can have call count	breakpoints,  the
	      same as start/0..3 with the same arguments would have returned.

SEE ALSO
       eprof(3erl), fprof(3erl), erlang(3erl), User's Guide

Ericsson AB				  tools 2.6.6.3 			      cprof(3erl)


All times are GMT -4. The time now is 09:52 AM.

Unix & Linux Forums Content Copyrightę1993-2018. All Rights Reserved.
×
UNIX.COM Login
Username:
Password:  
Show Password