| Age | Commit message (Collapse) | Author |
|---|
|
This change adds a new column to resource table of the OpenDC trace format for
the CPU capacity provisioned for a virtual machine, so that this
capacity can be assigned to the virtual machine during simulation.
|
|
This change addresses an issue where the timestamps in the Azure trace
where not retrieved correctly from the files.
|
|
This change updates the Azure VM trace format implementation to directly
support loading a trace in GZIP format in order to prevent users having
to decompress the trace files so they can be opened by OpenDC.
|
|
This pull request addresses several regressions that have been introduced in the past few pull requests.
- Fix queue resizing logic
- Change clock resolution from milliseconds to nanoseconds in `OtelClockAdapter`
- Compute energy usage in absence of convergence
- Fix duplicate classpath entries
- Fix release workflow
**Breaking API Changes**
- `OtelClockAdapter` now exports time in nanoseconds as the method contract describes.
|
|
This change fixes an issue with a missing whitespace in the release
workflow, causing the workflow to not be parsed correctly.
|
|
This change fixes an issue with the JMH plugin where entries would be
included twice on the classpath or entries that did not belong on the
classpath were also included.
|
|
This change addresses an issue where energy usage was not computed
correctly if the machine performed no work in between collection cycles.
|
|
This change updates the Clock adapter for OpenTelemetry to return the
current time in nanoseconds as specified by the method contract (as
opposed to milliseconds).
|
|
This change fixes two issues with the resizing logic of the specialized
queue implementations used by the FlowEngine implementation.
|
|
This pull request integrates the changes planned for the v2.1 release of
OpenDC into the public Github repository in order to sync the progress
of both repositories.
|
|
This change adds a tooltip to the graphs in the portfolio results, in order to
make it easier to read exact values from the graphs.
|
|
This change fixes the version number in package.json which contained the
suffix "-rc1", which is apparently not supported by npm.
|
|
This pull request applies multiple performance improvements for the flow engine and
compute simulator.
* Optimize SimTraceWorkload (by storing fragments using several arrays)
* Skip fair-share algorithm if capacity remaining
* Count interference for multiplexer inputs
* Simplify FlowSink implementation
* Do not update outputs if rate is unchanged
* Eliminate ArrayList iteration overhead
* Optimize clock storage
* Specialize FlowEngine queues
* Eliminate clock access in hot path
**Breaking API Changes**
* `SimTraceWorkload` now accepts a `SimTrace` as parameter. This trace can be constructed using fragments or directly using builder class. Internally, the trace is now stored using several arrays.
|
|
This change eliminates the clock calls in the hot path, by passing the
current timestamp directly as method parameter.
|
|
This change specializes the queues used by the FlowEngine implementation
in order to reduce the overhead caused by type-erasure of generics.
|
|
|
|
This change eliminates the overhead caused by ArrayList iteration in the
MaxMinFlowMultiplexer class.
|
|
|
|
This change simplifies the FlowSink implementation by not relying on the
AbstractFlowConsumer, but instead implementing the FlowConsumer
interface itself.
|
|
This change updates the SimAbstractHypervisor and MaxMinFlowMultiplexer
to count interference of multiplexer inputs, instead of only counting
them for the scheduler as a whole.
|
|
This change updates the MaxMinFlowMultiplexer implementation to skip the
fair-share algorithm in case the total demand is lower than the
available capacity. In this case, no re-division of capacity is
necessary.
|
|
This change improves the performance of the SimTraceWorkload class by
changing the way trace fragments are read and processed by the CPU
consumers.
|
|
This pull request adds a JMH benchmark for the Capelin experiments, in order to concretely measure
the bottlenecks in these experiments.
* Do not prune invocations on sync engine invocation
* Add benchmark for Capelin experiment
* Extract scheduler for max min multiplexer
* Only sort outputs on capacity change
|
|
This change removes the sorting step for the outputs in the scheduling
procedure for the max min multiplexer. This step is only necessary when
the capacity of one of the outputs changes, which does not happen often.
|
|
|
|
|
|
This change updates the MaxMinFlowMultiplexer implementation to
centrally manage the deadlines of the `FlowSource`s as opposed to each
source using its own timers. For large amounts of inputs, this is much
faster as the multiplexer already needs to traverse each input on a
timer expiration of an input.
|
|
|
|
|
|
This pull request converts the `opendc-simulator-resources` module into a flow
simulator and adapts the existing low-level models (e.g., CPU, network, disk)
to this new flow simulator.
The flow simulator works differently from the uniform resource consumption
model, in that it models flow through a system of connections, as opposed to
resource consumptions. Concretely, this means that while in the uniform
resource consumption model, consumptions with the same usage are propagated to
the resources, in the flow simulator, only changes to the flow in the system
are propagated.
Overall, this leads to less updates in the system and therefore higher
performance. The benchmarks shows that the new implementation obtains more than
double the performance of the old implementation. We have focused in the new
implementation on reducing the amount of work and memory
allocations/loads/stores per updates.
* Migrate from kotlinx-benchmark to jmh-gradle (for better profiling support)
* Use longer traces for benchmarks (to prevent measuring the benchmark
overhead)
* Use direct field access for perf-sensitive code
* Combine work and deadline to duration
* Add support for pushing flow from context (to eliminate the allocation for
every `SimResourceCommand`)
* Reduce memory allocations in SimResourceInterpreter, by revamping the way
timers are allocated.
* Simplify max-min aggregator implementation (by utilizing the new push
mechanism)
* Invoke consumer callback on every invalidation (in order to propagate changes
downstream)
* Lazily push changes to resource context (by not updating the flow rate
immediately after a push, but only after an update)
* Remove onUpdate callback
* Merge distributor and aggregator into switch
* Separate push and pull flags
* Remove failure callback from FlowSource
* Create separate callbacks for remaining events
* Make convergence callback optional
* Reduce field accesses in FlowConsumerContextImpl
* Optimize hot path in SimTraceWorkload
* Expose CPU time counters directly on hypervisor
* Optimize telemetry collection
**Breaking API Changes**
* The entire `opendc-simulator-resources` module has been replaced by the
`opendc-simulator-flow` module.
* `SimHypervisor.Listener` has been removed in favour of a new interface that
exposes the performance counters of the hypervisor directly. To listen for
convergence, use `FlowConvergenceListener`.
|
|
This change optimizes the telemetry collection in the SimHost class.
Previously, there was significant overhead in collecting the metrics of
this and associated classes due large `Attributes` object that did not
cache accesses to `hashCode()`. We now wrap this object and manually
cache the hash code.
|
|
This change adds a new interface to the SimHypervisor interface that
exposes the CPU time counters directly. These are derived from the flow
counters and will be used by SimHost to expose them via telemetry.
|
|
This change optimizes the hot path of the SimTraceWorkload class. This
class is used by multiple experiments to replay workload traces and
consumes a considerable amount of time of the total time of the
experiments.
By inlining the isExpired method, marking the properties on the Fragment
class as field, and caching several properties locally in the class, we
reduce the amount of virtual method calls in the hot path.
|
|
This change updates the implementation of FlowConsumerContextImpl to
reduce the number of field accesses by storing the flags of the
connection inside a single integer.
|
|
This change adds two new properties for controlling whether the
convergence callbacks of the source and consumer respectively should be
invoked. This saves a lot of unnecessary calls for stages that do not
have any implementation of the `onConvergence` method.
|
|
This change fixes the loss computation for both the UPS and PDU
implementation that was broken due to the new pushing mechanism. We
implement a new class FlowMapper that can be used to map the flow pushed
by a `FlowSource` using a user-specified method.
|
|
This change creates separate callbacks for the remaining events:
onStart, onStop and onConverge.
|
|
This change removes the Capacity entry from FlowEvent. Since the source
is always pulled on a capacity change, we do not need a separate event
for this.
|
|
This change removes the `onFailure` method from FlowSource. Instead, the
FlowConsumer will receive the reason for failure of the source.
|
|
This change reduces the number of operations necessary to manage the
timers of a flow connection.
|
|
This change removes the use of a HashSet for tracking the flow
connections that can converge. A HashSet requires an allocation for
every addition, which caused a significant overhead. The new approach
using an ArrayDeque should not allocate any memory.
|
|
This change separates the push and pull flags in
FlowConsumerContextImpl, meaning that sources can now push directly
without pulling and vice versa.
|
|
This change renames the `opendc-simulator-resources` module into the
`opendc-simulator-flow` module to indicate that the core simulation
model of OpenDC is based around modelling and simulating flows.
Previously, the distinction between resource consumer and provider, and
input and output caused some confusion. By switching to a flow-based
model, this distinction is now clear (as in, the water flows from source
to consumer/sink).
|
|
This change removes the ability to transform the duration of a pull from
the SimResourceForwarder class. This ability is not used anymore, since
pushes are now done using a method instead of a command.
|
|
This change removes the distributor and aggregator interfaces in favour
of a single switch interface. Since the switch interface is as powerful
as both the distributor and aggregator, we don't need the latter two.
|
|
This change removes the use of distributor and aggregator from the other
OpenDC components. For the future, we focus on maintaining a single
SimResourceSwitch implementation to achieve both use-cases.
|
|
|
|
This change hides the SimResourceState from public API since it is not
actively used outside of the `SimResourceContextImpl` class.
|
|
This change removes the `onUpdate` callback from the
`SimResourceProviderLogic` interface. Instead, users should now update
counters using either `onConsume` or `onConverge`.
|
|
This change updates the SimResourceContextImpl to lazily push changes to
the resource context instead of applying them directly. The change is
picked up after the resource is updated again.
|
