| Age | Commit message (Collapse) | Author |
|---|
|
CPUs are combined into one. This is for performance and explainability. (#255)
|
|
* Added a max failure for tasks. If tasks fail more times, they get cancelled
* Added maxNumFailures to the frontend
* Updated tests
|
|
* Updated the checkpointing system to use SimTrace. The checkpoint model can now also scale, which means the interval between checkpoints can increase or decrease over time.
* spotless kotlin
* Fixed tests
* spotless apply
|
|
* Started on reimplementing the SimTrace implementation
* updated trace format. Fragments now do not have a deadline, but a duration. The Fragments are executed in order.
|
|
* Updated SimTrace to use a single ArrayDeque instead of three separate lists for deadline, cpuUsage, and coreCount
* Renamed input files to tasks.parquet and fragments.parquet. Renamed server to task. OpenDC nows exports tasks.parquet instead of server.parquet
|
|
for deadline, cpuUsage, and coreCount (#245)
|
|
|
|
|
|
* Fixed a problem which caused the CPU limit to be much lower than it should be.
AllocationPolicy is now properly exposed to the user
* Fixed tests
* spotless kotlin
|
|
Added host_name to the host output file.
Added boot_time_absolute to the server output file.
renamed absolute_timestamp to timestamp_absolute in all output files
|
|
|
|
* unversioned demo - removed from git history
unversioned filed pushed
spotless applied
code cleaned up
commit before pr
spotless applied
setupOutputFolder moved before getting the scenarios
specific topology added
pretty tracking
given scenarios are kept track by id
code runnable
output name for scenario updated
python folder and src document connected
simulationOutputFolder structure prepared
base for python script integration in simulations
output contents into a folder defined by the simulation name
output contents into a folder defined by the simulation name
* bugs with trackr.json (id not showing) solved. outputting bug also solved (now we use the output folder indicated in scenario.json input file)
* spotless applied, ready for PR
* var -> val in Scenario
* ScenarioWriter package naming repaired
|
|
into objects when the scenario is being executed by ScenarioRunner.kt (#227)
|
|
|
|
* Updated the power models and added tests
* Updated test topologies
|
|
* sync with the master branch
* rebase
* multimodel - simulation is currently run as many times as you can see a model
* factory method - handles models without given params
* removed redundant flags
* modelType
* flags removed
* implemented output into a folder
* multimodel ipynb setup - to be implemented and also ran as a python script, when the simulation occurs
* towards a mutimodel python implementation - issue observed - the saved files have same data?
* json parsing handles now lists for topology, workloads, allocaitonPolicies, powerModels
* scenarioFile inputs lists, and creates multiple combinations of scenarios
* multi-model prediction repaired, now we predict using multiple models
* commit before removing powerModel from scenario
* commit after removing powerModel from scenario
* commit after removing powerModel from scenario (and actually running)
* powermodels now can output their name and full name (with min and max)
* now we can select where to output (seed or output folder)
* input files - clear naming + output naming improved
* minimal changes
* all tests passing + json files from tests updated to the new json format
* json files from topology now accept only one power model (instead of list)
* json files from topology now accept only one power model (instead of list)
* multi and single input from tests updated to match the format
* tests passed locally
* spotless applies
* demo folder removed
|
|
* Started with the carbon trace implementation
* Moved the carbon trace system to the proper folders
|
|
|
|
* Initial commit
* Implemented a new systems of defining and running scenarios / portfolios. Scenarios and Portfolios can now be defined using JSON files similar to topologies. This allows user to define experiments without changing any KotLin code.
* Ran spotlessApply
|
|
* Updated the topology format to JSON. Updated TopologyReader.kt to handle JSON filed. Added documentation for the new format.
* applied spotless kotlin
* small update
* Updated for spotless apply
* Updated for spotless apply
|
|
* Updated all package versions including kotlin. Updated all web-server tests to run.
* Changed the java version of the tests. OpenDC now only supports java 19.
* small update
* test update
* new update
* updated docker version to 19
* updated docker version to 19
|
|
* Updated metrics to consistently be ms
* Updated metrics to consistently be ms
* Updated metric documentation on the site
* Updated some tests to work with the updated metrics
|
|
* Started with a documentation page
* Started with a documentation page
* Added documentation of the input required to run OpenDC, and the output returned by OpenDC to the website.
|
|
* Updated metrics and parquet output
* fixed typos
|
|
* removed experiment-compute and integrated all components into opendc-compute
* updated workflow gradle file
* removed unneeded code
|
|
* made sure all tests run
* fixed typo
* executed spotlessApply
* added back web-server tests
* updated SimTraceWorkloadTest
* commented CapelinRunneer and GreenifierRunner tests
* commented one SimTraceWorkloadTest
* altered codecov execution
* changed codecov
|
|
|
|
This change inlines the implementation of the compute service into the
`ComputeService` interface. We do not intend to provide multiple
implementations of the service. In addition, this approach makes more
sense for a Java implementation.
|
|
This change updates the implementation of the compute service to expose
state to clients created by the compute service.
|
|
This change updates the API interface of the OpenDC Compute service to
not suspend execution using Kotlin Coroutines.
The suspending modifiers were introduced in case the ComputeClient would
communicate with the service over a network connection. However, the main
use-case has been together with the ComputeService, where the suspending
modifiers only frustrate the user experience when writing experiments.
Furthermore, with the advent of Project Loom, it is not necessarily a
problem to block the (virtual) thread during network communications.
|
|
This change replaces the use of `CoroutineContext` for passing the
`SimulationDispatcher` across the different modules of OpenDC by the
lightweight `Dispatcher` interface of the OpenDC common module.
|
|
This change updates the `SimulationScheduler` class to implement the
`Dispatcher` interface from the OpenDC Common module, so that OpenDC
modules only need to depend on the common module for dispatching future
task (possibly in simulation).
|
|
This change updates the modules of OpenDC to always accept
the `InstantSource` interface as source of time. Previously we used
`java.time.Clock`, but this class is bound to a time zone which does not
make sense for our use-cases.
Since `java.time.Clock` implements `java.time.InstantSource`, it can be
used in places that require an `InstantSource` as parameter. Conversion
from `InstantSource` to `Clock` is also possible by invoking
`InstantSource#withZone`.
|
|
This change updates the modules of OpenDC to always accept
the `RandomGenerator` interface as source of randomness. This interface
is implemented by the slower `java.util.Random` class, but also by the
faster `java.util.SplittableRandom` class
|
|
This change updates the interface of `SimWorkload` to support
snapshotting workloads. We introduce a new method `snapshot()` to this
interface which returns a new `SimWorkload` that can be started at a
later point in time and on another `SimMachine`, which continues
progress from the moment the workload was snapshotted.
|
|
This change updates the `Guest` class implementation to use a static
logger field instead of allocation a new logger for every guest.
|
|
This change updates the `Host` interface to remove the suspend modifiers
to the start, stop, spawn, and delete methods of this interface. We now
assume that the host immediately launches the guest on invocation of
this method.
|
|
This change updates `SimHost` to support modeling the time and resource
consumption it takes to boot the host. The boot procedure is modeled as a
`SimWorkload`.
|
|
This change updates the implementation of `SimHost` to use workload
chaining for modelling boot delays. Previously, this was implemented by
sleeping 1 millisecond using Kotlin coroutines. With this change, we
remove the need for coroutines and instead use the `SimDurationWorkload`
to model the boot delay.
In the future, we envision a user-supplied stochastic boot model to
model the boot delay for VM instances.
|
|
This change updates the interface of `SimMachine#startWorkload` to
introduce a parameter `completion` that is invoked when the workload
completes either succesfully or due to failure.
This functionality has often been implemented by wrapping a
`SimWorkload` and catching its exceptions. However, since this
functionality is used in all usages of `SimMachine#startWorkload` we
instead embed it into `SimMachine` itself.
|
|
This change adds the log4j-core dependency to various modules of OpenDC
using log4j2, to ensure logging keeps working. The upgrade to SLF4J 2.0 broke
the Log4j2 functionality, since the log4j-core artifact is not
automatically shipped with the SLF4J implementation.
|
|
This change re-implements the OpenDC compute simulator framework using
the new flow2 framework for modelling multi-edge flow networks. The
re-implementation is written in Java and focusses on performance and
clean API surface.
|
|
This change updates the compute service telemetry to also expose the
number of servers that are registered with the service.
|
|
This change updates the build configuration to use Spotless for code
formating of both Kotlin and Java.
|
|
This change updates the repository to remove the use of wildcard imports
everywhere. Wildcard imports are not allowed by default by Ktlint as
well as Google's Java style guide.
|
|
This change renames the method `runBlockingSimulation` to
`runSimulation` to put more emphasis on the simulation part of the
method. The blocking part is not that important, but this behavior is
still described in the method documentation.
|
|
This change updates the implementation of `SimulationDispatcher` to use
a (possibly user-provided) `SimulationScheduler` for managing the
execution of the simulation and future tasks.
|
|
This change integrates the classes from the old
`opendc-compute-workload` module into the `opendc-experiments-compute`
module. This new module contains helper classes for setting up
experiments with the OpenDC compute service.
|
|
This change adds a new module `opendc-experiments-compute` that provides
provisioner implementations for experiments to use for setting up the
compute service of OpenDC and provisioning (simulated) hosts.
|
|
This change updates the interface of `ComputeService` to provide access
to the instances (servers) that have been registered with the compute
service. This allows metric collectors to query the metrics of the
servers that are currently running.
|
