| Action |
An action is the core logic that occurs within an activity.
|
| ActionDispenser |
An ActionDispenser is created for each Activity instance within a scenario.
|
| ActivitiesAware |
Dispensers that implement this decorator interface might need to know about the other
activities that are present in a configuration.
|
| Activity |
Provides the components needed to build and run an activity a runtime.
|
| ActivityController |
|
| ActivityControlsListener |
|
| ActivityDef |
A runtime definition for an activity.
|
| ActivityDefObserver |
Decorator interface for getting notified when an activities parameters are changed at runtime.
|
| ActivityDispenser |
|
| ActivityInitializationError |
Represents an error that occurred while initializing an activity instance to run.
|
| ActivityInstrumentation |
All the accessors of the metrics that will be used for each activity instance.
|
| ActivityMetrics |
|
| ActivityType<A extends Activity> |
An ActivityType is the central extension point in EngineBlock for new
activity types drivers.
|
| AsyncAction<D> |
An AsyncAction allows an activity type to implement asynchronous
operations within each thread.
|
| AtomicInput |
TODO: This documentation is out of date as of 2.0.0
|
| BaseAsyncAction<D,A extends Activity> |
|
| BlockParams |
|
| BucketSequencer<T> |
Introduction
|
| Buffer<T extends java.lang.Comparable> |
This is a lightweight buffer implementation that allows for buffer
flipping and callbacks when the buffer is full.
|
| ByteTrackerExtent |
A simple bytebuffer marker implementation
|
| CanFilterResultValue |
|
| CanSortCycles |
|
| CapabilityHook<T> |
A silly class that does nothing but allow cleaner code elsewhere,
because MetricRegistryListener, that's why.
|
| ClassicHistoListener |
|
| ClassicTimerListener |
|
| Colors |
ANSI console colors for enhanced logging
|
| CompletedOp<D> |
A CompletedOp can be any of
SucceededOp
FailedOp
SkippedOp
It may be necessary to downcast a completed Op in order to
get more contextual details from it. |
| ConcatSequencer<T> |
This sequencer just repeats a number of elements, one element after
another.
|
| ConfigTuples |
|
| ConfigTuples.Section |
|
| ContiguousOutputChunker |
This is the default cycle output implementation for EngineBlock when
the input cycles are known to be contiguous.
|
| ConvenientSnapshot |
|
| CoreAction |
|
| CoreActionDispenser |
An action dispenser that returns a logging action.
|
| CoreActivityInstrumentation |
|
| CoreInputDispenser |
|
| CoreMotor<D> |
ActivityMotor is a Runnable which runs in one of an activity's many threads.
|
| CoreMotorDispenser<D> |
Produce index ActivityMotor instances with an input and action,
given the input and an action factory.
|
| CoreResultValueFilter |
This cycle result filter implements a filter that allows for the
inclusion or exclusion of single-values or intervals.
|
| CoreResultValueFilter.Dispenser |
|
| CoreServices |
|
| CpuInfo |
|
| CpuInfo.ProcDetails |
|
| CycleArray |
Just cycle numbers in a long array.
|
| CycleArray.ArraySegment |
|
| CycleArrayBuffer |
|
| CycleErrorHandler<T extends java.lang.Throwable,R> |
|
| CycleErrorHandler.Triple<T,R> |
|
| CycleErrorHandlers |
Provide some basic error handlers
|
| CycleLogDumperUtility |
|
| CycleLogImporterUtility |
|
| CycleLogInput |
|
| CycleLogInputType |
|
| CycleLogInputType.Dispenser |
|
| CycleLogOutput |
A Output that writes cycles and results to an RLE-based file format. |
| CycleLogOutputType |
|
| CycleLogOutputType.Dispenser |
|
| CycleMutable |
|
| CycleReadable |
|
| CycleResult |
A readable interface for (cycle, result) tuple types.
|
| CycleResultArray |
|
| CycleResultPredicate |
|
| CycleResultPredicate.ResultEquals |
|
| CycleResultPredicate.ResultHasAllBits |
|
| CycleResultPredicate.ResultHasSomeBits |
|
| CycleResultPredicate.ResultInRange |
|
| CycleResultSegmentBuffer |
Implements a cycle result segment in a basic buffer
that contains the cycle and the result in long, byte format.
|
| CycleResultSegmentBuffer.Sink |
|
| CycleResultSegmentsReadable |
|
| CycleResultsIntervalSegment |
This is just a typed-data holder for efficient transfer of tracked data.
|
| CycleResultsRLEBufferReadable |
Implements a cycle result segment in a run-length encoded buffer
that contains the cycle interval and the result in long, long, byte format,
where the last value (the second long value) is *not* included in the
cycle inteval.
|
| CycleResultsRLEBufferTarget |
Implements a convenient target buffer for Marker data that can be used
to create nio ByteBuffers easily.
|
| CycleResultsSegment |
|
| CycleResultsSegment.EmptySegment |
|
| CycleResultsSegmentReadable |
Implements a cycle result segment in a basic buffer
that contains the cycle and the result in long, byte format.
|
| CycleResultStrider |
|
| CycleResultTristateFilter |
|
| CycleSegment |
A segment of cycle numbers to iterate over.
|
| CycleSegmentBuffer |
|
| CycleSorting |
|
| CycleSpanResults |
|
| DeltaHdrHistogramReservoir |
A custom wrapping of snapshotting logic on the HdrHistogram.
|
| DeltaSnapshotReader |
|
| DeltaSnapshotter |
|
| DiagUpdateRate |
|
| ElementSequencer<T> |
|
| EngineBlockFiles |
|
| EnumReadableMappingFilter<E extends java.lang.Enum<E> & ResultReadable> |
A result reading filter which uses an Enum as a set of elements to filter.
|
| Evaluator<T> |
An evaluator is a scripting helper that knows what its return type will be at runtime.
|
| EventedOpImpl<D> |
|
| ExceptionCountMetrics |
Use this to provide exception metering in a uniform way.
|
| ExceptionHistoMetrics |
Use this to provide exception histograms in a uniform way.
|
| ExceptionMeterMetrics |
Use this to provide exception metering in a uniform way.
|
| ExperimentalResultFilterType |
|
| ExperimentalResultFilterType.StaticDispenser |
|
| FailedOp<D> |
A failed op is any operation which has an error, according to the semantics
of the implementing activity type.
|
| FilteringInputDispenser |
|
| FilteringOutputDispenser |
|
| FluentOp |
|
| HashedErrorHandler<T extends java.lang.Throwable,R> |
Allow error handlers to be registered for any exception type, with an explicit handler
that will be called if no specific other handler is matched.
|
| HdrDeltaHistogramAttachment |
Allow a DeltaHistogram to have attached metrics that also get a copy of
any input data.
|
| HdrDeltaHistogramProvider |
|
| HistogramAttachment |
|
| HistoIntervalLogger |
HistoIntervalLogger runs a separate thread to snapshotAndWrite encoded histograms on a regular interval.
|
| HistoLogChartGenerator |
|
| HistoLogger |
|
| HistoStatsCSVWriter |
|
| HistoStatsLogger |
HistoIntervalLogger runs a separate thread to snapshotAndWrite encoded histograms on a regular interval.
|
| HybridRateLimiter |
Synopsis
|
| IncludeCodesTypeExperimental |
A naive implementation of set filtering on integer values.
|
| IndicatorMode |
|
| Input |
|
| InputDispenser |
An InputDispenser is created for each Activity instance within a scenario.
|
| InputFilterDispenser |
|
| InputInterval |
|
| InputInterval.Segment |
|
| InputMapper |
|
| InputType |
|
| IntervalSequencer<T> |
Introduction
|
| IntPredicateDispenser |
|
| LeastWorstDelay |
|
| LoggingMarkerDispenser |
|
| LoggingOutput |
|
| longIntervalSupplier |
|
| LongTreeTracker |
Using the 64 bit structure of a long as a heap addressed
tracker, where the leaf nodes represent marked values and
all others are used to consolidate state.
|
| LongTreeTrackerAtomic |
This is a version of longTreeTracker that is safe for concurrent access.
|
| MetricRegistryService |
|
| MetricsCloseable |
|
| MetricsRegistryMount |
|
| Motor<T> |
The core threading harness within an activity.
|
| MotorDispenser<T> |
A MotorDispenser is created for each Activity instance within a scenario.
|
| MultiMapLookup |
|
| MultiPhaseAction |
A continuing action can ask to be iterated within the cycle.
|
| MutableCycleResult |
|
| Named |
|
| NashornEvaluator<T> |
public void setBindings(Bindings bindings, int scope);
|
| NicerHistogram |
|
| NicerTimer |
|
| OldCoreTracker |
|
| OpEvents<D> |
|
| OpFacets<D> |
This interface represents the union of interfaces needed for all of the
behavioral facets of a useful Op implementation.
|
| OpImpl<D> |
|
| OpSequence<T> |
An OpSequence provides fast access to a set of operations in a specific
order.
|
| OpTracker<D> |
|
| OpTrackerImpl<D> |
This tracker keeps track of the state of operations associated with it.
|
| Output |
A cycle marker is simply a type that knows how to do something
useful with the result of a particular cycle.
|
| OutputDispenser |
|
| OutputType |
|
| ParameterMap |
A concurrently accessible parameter map which holds both keys and values as strings.
|
| ParameterMap.Listener |
|
| ParameterMap.NamedParameter |
|
| ParamsParser |
|
| ParsedStmt |
Allow for uniform statement anchor parsing, using the
|
| Payload<D> |
This op context carries with it a data element which a protocol-specific
implementation can use to hold the state and logic for operations.
|
| PeriodicRunnable<T extends java.lang.Runnable> |
This is a simple and light way to run a periodic task
|
| ProgressCapable |
Any type that implements this interface can provide a double indicating relative progress.
|
| ProgressMeter |
|
| RateLimiter |
|
| RateLimiters |
|
| RateLimiters.BurstRateGauge |
|
| RateLimiters.RateGauge |
|
| RateLimiters.WaitTimeGauge |
|
| RateSpec |
Rate Limiter Specifications
|
| RateSpec.Verb |
|
| RawStmtDef |
|
| RawStmtsBlock |
A StmtsDef contains a list of rawStmts, as well as all of the optional
block parameters that can be assigned to BlockParams, which includes
a name, config values, data bindings, and filtering tags. |
| RawStmtsDoc |
A statements doc can have both a list of statement blocks and/or a
list of statements.
|
| RawStmtsDocList |
|
| RawYamlStatementLoader |
|
| ReorderingConcurrentResultBuffer |
This will implement a result buffer that puts cycles in order when possible,
according to a sliding window.
|
| ResultFilterDispenser |
|
| ResultFilteringSieve |
|
| ResultFilteringSieve.Builder |
|
| ResultFilterPhase |
|
| ResultMappingArrayFilter |
|
| ResultReadable |
|
| ResultValueFilterType |
|
| RunState |
|
| SandboxPlugin |
Any object can be a sandbox extension.
|
| ScriptEnvBuffer |
ScriptEnvBuffer provides a variant of SimpleScriptContext which captures all
stdin, stdout, and stderr data into diagnostic character buffers.
|
| ScriptingPluginInfo<T> |
Any implementation of a SandboxExtension that is found in the runtime
can be automatically loaded into the scenario scripting sandbox.
|
| SegmentedResultInput |
|
| SequencePlanner<T> |
|
| SequencePlanner.Sequence<T> |
|
| SequencerType |
Sequencer types are used to control the type of ordering used with a set of
operations.
|
| Shutdownable |
|
| SimpleActivity |
A default implementation of an Activity, suitable for building upon.
|
| SimpleConfig |
|
| SimpleServiceLoader<T extends Named> |
|
| SkippedOp<D> |
|
| SlotStateTracker |
Holds the state of a slot, allows only valid transitions, and shares the
slot state as
|
| SnakeYamlCharmer |
This is as arcane and strange looking as it sounds.
|
| SnakeYamlCharmer.FieldHandler |
|
| SnakeYamlCharmer.ReSafeConstructor |
|
| SSLKsFactory |
|
| Startable |
|
| StartedOp<D> |
A StartedOp is a type that represents that an operation has been sent to some
specific type of protocol or logic.
|
| StatementsLoader |
|
| StatementsOwner |
|
| StmtDef |
|
| StmtsBlock |
|
| StmtsDoc |
StmtsDoc creates a logical view of a statements doc that includes
all inherited and overridden values for bindings, tags, and params.
|
| StmtsDocList |
|
| Stoppable |
|
| StrideAware |
Any activity that implements StrideAware will be notified of the
exact interval that it is processing before the first cycle
is dispatched from the motor.
|
| StrideOutputConsumer<D> |
|
| StrideOutputSegment<D> |
|
| StrideOutputSegmentImpl<D extends CompletedOp> |
|
| StrideTracker<D> |
|
| StrInterpolater |
|
| SucceededOp<D> |
An op should be deemed successful if it completes with no exception.
|
| SyncAction |
|
| SysBenchMethodNanoTime |
|
| SysBenchMethodNanoTime_callSystemNanoTime_jmhTest |
|
| SysBenchMethodNanoTime_jmhType |
|
| SysBenchMethodNanoTime_jmhType_B1 |
|
| SysBenchMethodNanoTime_jmhType_B2 |
|
| SysBenchMethodNanoTime_jmhType_B3 |
|
| SysBenchMethodParkNanos |
|
| SysBenchMethodParkNanos_callLockSupportParkNanos_jmhTest |
|
| SysBenchMethodParkNanos_jmhType |
|
| SysBenchMethodParkNanos_jmhType_B1 |
|
| SysBenchMethodParkNanos_jmhType_B2 |
|
| SysBenchMethodParkNanos_jmhType_B3 |
|
| SysBenchMethodThreadSleep |
|
| SysBenchMethodThreadSleep_callThreadSleep_jmhTest |
|
| SysBenchMethodThreadSleep_jmhType |
|
| SysBenchMethodThreadSleep_jmhType_B1 |
|
| SysBenchMethodThreadSleep_jmhType_B2 |
|
| SysBenchMethodThreadSleep_jmhType_B3 |
|
| SysPerf |
|
| SysPerfBaseliner |
|
| SysPerfData |
|
| TagFilter |
This class makes it easy to associate tags and tag values with Tagged
items, filtering matching Tagged items from a set of candidates. |
| TagFilter.Result |
|
| Tagged |
|
| Tags |
|
| TargetRateInputType |
|
| TargetRateInputType.Dispenser |
|
| TimerAttachment |
|
| TokenFiller |
|
| TokenPool |
Synopsis
|
| TrackedOp<D> |
A tracked op is one that has been added to a tracker, and can
then be started.
|
| TreeTracker1024 |
Wrap 32 of the 32-position LongTreeTrackers together, allowing
for a range of 0-1023 positions.
|
| TristateFilter<T> |
A tri-state filter allows for flexible configuration of
multi-phase filtering.
|
| TristateFilter.DefaultingPredicate<T> |
|
| TristateFilter.MatchingPredicate<T> |
|
| TristateFilter.Policy |
The filter action determines what action is taken for a given
element that matches the predicate.
|
| Unit |
|
| Unit.Bytes |
|
| Unit.Count |
|
| Unit.Duration |
|