de.uni_hildesheim.sse.monitoring.runtime.recordingStrategies

Class AbstractEventRecorderStrategy

java.lang.Object

de.uni_hildesheim.sse.monitoring.runtime.recordingStrategies.AbstractRecorderStrategy

de.uni_hildesheim.sse.monitoring.runtime.recordingStrategies.AbstractEventRecorderStrategy

All Implemented Interfaces:

RecorderStrategy

Direct Known Subclasses:

DefaultEventRecorderStrategy, TCPRecorderStrategy

public abstract class AbstractEventRecorderStrategy
extends AbstractRecorderStrategy

Implements an abstract strategy for buffering the incoming calls into events, buffering them and analyzing them in parallel.

Since:

1.00

Version:

1.00

Author:

Stephan Dederichs, Holger Eichelberger

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
protected class	AbstractEventRecorderStrategy.HandleException A specific exception type which may occur during handleEvent(de.uni_hildesheim.sse.monitoring.runtime.recordingStrategiesElements.RecordingStrategiesElement).
private class	AbstractEventRecorderStrategy.HandleThread Implements a thread which sends the gathered data to the specified server.

Field Summary

Fields

Modifier and Type	Field and Description
private static boolean	DOPOOLING true if elements should be pooled, otherwise false.
private RecordingStrategiesElementLinkedList	elements Stores the generated elements for sending them to the specified server.
private java.lang.Object	lock The internal lock for the message producer-consumer.
private boolean	record true while recording, otherwise false.
private AbstractEventRecorderStrategy.HandleThread	thread Stores the handling thread.

Fields inherited from interface de.uni_hildesheim.sse.monitoring.runtime.recordingStrategies.RecorderStrategy

REGISTER_END, REGISTER_FORCE

Constructor Summary

Constructors

Constructor and Description
AbstractEventRecorderStrategy(StrategyStorage storage) Creates a new recorder strategy.

Method Summary

Modifier and Type	Method and Description
private void	add(RecordingStrategiesElement elt) Adds an element to the processing list.
boolean	assignAllTo(java.lang.String recId, boolean enter, long now, ThreadsInfo threadInfo) Notifies that the following values (if not further calls to this method or other recording ids occur) should be assigned to the given recId.
void	clearTemporaryData() Notify that temporary data e.g. from instrumentation shall be cleared.
void	endSystem() Called as the last event from the monitored program.
boolean	enter(java.lang.String recId, long now, ThreadsInfo threadsInfo, boolean exclude) Notifies the recorder about a method being called.
void	enterConfiguration(java.lang.String id) Notify the recorder that a new variability configuration might have been entered.
boolean	exit(java.lang.String recId, long now, ThreadsInfo threadsInfo, boolean exclude) Notifies the recorder about a method being exited.
boolean	finishRecording(long now, long threadId, LongLongHashMap curCpuTime) Notifies this strategy that recording should be stopped (second stage of stopping the recorder).
protected abstract void	handleEvent(RecordingStrategiesElement event) Handles an event.
protected boolean	isRecording() Returns whether recording is activated.
void	memoryAllocated(java.lang.String recId, long threadId, long id, long size) Notifies the recorder about an object allocated to memory.
void	memoryFreedByRecId(java.lang.String recId, long size) Notifies the recorder about an object freed from memory.
void	notifyProgramRecordCreation() Notify the listeners about the program record creation (if not done implicitly before).
void	notifyTimer(java.lang.String id, TimerState state, long now, long threadId) Notifies about a timer event.
void	notifyValueChange(java.lang.String id, ValueType type, java.lang.Object value) Notifies about a changing attribute value.
boolean	printCurrentState(ProcessData data) Prints the current (aggregated) state to the output formatter.
boolean	printStatistics(ProcessData data) Emits the values collected so far.
protected int	processEvent(RecordingStrategiesElement event) Processes a single element.
void	readIo(java.lang.String recId, java.lang.String caller, long threadId, int bytes, StreamType type) Notifies the recorder about an amount of bytes read from some I/O channel.
void	register(long threadId, long newId, long threadTicks, long now) Registers a thread id with a recording id.
protected void	start() Starts the AbstractEventRecorderStrategy.HandleThread.
void	startRecording(long now, long threadId, long threadTicks) Notifies this strategy that recording should be start.
boolean	stopTimeRecording(long now, ThreadsInfo threadInfo) Notifies this strategy that time recording should be stopped (first stage of stopping the recorder).
void	writeIo(java.lang.String recId, java.lang.String caller, long threadId, int bytes, StreamType type) Notifies the recorder about an amount of bytes written to some I/O channel.

Methods inherited from class de.uni_hildesheim.sse.monitoring.runtime.recordingStrategies.AbstractRecorderStrategy

enableVariabilityDetection, getRecorderElement, getRecorderElements, getRecorderId, getStorage, getVariabilitySeparatorChar, isVariabilityDetectionEnabled, registerForRecording

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

DOPOOLING

private static final boolean DOPOOLING

true if elements should be pooled, otherwise false. This affects the EnterElement, ExitElement and the MemoryAllocatedElement.

See Also:

Constant Field Values

elements

private RecordingStrategiesElementLinkedList elements

Stores the generated elements for sending them to the specified server.

lock

private java.lang.Object lock

The internal lock for the message producer-consumer.

record

private boolean record

true while recording, otherwise false.

thread

private AbstractEventRecorderStrategy.HandleThread thread

Stores the handling thread.

Constructor Detail

AbstractEventRecorderStrategy

public AbstractEventRecorderStrategy(StrategyStorage storage)

Creates a new recorder strategy.

Parameters:

storage - the storage object

Since:

1.00

Method Detail

start

protected void start()

Starts the AbstractEventRecorderStrategy.HandleThread.

Since:

1.00

isRecording

protected boolean isRecording()

Returns whether recording is activated.

Returns:

true if recording is activated, false else

Since:

1.00

enter

public boolean enter(java.lang.String recId,
                     long now,
                     ThreadsInfo threadsInfo,
                     boolean exclude)

Notifies the recorder about a method being called.

Parameters:

recId - a unique identification where to assign this event to

now - the current system time in nano seconds

threadsInfo - information on the currently running threads

exclude - is this an exclusion from monitoring

Returns:

true if the threadsInfo object should be released to the pool, false if it should not be released

assignAllTo

public boolean assignAllTo(java.lang.String recId,
                           boolean enter,
                           long now,
                           ThreadsInfo threadInfo)

Notifies that the following values (if not further calls to this method or other recording ids occur) should be assigned to the given recId.

Parameters:

recId - the recording id (may be also the variability prefix)

enter - true if this is a method enter event, false else

now - the current system time

threadInfo - information on the current thread

Returns:

true if the threadsInfo object should be released to the pool, false if it should not be released

enterConfiguration

public void enterConfiguration(java.lang.String id)

Notify the recorder that a new variability configuration might have been entered. The recorder should resolve the concrete configuration by tracking the configuration activations.

Parameters:

id - an optional group identification (may be empty or null)

exit

public boolean exit(java.lang.String recId,
                    long now,
                    ThreadsInfo threadsInfo,
                    boolean exclude)

Notifies the recorder about a method being exited.

Parameters:

recId - a unique identification where to assign this event to

now - the current time in nano seconds

threadsInfo - information on the currently running threads

exclude - is this an exclusion from monitoring

Returns:

true if the threadsInfo object should be released to the pool, false if it should not be released

finishRecording

public boolean finishRecording(long now,
                               long threadId,
                               LongLongHashMap curCpuTime)

Notifies this strategy that recording should be stopped (second stage of stopping the recorder).

Parameters:

now - the current time in nano seconds

threadId - the id of the current thread

curCpuTime - the id-cpu time mapping of all threads

Returns:

true if the curCpuTime object should be released to the pool, false if it should not be released

memoryAllocated

public void memoryAllocated(java.lang.String recId,
                            long threadId,
                            long id,
                            long size)

Notifies the recorder about an object allocated to memory. Please note that dependent on the concrete instrumentation not all allocated objects might be cleaned up.

Parameters:

recId - a unique identification where to assign this event to

threadId - the identification of the calling thread

id - the unique identification of the object being allocated

size - the affected amount of bytes in memory

printStatistics

public boolean printStatistics(ProcessData data)

Emits the values collected so far.

Parameters:

data - additional information collected for system and JVM process

Returns:

true if the data object should be released to the pool, false if it should not be released

endSystem

public void endSystem()

Called as the last event from the monitored program. This is after RecorderStrategy.finishRecording(long, long, de.uni_hildesheim.sse.monitoring.runtime.utils.LongLongHashMap) and optionally RecorderStrategy.printStatistics(de.uni_hildesheim.sse.monitoring.runtime.recordingStrategies.ProcessData).

readIo

public void readIo(java.lang.String recId,
                   java.lang.String caller,
                   long threadId,
                   int bytes,
                   StreamType type)

Notifies the recorder about an amount of bytes read from some I/O channel.

Parameters:

recId - a unique identification where to assign this event to

caller - optional class name of the calling class

threadId - the identification of the calling thread

bytes - the number of bytes

type - the type of the channel

register

public void register(long threadId,
                     long newId,
                     long threadTicks,
                     long now)

Registers a thread id with a recording id. This method is used to assign unregistered method calls to monitored threads as well as to register system threads.

Parameters:

threadId - the read id to be recorded

newId -

• if positive, the new thread
• if RecorderStrategy.REGISTER_FORCE the thread specified by threadId and threadTicks is registered with the recorder
• if RecorderStrategy.REGISTER_END the thread specified by threadId and threadTicks is marked as terminated in the recorder

threadTicks - the ticks of threadId

now - the current time in nano seconds

writeIo

public void writeIo(java.lang.String recId,
                    java.lang.String caller,
                    long threadId,
                    int bytes,
                    StreamType type)

Notifies the recorder about an amount of bytes written to some I/O channel.

Parameters:

recId - a unique identification where to assign this event to

caller - optional class name of the calling class

threadId - the identification of the calling thread

bytes - the number of bytes

type - the type of the channel

memoryFreedByRecId

public void memoryFreedByRecId(java.lang.String recId,
                               long size)

Notifies the recorder about an object freed from memory. Please note that dependent on the concrete instrumentation not all memory frees might be detected, e.g. those of immediate system classes (e.g. Object cannot be instrumented).

Parameters:

recId - a unique identification where to assign this event to

size - the affected amount of bytes in memory

stopTimeRecording

public boolean stopTimeRecording(long now,
                                 ThreadsInfo threadInfo)

Notifies this strategy that time recording should be stopped (first stage of stopping the recorder).

Parameters:

now - the current time in nano seconds

threadInfo - information on the currently running threads

Returns:

true if the threadsInfo object should be released to the pool, false if it should not be released

startRecording

public void startRecording(long now,
                           long threadId,
                           long threadTicks)

Notifies this strategy that recording should be start.

Parameters:

now - the current time in nano seconds

threadId - the thread id of the executing (main) thread

threadTicks - the thread ticks for threadId

notifyTimer

public void notifyTimer(java.lang.String id,
                        TimerState state,
                        long now,
                        long threadId)

Notifies about a timer event.

Parameters:

id - the timer identification (may overlap with recorder ids)

state - the new timer state

now - the current system time in milliseconds

threadId - the id of the currently executing thread, may be negative if it should be ignored

printCurrentState

public boolean printCurrentState(ProcessData data)

Prints the current (aggregated) state to the output formatter.

Parameters:

data - additional information collected for system and JVM process (may be null)

Returns:

true if the threadsInfo object should be released to the pool, false if it should not be released

clearTemporaryData

public void clearTemporaryData()

Notify that temporary data e.g. from instrumentation shall be cleared. This is in particular required to synchronize event-based implementations.

notifyValueChange

public void notifyValueChange(java.lang.String id,
                              ValueType type,
                              java.lang.Object value)

Notifies about a changing attribute value.

Parameters:

id - the identification of the attribute (may overlap with recorder ids)

type - the type of the value

value - the new value (after changing)

Since:

1.00

notifyProgramRecordCreation

public void notifyProgramRecordCreation()

Notify the listeners about the program record creation (if not done implicitly before).

add

private void add(RecordingStrategiesElement elt)

Adds an element to the processing list.

Parameters:

elt - element the element to be added

Since:

1.00

processEvent

protected int processEvent(RecordingStrategiesElement event)

Processes a single element.

Parameters:

event - the event to be processed

Returns:

the identification of the processed event

Since:

1.00

handleEvent

protected abstract void handleEvent(RecordingStrategiesElement event)
                             throws AbstractEventRecorderStrategy.HandleException

Handles an event.

Parameters:

event - the event to be handled

Throws:

AbstractEventRecorderStrategy.HandleException - any kind of throwable exception which should cause aborting the event loop

Since:

1.00