profiler.mx

一个内存数据库的源代码这是服务器端还有客户端

@' The contents of this file are subject to the MonetDB Public License
@' Version 1.1 (the "License"); you may not use this file except in
@' compliance with the License. You may obtain a copy of the License at
@' http://monetdb.cwi.nl/Legal/MonetDBLicense-1.1.html
@'
@' Software distributed under the License is distributed on an "AS IS"
@' basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
@' License for the specific language governing rights and limitations
@' under the License.
@'
@' The Original Code is the MonetDB Database System.
@'
@' The Initial Developer of the Original Code is CWI.
@' Portions created by CWI are Copyright (C) 1997-2007 CWI.
@' All Rights Reserved.

@f profiler
@a Martin Kersten
@+ Performance profiler
A key issue in developing fast programs using the Monet database
back-end requires a keen eye on where performance is lost.
Although performance tracking and measurements are highly
application dependent, a simple to use tool makes life
a lot easier.

Inspired by programs like xosview and xload, we
provide a simple Java application that reads a stream
of log events generated by the Monet kernel upon request.

Activation of the performance monitor has a global effect,
i.e. all concurrent actions on the kernel are traced,
but the events are only sent to the client initiated 
the profiler thread.

@- Monet Event Logger
The Monet Event Logger generates records of each event of
interest indicated by a log filter, i.e. a pattern over
module and function names. 

The log record contents is derived from counters being
(de-)activated. 
A complete list of recognized counters is shown below.

@- Execution tracing
Tracing is a special kind of profiling, where the information
gathered is not sent to a remote system, but stored in the database
itself. Each profile event is given a separate BAT

@verbatim
# thread and time since start
profiler.activate("tick");	
# cpu time in nano-seconds 
profiler.activate("cpu");	
# memory allocation information
profiler.activate("memory");
# IO activity
profiler.activate("io"); 
# Module,function,program counter
profiler.activate("pc"); 
# actual MAL instruction executed
profiler.activate("statement");	
@end verbatim
@-
The profiler event can be handled in several ways.
The default strategy is to ship the event record immediately over a stream
to a performance monitor, eg. Mknife.
An alternative strategy is preparation of off-line performance analysis.
For this case the event record is turned into a XML structure and
sent over the stream (most likely linked with a file)
or the information is gathered in a BAT group for online analysis.

To reduce the  interference of performance measurement with
the experiments, the user can use an event cache, which is
emptied explicitly upon need.
@mal
module profiler;

command activate(name:str):void
address CMDactivateProfiler
comment "Make the specified counter active.";

command deactivate(name:str):void
address CMDdeactivateProfiler
comment "Deactivate the counter";

command openStream():void 
address CMDopenProfilerStream
comment "Sent the events to output stream";
command openStream(fnme:str)
address CMDsetProfilerStream
comment "Send the log events to a file ";
command closeStream():void 
address CMDcloseProfilerStream
comment "Stop sending the event records";

command setAll():void
address CMDsetAllProfiler
comment "Short cut for setFilter(*,*).";
command setNone():void
address CMDsetNoneProfiler
comment "Short cut for clrFilter(*,*).";

command setFilter(mod:str,fcn:str):void
address CMDsetFilterProfiler
comment "Generate an event record for all 
	function calls that satisfy the regular 
	expression mod.fcn. A wildcard (*) can 
	be used as name to identify all";

command clrFilter(mod:str,fcn:str):void
address CMDclrFilterProfiler
comment "Clear the performance trace bit 
	of the selected functions.";

command setStartPoint(mod:str,fcn:str):void
address CMDstartPointProfiler
comment "Start performance tracing at mod.fcn";
command setEndPoint(mod:str,fcn:str)
address CMDendPointProfiler
comment "End performance tracing after mod.fcn";

command start():void
address CMDstartProfiler
comment "Start performance tracing";

command stop():void
address CMDstopProfiler
comment "Stop performance tracing";

command clearTrace():void
address CMDclearTrace
comment "Clear the profiler tables";

command startTrace():void
address CMDstartTrace
comment "Prepare for online tracing using the profile filter";

command stopTrace():void
address CMDstopTrace
comment "Stop online tracing";

command setCachedProfiling():void
address CMDsetCachedProfiling
comment "use cached events rather then online";

command setOnlineProfiling():void
address CMDsetOnlineProfiling
comment "Sent events over stream";

command setOfflineProfiling():void
address CMDsetOfflineProfiling
comment "Sent events over stream";

command dumpTrace():void
address CMDdumpTrace
comment "List the events collected";

command getTrace(e:str):bat[:int,:any_1]
address CMDgetTrace
comment "Get the trace details of a specific event";

command cleanup():void
address CMDcleanup
comment "Remove the temporary tables for profiling";
@{
@-
@+ Implementation
The commands merely encapsulate the functionality provided by
mal_profiler, which should be explicitly compiled with the kernel, because
its generates a noticable overhead.
@h
#include "gdk.h"
#include <stdarg.h>
#include <time.h>
#include "mal_stack.h"
#include "mal_resolve.h"
#include "mal_exception.h"
#include "mal_client.h"
#include "mal_profiler.h"

@-
Using the Monet Performance Profiler is constrained by the mal_profiler.
@c
#include "mal_config.h"
#include "profiler.h"

#ifdef WIN32
#ifndef LIBPROFILER
#define profiler_export extern __declspec(dllimport)
#else
#define profiler_export extern __declspec(dllexport)
#endif
#else
#define profiler_export extern
#endif

profiler_export str CMDactivateProfiler(int *res, str *name);
profiler_export str CMDdeactivateProfiler(int *res, str *name);
profiler_export str CMDsetFilterProfiler(int *res, str *mod, str *fcn);
profiler_export str CMDsetAllProfiler(int *res);
profiler_export str CMDclrFilterProfiler(int *res, str *mod, str *fcn);
profiler_export str CMDsetNoneProfiler(int *res);
profiler_export str CMDsetProfilerStream(int *res, str *fnme);
profiler_export str CMDstartPointProfiler(int *res, str *mod, str *fcn);
profiler_export str CMDendPointProfiler(int *res, str *mod, str *fcn);
profiler_export str CMDstopProfiler(int *res);
profiler_export str CMDstartProfiler(int *res);
profiler_export str CMDstartTrace(int *res);
profiler_export str CMDstopTrace(int *res);
profiler_export str CMDclearTrace(int *res);
profiler_export str CMDdumpTrace(int *res);
profiler_export str CMDgetTrace(int *res, str *ev);
profiler_export str CMDsetCachedProfiling(int *ret);
profiler_export str CMDsetOnlineProfiling(int *ret);
profiler_export str CMDsetOfflineProfiling(int *ret);
profiler_export str CMDopenProfilerStream(int *res);
profiler_export str CMDcloseProfilerStream(int *res);
profiler_export str CMDcleanup(int *ret);

#define checkProfiler(X) \
	if( ! profilerAvailable()) \
	throw(MAL, "profiler." X,\
	":Monet not compiled for performance monitoring");


str
CMDactivateProfiler(int *res, str *name)
{
	(void) res;		/* fool compiler */
	checkProfiler("activate");
	activateCounter(*name);
	return MAL_SUCCEED;
}

str
CMDdeactivateProfiler(int *res, str *name)
{
	(void) res;		/* fool compiler */
	checkProfiler("deactivate");
	deactivateCounter(*name);
	return MAL_SUCCEED;
}

str
CMDsetFilterProfiler(int *res, str *mod, str *fcn)
{
	(void) res;		/* fool compiler */
	checkProfiler("setFilter");
	setFilter(MCgetClient()->nspace, *mod, *fcn);
	return MAL_SUCCEED;
}

str
CMDsetAllProfiler(int *res)
{
	str x = GDKstrdup("*");
	str y = GDKstrdup("*");

	(void) res;		/* fool compiler */
	return CMDsetFilterProfiler(res, &x, &y);
}

str
CMDopenProfilerStream(int *res)
{
	(void) res;
	return openProfilerStream();
}
str
CMDcloseProfilerStream(int *res)
{
	(void) res;
	return closeProfilerStream();
}

str
CMDclrFilterProfiler(int *res, str *mod, str *fcn)
{
	(void) res;		/* fool compiler */
	checkProfiler("clrFilter");
	resetFilter(MCgetClient()->nspace, *mod, *fcn);
	return MAL_SUCCEED;
}

str
CMDsetNoneProfiler(int *res)
{
	str x = GDKstrdup("");
	str y = GDKstrdup("");

	(void) res;		/* fool compiler */
	return CMDclrFilterProfiler(res, &x, &y);
}

str
CMDsetProfilerStream(int *res, str *fnme)
{
	(void) res;		/* fool compiler */
	checkProfiler("setProfiler");
	setLogFile(MCgetClient()->nspace, *fnme);
	return MAL_SUCCEED;
}

str
CMDstartPointProfiler(int *res, str *mod, str *fcn)
{
	(void) res;		/* fool compiler */
	checkProfiler("startPoint");
	setStartPoint(MCgetClient()->nspace, *mod, *fcn);
	return MAL_SUCCEED;
}

str
CMDendPointProfiler(int *res, str *mod, str *fcn)
{
	(void) res;		/* fool compiler */
	checkProfiler("endPoint");
	setStartPoint(MCgetClient()->nspace, *mod, *fcn);
	return MAL_SUCCEED;
}

str
CMDstopProfiler(int *res)
{
	Client c = MCgetClient();

	(void) res;		/* fool compiler */
	checkProfiler("stop");
	stream_printf(c->fdout, "# Performance profiling stopped\n");
	stopProfiling();
	return MAL_SUCCEED;
}

str
CMDstartProfiler(int *res)
{
	Client c = MCgetClient();

	(void) res;		/* fool compiler */
	checkProfiler("start");
	stream_printf(c->fdout, "# Start performance profiling\n");
	startProfiling();
	return MAL_SUCCEED;
}

@-
Tracing an active system.
@c
str
CMDstartTrace(int *res)
{
	(void) res;		/* fool compiler */
	checkProfiler("start");
	startTrace();
	return MAL_SUCCEED;
}

str
CMDstopTrace(int *res)
{
	(void) res;		/* fool compiler */
	checkProfiler("stop");
	stopTrace();
	return MAL_SUCCEED;
}

str
CMDclearTrace(int *res)
{
	(void) res;		/* fool compiler */
	checkProfiler("stop");
	clearTrace();
	return MAL_SUCCEED;
}

str
CMDdumpTrace(int *res)
{
	(void) res;		/* fool compiler */
	checkProfiler("dump");
	stopTrace();
	return MAL_SUCCEED;
}

str
CMDgetTrace(int *res, str *ev)
{
	BAT *bn;

	(void) res;		/* fool compiler */
	checkProfiler("dump");
	bn = getTrace(*ev);
	if (bn) {
		BBPincref(*res = bn->batCacheid, TRUE);
		return MAL_SUCCEED;
	}
	throw(MAL, "getTrace", "Failed to find event profile");
}

str
CMDsetCachedProfiling(int *ret)
{
	(void) ret;
	setCachedProfiling();
	return MAL_SUCCEED;
}

str
CMDsetOnlineProfiling(int *ret)
{
	(void) ret;
	setOnlineProfiling();
	return MAL_SUCCEED;
}

str
CMDsetOfflineProfiling(int *ret)
{
	(void) ret;
	setOnlineProfiling();
	return MAL_SUCCEED;
}

str
CMDcleanup(int *ret){
	(void) ret;
	cleanupProfiler();
	return MAL_SUCCEED;
}
@}