etop(3erl) [linux man page]

etop(3erl)						     Erlang Module Definition							etop(3erl)

NAME

       etop - Erlang Top is a tool for presenting information about erlang processes similar to the information presented by "top" in UNIX.

DESCRIPTION

       etop  should  be started with the provided scripts etop and getop for text based and graphical presentation respectively. This will start a
       hidden erlang node which connects to the node to be measured. The measured node is given with the -node option. If the measured node has  a
       different  cookie  than	the  default  cookie for the user who invokes the script, the cookie must be explicitly given witht the -setcookie
       option.

       Under Windows the batch files etop.bat and getop.bat can be used.

       The following configuration parameters exist for the etop tool. When executing the etop or getop scripts, these parameters can be given	as
       command line options, e.g. getop -node testnode@myhost -setcookie MyCookie .

	 node :
	   The measured node.
	   Value: atom()
	   Mandatory

	 setcookie :
	   Cookie to use for the etop node - must be the same as the cookie on the measured node.
	   Value: atom()

	 lines :
	   Number of lines (processes) to display.
	   Value: integer()
	   Default: 10

	 interval :
	   The time interval (in seconds) between each update of the display.
	   Value: integer()
	   Default: 5

	 accumulate :
	   If true the execution time and reductions are accumulated.
	   Value: boolean()
	   Default: false

	 sort :
	   Identifies what information to sort by.
	   Value: runtime | reductions | memory | msg_q
	   Default: runtime ( reductions if tracing=off )

	 tracing :
	   etop  uses  the  erlang  trace  facility, and thus no other tracing is possible on the measured node while etop is running, unless this
	   option is set to off . Also helpful if the etop tracing causes too high load on the measured node. With tracing  off,  runtime  is  not
	   measured.
	   Value: on | off
	   Default: on

       All  interaction  with  etop when running the graphical presentation should happen via the menus. For the text based presentation the func-
       tions described below can be used.

       See the user's guide for more information about the etop tool.

EXPORTS

       config(Key,Value) -> Result

	      Types  Result = ok | {error,Reason}
		     Key = lines | interval | accumulate | sort
		     Value = term()

	      This function is used to change the tool's configuration parameters during runtime. The table above indicates the allowed values for
	      each parameter.

       dump(File) -> Result

	      Types  Result = ok | {error,Reason}
		     File = string()

	      This function dumps the current display to a text file.

       stop() -> stop

	      This function terminates etop .

Ericsson AB							  observer 0.9.9							etop(3erl)

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

NAME

       cprof - A simple Call Count Profiling Tool using breakpoints for minimal runtime performance impact.

DESCRIPTION

       The  cprof module is used to profile a program to find out how many times different functions 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 FuncCallCount 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 analysed,  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 Mod-
	      Analysis tuple for all modules returned from code:all_loaded() except cprof itself.

	      All functions with a FuncCallCount lower than Limit are excluded from FuncAnalysisList . 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 functions 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 functions 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 argument 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 breakpoints. 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 functions 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)