| Age | Commit message (Collapse) | Author |
|---|
|
This change makes a `SuspendingBehavior` instance expose its
`SuspendingActorContext` in the coroutine context, so suspending methods
inside the coroutine can access the actor context.
|
|
This change adds conversion methods from `Number` types into `Instant`
and `Duration` instances.
|
|
This change updates the build dependencies to recent released version.
These include Kotlin 1.3.21 and ktlint Gradle plugin 7.1.0.
|
|
This change makes exception handling in actor systems consistent.
Implementors should not propagate unhandled exceptions in actors to the
(one of the) threads running the engine, but instead should stop the
offending actor and continue running.
Supervision of actors should be implemented within actor behavior
instead. Since BehaviorInterpreter will propagate exceptions thrown by
an actor, consumers of that API can use it to catch unhandled exceptions in an
actor.
|
|
This change updates JUnit dependency to version 5.3.2.
|
|
This change updates the Gradle wrapper that is shipped with the
repository to version 5.1.
|
|
This change adds support for generating documentation for all modules of
the repository using Dokka.
|
|
This change adds support for suspending behavior via Kotlin's coroutine
feature officially introduced in Kotlin 1.3. The syntax is similar to
the 1.x version of the simulator to allow for easier porting to 2.x.
|
|
This change adds support for linting the code base using ktlint and the
excellent ktlint-gradle plugin.
|
|
This change adds support for deferred and special behavior in the
Behavior API. Additionally, the new Behavior DSL is implemented using
the new primitives to make the tests cleaner.
|
|
This change updates the code base to use the official Kotlin 1.3
release.
|
|
This change creates the initial conformance test suite for the API
design and tries to specify most of the requirements and assumptions
made for implementors.
|
|
This change introduces the new API design that will be introduced in the
2.x versions of the OpenDC Simulator.
This changes focuses on simplifying simulation primitives provided by
the simulator and introduces a new concept of actors based on the model
designed by the Akka Typed project.
For now, the old simulation models have been removed from the branch,
but will be ported back as this branch is being finalized.
|
|
This change will improve exception handling of processes.
At the moment, when a process throws an uncaught exception, the kernel will catch and log the exception, stop the offending process and then continue. This approach however might cause the user to overlook possible exceptions in processes and does not give any ability to the user for handling these exception.
This change modifies the kernel implementation and specification such that the `step()` method (and consequently `run()`) must propagate uncaught exceptions that occur in processes. This allows the caller to control the way exceptions are handled.
|
|
This change fixes a bug where a process would be resumed again after it
had crashed, bringing down the kernel.
Fixes #27
|
|
This change refactors the calls to the recently deprecated
`CoroutineScope.coroutineContext` to use top-level `coroutineContext`
property instead.
This deprecation is the result of moving to the latest version of the
`koltinx-coroutines` library. See
https://github.com/Kotlin/kotlinx.coroutines/blob/master/CHANGES.md for
more information.
|
|
This change updates download instructions for the source code in the README.
The instructions reference an old branch that does not exist anymore
since the transition to the Kotlin codebase.
|
|
This pull requests updates the project as follows:
1. **Update Gradle version to 4.8**
This allows us to make use of new features such as native JUnit 5 integration and the build cache.
2. **Update Gradle build configuration according to new changes**
This change allows us to share configuration across modules and easily change the versions for shared dependencies. In addition, we now make use of the `java-library` plugin which allows for various optimizations. See https://docs.gradle.org/current/userguide/java_library_plugin.html
3. **Add support for Jacoco**
We add support code coverage tracking via the latest version of Jacoco which has increasing support for Kotlin.
Closes #22
|
|
This change adds support for Jacoco in the build toolchain.
|
|
This change updates the Gradle build configuration in order to make use
of the native JUnit 5 integration and the newest Kotlin and Dokka
plugins.
|
|
This change updates the Gradle wrapper version included in the
repository to version 4.8 which includes native JUnit 5 integration.
|
|
This pull request implements interpolation of task progress
(represented as the `TaskState` and `MachineState` class) via the
Interpolation helpers implemented in #20. The model assumes that tasks progress
linearly between two measurements (since the time between measurements is
usually small).
|
|
These changes contain the specification of the new Instrumentation API for the simulator, in addition to the implementation for the Omega kernel. As an example, the API allows users to measure data from processes in simulation and interpolate data points between the measurements.
Closes #11, #12
|
|
This change will make the simulator by default buffer all measurements
of attached instruments to prevent strange situations where certain
measurements are not recorded due to the processing running on another
thread.
|
|
This change in Instrumentation API allows the user to close the data
stream of an instrument by introducing a new concept: Port. A user can
open a `Port` for a `Simulation` object and attach an arbitrary amount of
instruments to this port. The data streams are closed by calling
`Port#close()`.
|
|
This change adds interpolation functionality to the standard library for
instrumentation devices.
|
|
These changes implement the Instrumentation API described in issue #11
into the Omega simulation kernel.
|
|
This commit creates the interfaces for the new Instrumentation API
described in issue #11. This interface allows users to plug an
instrumentation device into a (live) simulation in order extract
measurements from the simulation.
|
|
This change contains the redesign of the core simulation API and
provides a cleaner interface for developing simulation models for the
users.
Closes #18
|
|
This change simplifies the `Context` interface to reduce the amount of
methods required to implement by implementors.
|
|
This change removes the unused transformation receive methods from the
`Context` class as this functionality can now be easily implemented in
the standard library using the newly introduced `sender` property.
|
|
This change fixes the bug where the insertion order into the message
queue was not guaranteed for messages arriving at the same time, causing
some non-deterministic behaviour.
|
|
|
|
This change provides a method in the standard library to access the
process context in nested suspending function calls.
|
|
This change adds a `sender` property to the `Context` interface to
provide processes access to the sender of the latest received message.
Please note that methods like `hold()` and `interrupt()` may change the value
of this property.
|
|
This change fixes the broken implementation of the `receive()` method
with a timeout due to an invalid condition.
|
|
This change will make the kernel handle the launch of processes using a
kernel process that is launched at the start of the simulation and
launches processes when it receives `Launch` messages.
|
|
This change creates a distinction between a kernel and a simulation.
A single simulation is represented by a `Simulation` object which
provides control over the simulation, while the `Kernel` interface
allows users to create a new simulation using that kernel as backend.
|
|
This change fixes the deployment of the OpenDC simulation model.
|
|
This change will make the simulation kernel launch the processes at the
initial run instead of when the processes are registered.
|
|
This change aligns the code formatting of the project with the official
Kotlin Style Guide. They can be found at
http://kotlinlang.org/docs/reference/coding-conventions.html.
|
|
This change bumps the version of the dependencies used by the project.
|
|
This change contains the redesign of the core simulation API and
provides a cleaner interface for developing simulation models for the
users.
|
|
This change adds a timeout for experiments, which allows the user to set
an upper bound on the duration of an experiment.
Closes #3
|
|
This change prevents the currently available scheduler implementations
from scheduling tasks to machines without processing units, since these
machines cannot perform any work.
Closes #4
|
|
This change fixes a bug where sending a message to a stopped process
(gracefully or forced) would crash the simulation kernel with an
UninitializedPropertyAccessException.
This was caused by the fact that these processes still existed in the
registry, which caused the kernel to lookup a non-existent continuation
of a process.
This change will make the kernel remove stopped processes from the
registry, so they cannot be found anymore.
Closes #15
|
|
This change improves the Docker deployment by moving the build process
from runtime to (image) build time. Also, the opendc-integration-jpa
module now consists of a core and mysql module, where the mysql module
is a specific deployment of the integration.
|
|
This change fixes the interference of multiple experiments running at
the same time due to some thread unsafe behaviour in the
JpaExperimentManager class.
The code has now been restructured to solve the issue and fix the thread
unsafe behaviour.
Closes #9.
|
|
|
|
This change will make Travis CI build the Gradle project and run the
test suite when pushing and on pull requests.
Closes #7
|
