class MockNativeMonitor():
def __init__(self):
self._profile = ProfileFunctionManager()
def __enter__(self):
self._profile.replace(self.event)
def __exit__(self, exc_type, exc_val, exc_tb):
self._profile.recover()
def event(self, frame, event, arg):
pass
class MockNativeMonitor():
def __init__(self):
self._profile = ProfileFunctionManager()
def __enter__(self):
self._profile.replace(self.event)
def __exit__(self, exc_type, exc_val, exc_tb):
self._profile.recover()
def event(self, frame, event, arg):
pass
class FunctionMemoryMonitor(Monitor):
""" Record process memory on python function events.
The class hooks on the setprofile function to receive function events and
record the current process memory when they happen.
Private
-------
_recorder : object
A recorder object that implementes the
:class:`~pikos.recorder.AbstractRecorder` interface.
_profiler : object
An instance of the
:class:`~pikos._internal.profiler_functions.ProfilerFunctions` utility
class that is used to set and unset the setprofile function as required
by the monitor.
_index : int
The current zero based record index. Each function event will increase
the index by one.
_call_tracker : object
An instance of the :class:`~pikos._internal.keep_track` utility class
to keep track of recursive calls to the monitor's :meth:`__enter__` and
:meth:`__exit__` methods.
_process : object
An instanse of :class:`psutil.Process` for the current process, used to
get memory information in a platform independent way.
"""
def __init__(self, recorder):
""" Initialize the monitoring class.
Parameters
----------
recorder : object
A subclass of :class:`~pikos.recorders.AbstractRecorder` or a class
that implements the same interface to handle the values to be
logged.
"""
self._recorder = recorder
self._profiler = ProfileFunctionManager()
self._index = 0
self._call_tracker = KeepTrack()
self._process = None
def __enter__(self):
""" Enter the monitor context.
The first time the method is called (the context is entered) it will
initialize the Process class, set the setprofile hooks and initialize
the recorder.
"""
if self._call_tracker('ping'):
self._process = psutil.Process(os.getpid())
self._recorder.prepare(FunctionMemoryRecord)
self._profiler.replace(self.on_function_event)
def __exit__(self, exc_type, exc_val, exc_tb):
""" Exit the monitor context.
The last time the method is called (the context is exited) it will
unset the setprofile hooks and finalize the recorder and set
:attr:`_process` to None.
"""
if self._call_tracker('pong'):
self._profiler.recover()
self._recorder.finalize()
self._process = None
def on_function_event(self, frame, event, arg):
""" Record the process memory usage during the current function event.
Called on function events, it will retrieve the necessary information
from the `frame` and :attr:`_process`, create a :class:`FunctionRecord`
and send it to the recorder.
"""
usage = self._process.get_memory_info()
filename, lineno, function, _, _ = \
inspect.getframeinfo(frame, context=0)
if event.startswith('c_'):
function = arg.__name__
record = FunctionMemoryRecord(self._index, event, function, usage[0],
usage[1], lineno, filename)
self._recorder.record(record)
self._index += 1
class FunctionMonitor(Monitor):
""" Record python function events.
The class hooks on the setprofile function to receive function events and
record them.
Private
-------
_recorder : object
A recorder object that implementes the
:class:`~pikos.recorder.AbstractRecorder` interface.
_profiler : object
An instance of the
:class:`~pikos._internal.profiler_functions.ProfilerFunctions` utility
class that is used to set and unset the setprofile function as required
by the monitor.
_index : int
The current zero based record index. Each function event will increase
the index by one.
_call_tracker : object
An instance of the :class:`~pikos._internal.keep_track` utility class
to keep track of recursive calls to the monitor's :meth:`__enter__` and
:meth:`__exit__` methods.
"""
def __init__(self, recorder):
""" Initialize the monitoring class.
Parameters
----------
recorder : object
A subclass of :class:`~pikos.recorders.AbstractRecorder` or a class
that implements the same interface to handle the values to be
logged.
"""
self._recorder = recorder
self._profiler = ProfileFunctionManager()
self._index = 0
self._call_tracker = KeepTrack()
def __enter__(self):
""" Enter the monitor context.
The first time the method is called (the context is entered) it will
set the setprofile hooks and initialize the recorder.
"""
if self._call_tracker('ping'):
self._recorder.prepare(FunctionRecord)
self._profiler.replace(self.on_function_event)
def __exit__(self, exc_type, exc_val, exc_tb):
""" Exit the monitor context.
The last time the method is called (the context is exited) it will
unset the setprofile hooks and finalize the recorder.
"""
if self._call_tracker('pong'):
self._profiler.recover()
self._recorder.finalize()
def on_function_event(self, frame, event, arg):
""" Record the current function event.
Called on function events, it will retrieve the necessary information
from the `frame`, create a :class:`FunctionRecord` and send it to the
recorder.
"""
filename, lineno, function, _, _ = \
inspect.getframeinfo(frame, context=0)
if event.startswith('c_'):
function = arg.__name__
record = FunctionRecord(self._index, event, function, lineno, filename)
self._recorder.record(record)
self._index += 1
class FunctionMonitor(Monitor):
""" Record python function events.
The class hooks on the setprofile function to receive function events and
record them.
"""
def __init__(self, recorder, record_type=None):
""" Initialize the monitoring class.
Parameters
----------
recorder : object
A subclass of :class:`~.AbstractRecorder` or a class that
implements the same interface to handle the values to be logged.
record_type : type
A class object to be used for records. Default is
:class:`~.FunctionRecord`.
"""
self._recorder = recorder
self._record = recorder.record
self._profiler = ProfileFunctionManager()
self._index = 0
self._call_tracker = KeepTrack()
if record_type is None:
self._record_type = FunctionRecord
else:
self._record_type = record_type
self._use_tuple = self._record_type is tuple
def enable(self):
""" Enable the monitor.
The first time the method is called (the context is entered) it will
set the setprofile hooks and initialize the recorder.
"""
if self._call_tracker('ping'):
self._recorder.prepare(self._record_type)
self._profiler.replace(self.on_function_event)
def disable(self):
""" Disable the monitor.
The last time the method is called (the context is exited) it will
unset the setprofile hooks and finalize the recorder.
"""
if self._call_tracker('pong'):
self._profiler.recover()
self._recorder.finalize()
def on_function_event(self, frame, event, arg):
""" Record the current function event.
Called on function events, it will retrieve the necessary information
from the `frame`, create a :class:`FunctionRecord` and send it to the
recorder.
"""
record = self.gather_info(frame, event, arg)
if not self._use_tuple:
record = self._record_type(*record)
self._record(record)
self._index += 1
def gather_info(self, frame, event, arg):
""" Gather information for the record.
"""
if '_' == event[1]:
return (
self._index, event, arg.__name__,
frame.f_lineno, frame.f_code.co_filename)
else:
code = frame.f_code
return (
self._index, event, code.co_name,
frame.f_lineno, code.co_filename)