All Classes
| Class | Description |
|---|---|
| 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 | |
| ActivityDefAware | |
| 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.
|
| ActivityType<A extends Activity> |
An ActivityType is the central extension point in NB 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> | |
| 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 | |
| CLI | |
| CLIFacets | |
| CLIFacets.WantsAnyOption | |
| CLIFacets.WantsGlobalOption | |
| CLIFacets.WantsOptionType | |
| CLIFacets.WantsParameterizedCommand | |
| Colors |
ANSI console colors for enhanced logging
|
| CommandTemplate | Deprecated, for removal: This API element is subject to removal in a future version. |
| 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 NB when
the input cycles are known to be contiguous.
|
| 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 | |
| CounterErrorHandler | |
| CountErrorHandler |
This is here to allow the classic name 'count' to work although the
modern error handler scheme uses canonical metric type names.
|
| 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 | |
| DiagRunnableOp | |
| DiagRunnableOpDispenser<O extends java.lang.Runnable> | |
| DiagRunnableOpMapper | |
| DiagUpdateRate | |
| ElementSequencer<T> | |
| EnumReadableMappingFilter<E extends java.lang.Enum<E> & ResultReadable> |
A result reading filter which uses an Enum as a set of elements to filter.
|
| EnumSetter<F extends java.lang.Enum<F>,T> |
Provide a way to configure a target object of type T, given an enumeration which describes the distinct property
types which could be configured.
|
| ErrorDetail | |
| ErrorDetail.Retry | |
| ErrorHandler | |
| ErrorMetrics | |
| ErrorMetrics.Aware | |
| 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.
|
| ExceptionTimerMetrics |
Use this to provide exception metering in a uniform way.
|
| ExperimentalResultFilterType | |
| ExperimentalResultFilterType.StaticDispenser | |
| ExprEvaluator<T> |
An evaluator is a scripting helper that knows what its return type will be at runtime.
|
| FailedOp<D> |
A failed op is any operation which has an error, according to the semantics
of the implementing activity type.
|
| FilteringInputDispenser | |
| FilteringOutputDispenser | |
| FluentOp | |
| GraalJsEvaluator<T> | |
| 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.
|
| HistogramErrorHandler |
The histogram error handler will create, if needed, a histogram metrics
object for the named
"errorhistos.simplename" + e.getClass().getSimpleName(),
and then add the current session time to it. |
| HistoLogger | |
| HybridRateLimiter |
Synopsis
|
| IgnoreErrorHandler | |
| IncludeCodesTypeExperimental |
A naive implementation of set filtering on integer values.
|
| IndicatorMode | |
| InlineTokenPool |
Synopsis
|
| 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.
|
| MeterErrorHandler | |
| Motor<T> |
The core threading harness within an activity.
|
| MotorDispenser<T> |
A MotorDispenser is created for each Activity instance within a scenario.
|
| MultiMapLookup<V> | |
| MultiPhaseAction |
A continuing action can ask to be iterated within the cycle.
|
| MutableCycleResult | |
| NBCLIScenarioParser | |
| NBErrorHandler | |
| NBErrorHandler.HandlerMapping | |
| NBInvokerType |
If you provide a type of invokable element in this list, then it should
automatically be handled by NB.
|
| NbYamlVersionCheck | |
| OldCoreTracker | |
| OpDef | |
| 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.
|
| OpSource<T> |
An OpSource provides an Op for a given long value.
|
| OpTracker<D> |
The Op Tracker is the keeper of concurrency and op states.
|
| OpTrackerImpl<D> |
This tracker keeps track of the state of operations associated with it.
|
| Output |
A cycle output is simply a type that knows how to do something
useful with the result of a particular cycle.
|
| OutputDispenser | |
| OutputType | |
| 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.
|
| ProgressAndStateMeter | |
| 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 | |
| RawScenarios | |
| RawStmtDef | |
| RawStmtFields | |
| RawStmtsBlock |
A StmtsDef contains a list of rawStmts, as well as all of the optional
block parameters that can be assigned to
RawStmtFields, 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 | |
| RawStmtsLoader | |
| RawYamlLoader | |
| ReorderingConcurrentResultBuffer |
This will implement a result buffer that puts cycles in order when possible,
according to a sliding window.
|
| ResultCode | |
| ResultFilterDispenser | |
| ResultFilteringSieve | |
| ResultFilteringSieve.Builder | |
| ResultFilterPhase | |
| ResultMappingArrayFilter | |
| ResultReadable | |
| ResultValueFilterType | |
| RetryErrorHandler | |
| RunState | |
| SandboxPlugin |
Any object can be a sandbox extension.
|
| Scenarios | |
| ScopedSupplier |
Helper class to consolidate the notions of scoping items over different
NB layers of execution.
|
| 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 | |
| Sequence<T> | |
| SequencePlanner<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 | |
| SkippedOp<D> | |
| SlotStateTracker |
Holds the state of a slot, allows only valid transitions, and shares the
slot state as
|
| StandardAction<A extends StandardActivity<R,?>,R extends io.nosqlbench.engine.api.activityimpl.uniform.flowtypes.Op> |
This is the generified version of an Action.
|
| StandardActionDispenser | |
| StandardActivity<R extends io.nosqlbench.engine.api.activityimpl.uniform.flowtypes.Op,S> |
This is a typed activity which is expected to be come the standard
core of all new activity types.
|
| StandardActivityType<A extends StandardActivity<?,?>> | |
| StandardOpMapper | |
| Startable | |
| StartedOp<D> |
A StartedOp is a type that represents that an operation has been sent to some
specific type of protocol or logic.
|
| StateCapable | |
| StatementsLoader | |
| StatementsOwner | |
| StmtsBlock | |
| StmtsDoc |
StmtsDoc creates a logical view of a statements doc that includes
all inherited and overridden values for bindings, tags, and params.
|
| StmtsDocList | |
| StopErrorHandler | |
| 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> | |
| StrInterpolator | |
| StrInterpolator.MultiMap | |
| 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 |
TagFilter Synopsis
|
| TagFilter.Result | |
| Tags | |
| TargetRateInputType | |
| TargetRateInputType.Dispenser | |
| ThreadDrivenTokenPool |
Synopsis
|
| TimerErrorHandler | |
| TokenFiller | |
| TokenPool | |
| 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.
|
| WarnErrorHandler | |
| WorkloadDesc |