Merge branch 'feat/cpu-sharing' into 'feat/2.x'

Add basis for VM modeling and fractional space-sharing

See merge request opendc/opendc-simulator!23

6 files changed, 1098 insertions, 1 deletions

diff --git a/odcsim/odcsim-api/build.gradle.kts b/odcsim/odcsim-api/build.gradle.kts
index 51a80d2c..c8c6c90c 100644
--- a/odcsim/odcsim-api/build.gradle.kts
+++ b/odcsim/odcsim-api/build.gradle.kts
@@ -31,6 +31,7 @@ plugins {
 
 dependencies {
     implementation(kotlin("stdlib"))
+    api("org.slf4j:slf4j-api:${Library.SLF4J}")
     api("org.jetbrains.kotlinx:kotlinx-coroutines-core:${Library.KOTLINX_COROUTINES}")
 
     testImplementation("org.junit.jupiter:junit-jupiter-api:${Library.JUNIT_JUPITER}")
diff --git a/odcsim/odcsim-api/src/main/kotlin/com/atlarge/odcsim/ProcessContext.kt b/odcsim/odcsim-api/src/main/kotlin/com/atlarge/odcsim/ProcessContext.kt
index 2a72e331..30ef4114 100644
--- a/odcsim/odcsim-api/src/main/kotlin/com/atlarge/odcsim/ProcessContext.kt
+++ b/odcsim/odcsim-api/src/main/kotlin/com/atlarge/odcsim/ProcessContext.kt
@@ -27,11 +27,13 @@ package com.atlarge.odcsim
 import java.time.Clock
 import kotlin.coroutines.CoroutineContext
 import kotlin.coroutines.coroutineContext
+import kotlinx.coroutines.CoroutineScope
+import org.slf4j.Logger
 
 /**
  * Represents the execution context of a logical process in simulation.
  */
-public interface ProcessContext : CoroutineContext.Element {
+public interface ProcessContext : CoroutineContext.Element, CoroutineScope {
     /**
      * Key for [ProcessContext] instance in the coroutine context.
      */
@@ -48,6 +50,11 @@ public interface ProcessContext : CoroutineContext.Element {
     public val clock: Clock
 
     /**
+     * A logger instance tied to the logical process.
+     */
+    public val log: Logger
+
+    /**
      * Spawn an anonymous logical process in the simulation universe with the specified [behavior].
      */
     public fun spawn(behavior: Behavior): ProcessRef
diff --git a/odcsim/odcsim-engine-omega/src/main/kotlin/com/atlarge/odcsim/engine/omega/OmegaSimulationEngine.kt b/odcsim/odcsim-engine-omega/src/main/kotlin/com/atlarge/odcsim/engine/omega/OmegaSimulationEngine.kt
index 11dae528..207d2768 100644
--- a/odcsim/odcsim-engine-omega/src/main/kotlin/com/atlarge/odcsim/engine/omega/OmegaSimulationEngine.kt
+++ b/odcsim/odcsim-engine-omega/src/main/kotlin/com/atlarge/odcsim/engine/omega/OmegaSimulationEngine.kt
@@ -33,6 +33,7 @@ import com.atlarge.odcsim.ReceiveRef
 import com.atlarge.odcsim.SendPort
 import com.atlarge.odcsim.SendRef
 import com.atlarge.odcsim.SimulationEngine
+import com.atlarge.odcsim.engine.omega.logging.LoggerImpl
 import java.time.Clock
 import java.time.Instant
 import java.time.ZoneId
@@ -54,6 +55,7 @@ import kotlinx.coroutines.channels.Channel as KChannel
 import kotlinx.coroutines.isActive
 import kotlinx.coroutines.selects.SelectClause1
 import org.jetbrains.annotations.Async
+import org.slf4j.Logger
 
 /**
  * The reference implementation of the [SimulationEngine] instance for the OpenDC simulation core.
@@ -188,6 +190,8 @@ class OmegaSimulationEngine(rootBehavior: Behavior, override val name: String) :
         override val clock: Clock
             get() = this@OmegaSimulationEngine.clock
 
+        override val log: Logger by lazy(LazyThreadSafetyMode.NONE) { LoggerImpl.invoke(this) }
+
         override fun spawn(behavior: Behavior): ProcessRef {
             val name = "$" + UUID.randomUUID()
             return this@OmegaSimulationEngine.spawn(behavior, name)
@@ -229,6 +233,10 @@ class OmegaSimulationEngine(rootBehavior: Behavior, override val name: String) :
         override val key: CoroutineContext.Key<*> = ProcessContext.Key
 
         @InternalCoroutinesApi
+        override val coroutineContext: CoroutineContext
+            get() = context
+
+        @InternalCoroutinesApi
         override val context: CoroutineContext = this + dispatcher + job
     }
 
diff --git a/odcsim/odcsim-engine-omega/src/main/kotlin/com/atlarge/odcsim/engine/omega/logging/LocationAwareLoggerImpl.kt b/odcsim/odcsim-engine-omega/src/main/kotlin/com/atlarge/odcsim/engine/omega/logging/LocationAwareLoggerImpl.kt
new file mode 100644
index 00000000..5db989e8
--- /dev/null
+++ b/odcsim/odcsim-engine-omega/src/main/kotlin/com/atlarge/odcsim/engine/omega/logging/LocationAwareLoggerImpl.kt
@@ -0,0 +1,567 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2019 atlarge-research
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.atlarge.odcsim.engine.omega.logging
+
+import com.atlarge.odcsim.ProcessContext
+import org.slf4j.Logger
+import org.slf4j.Marker
+import org.slf4j.helpers.MessageFormatter
+import org.slf4j.spi.LocationAwareLogger
+
+/**
+ * An actor-specific [Logger] implementation that is aware of the calling location.
+ *
+ * @param ctx The owning [ProcessContext] of this logger.
+ * @param delegate The [LocationAwareLogger] to delegate the messages to.
+ */
+internal class LocationAwareLoggerImpl(
+    ctx: ProcessContext,
+    private val delegate: LocationAwareLogger
+) : LoggerImpl(ctx), Logger by delegate {
+    /**
+     * The fully qualified name of this class.
+     */
+    private val fqcn = LocationAwareLoggerImpl::class.java.name
+
+    override fun trace(format: String?, arg: Any?) {
+        if (!delegate.isTraceEnabled) {
+            return
+        }
+
+        withMdc {
+            val formattedMessage = MessageFormatter.format(format, arg).message
+            delegate.log(null, fqcn, LocationAwareLogger.TRACE_INT, formattedMessage, arrayOf(arg), null)
+        }
+    }
+
+    override fun trace(format: String?, arg1: Any?, arg2: Any?) {
+        if (!delegate.isTraceEnabled) {
+            return
+        }
+
+        withMdc {
+            val formattedMessage = MessageFormatter.format(format, arg1, arg2).message
+            delegate.log(null, fqcn, LocationAwareLogger.TRACE_INT, formattedMessage, arrayOf(arg1, arg2), null)
+        }
+    }
+
+    override fun trace(format: String?, argArray: Array<Any?>) {
+        if (!delegate.isTraceEnabled) {
+            return
+        }
+
+        withMdc {
+            val formattedMessage = MessageFormatter.arrayFormat(format, argArray).message
+            delegate.log(null, fqcn, LocationAwareLogger.TRACE_INT, formattedMessage, argArray, null)
+        }
+    }
+
+    override fun trace(msg: String?, t: Throwable?) {
+        if (!delegate.isTraceEnabled) {
+            return
+        }
+
+        withMdc {
+            delegate.log(null, fqcn, LocationAwareLogger.TRACE_INT, msg, null, t)
+        }
+    }
+
+    override fun trace(marker: Marker?, msg: String?) {
+        if (!delegate.isTraceEnabled) {
+            return
+        }
+
+        withMdc {
+            delegate.log(marker, fqcn, LocationAwareLogger.TRACE_INT, msg, null, null)
+        }
+    }
+
+    override fun trace(marker: Marker?, format: String?, arg: Any?) {
+        if (!delegate.isTraceEnabled) {
+            return
+        }
+
+        withMdc {
+            val formattedMessage = MessageFormatter.format(format, arg).message
+            delegate.log(marker, fqcn, LocationAwareLogger.TRACE_INT, formattedMessage, arrayOf(arg), null)
+        }
+    }
+
+    override fun trace(marker: Marker?, format: String?, arg1: Any?, arg2: Any?) {
+        if (!delegate.isTraceEnabled) {
+            return
+        }
+
+        withMdc {
+            val formattedMessage = MessageFormatter.format(format, arg1, arg2).message
+            delegate.log(marker, fqcn, LocationAwareLogger.TRACE_INT, formattedMessage, arrayOf(arg1, arg2), null)
+        }
+    }
+
+    override fun trace(marker: Marker?, format: String?, argArray: Array<Any?>) {
+        if (!delegate.isTraceEnabled) {
+            return
+        }
+
+        withMdc {
+            val formattedMessage = MessageFormatter.arrayFormat(format, argArray).message
+            delegate.log(marker, fqcn, LocationAwareLogger.TRACE_INT, formattedMessage, argArray, null)
+        }
+    }
+
+    override fun trace(marker: Marker?, msg: String?, t: Throwable?) {
+        if (!delegate.isTraceEnabled) {
+            return
+        }
+
+        withMdc {
+            delegate.log(marker, fqcn, LocationAwareLogger.TRACE_INT, msg, null, t)
+        }
+    }
+
+    override fun debug(msg: String?) {
+        if (!delegate.isDebugEnabled) {
+            return
+        }
+
+        withMdc {
+            delegate.log(null, fqcn, LocationAwareLogger.DEBUG_INT, msg, null, null)
+        }
+    }
+
+    override fun debug(format: String?, arg: Any?) {
+        if (!delegate.isDebugEnabled) {
+            return
+        }
+
+        withMdc {
+            val formattedMessage = MessageFormatter.format(format, arg).message
+            delegate.log(null, fqcn, LocationAwareLogger.DEBUG_INT, formattedMessage, arrayOf(arg), null)
+        }
+    }
+
+    override fun debug(format: String?, arg1: Any?, arg2: Any?) {
+        if (!delegate.isDebugEnabled) {
+            return
+        }
+
+        withMdc {
+            val formattedMessage = MessageFormatter.format(format, arg1, arg2).message
+            delegate.log(null, fqcn, LocationAwareLogger.DEBUG_INT, formattedMessage, arrayOf(arg1, arg2), null)
+        }
+    }
+
+    override fun debug(format: String?, argArray: Array<Any?>) {
+        if (!delegate.isDebugEnabled) {
+            return
+        }
+
+        withMdc {
+            val ft = MessageFormatter.arrayFormat(format, argArray)
+            delegate.log(null, fqcn, LocationAwareLogger.DEBUG_INT, ft.message, ft.argArray, ft.throwable)
+        }
+    }
+
+    override fun debug(msg: String?, t: Throwable?) {
+        if (!delegate.isDebugEnabled) {
+            return
+        }
+
+        withMdc {
+            delegate.log(null, fqcn, LocationAwareLogger.DEBUG_INT, msg, null, t)
+        }
+    }
+
+    override fun debug(marker: Marker?, msg: String?) {
+        if (!delegate.isDebugEnabled) {
+            return
+        }
+
+        withMdc {
+            delegate.log(marker, fqcn, LocationAwareLogger.DEBUG_INT, msg, null, null)
+        }
+    }
+
+    override fun debug(marker: Marker?, format: String?, arg: Any?) {
+        if (!delegate.isDebugEnabled) {
+            return
+        }
+
+        withMdc {
+            val ft = MessageFormatter.format(format, arg)
+            delegate.log(marker, fqcn, LocationAwareLogger.DEBUG_INT, ft.message, ft.argArray, ft.throwable)
+        }
+    }
+
+    override fun debug(marker: Marker?, format: String?, arg1: Any?, arg2: Any?) {
+        if (!delegate.isDebugEnabled) {
+            return
+        }
+
+        withMdc {
+            val formattedMessage = MessageFormatter.format(format, arg1, arg2).message
+            delegate.log(marker, fqcn, LocationAwareLogger.DEBUG_INT, formattedMessage, arrayOf(arg1, arg2), null)
+        }
+    }
+
+    override fun debug(marker: Marker?, format: String?, argArray: Array<Any?>) {
+        if (!delegate.isDebugEnabled) {
+            return
+        }
+
+        withMdc {
+            val ft = MessageFormatter.arrayFormat(format, argArray)
+            delegate.log(marker, fqcn, LocationAwareLogger.DEBUG_INT, ft.message, argArray, ft.throwable)
+        }
+    }
+
+    override fun debug(marker: Marker?, msg: String?, t: Throwable?) {
+        if (!delegate.isDebugEnabled) {
+            return
+        }
+
+        withMdc {
+            delegate.log(marker, fqcn, LocationAwareLogger.DEBUG_INT, msg, null, t)
+        }
+    }
+
+    override fun info(msg: String?) {
+        if (!delegate.isInfoEnabled) {
+            return
+        }
+
+        withMdc {
+            delegate.log(null, fqcn, LocationAwareLogger.INFO_INT, msg, null, null)
+        }
+    }
+
+    override fun info(format: String?, arg: Any?) {
+        if (!delegate.isInfoEnabled) {
+            return
+        }
+
+        withMdc {
+            val formattedMessage = MessageFormatter.format(format, arg).message
+            delegate.log(null, fqcn, LocationAwareLogger.INFO_INT, formattedMessage, arrayOf(arg), null)
+        }
+    }
+
+    override fun info(format: String?, arg1: Any?, arg2: Any?) {
+        if (!delegate.isInfoEnabled) {
+            return
+        }
+
+        withMdc {
+            val formattedMessage = MessageFormatter.format(format, arg1, arg2).message
+            delegate.log(null, fqcn, LocationAwareLogger.INFO_INT, formattedMessage, arrayOf(arg1, arg2), null)
+        }
+    }
+
+    override fun info(format: String?, argArray: Array<Any?>) {
+        if (!delegate.isInfoEnabled) {
+            return
+        }
+
+        withMdc {
+            val formattedMessage = MessageFormatter.arrayFormat(format, argArray).message
+            delegate.log(null, fqcn, LocationAwareLogger.INFO_INT, formattedMessage, argArray, null)
+        }
+    }
+
+    override fun info(msg: String?, t: Throwable?) {
+        if (!delegate.isInfoEnabled) {
+            return
+        }
+
+        withMdc {
+            delegate.log(null, fqcn, LocationAwareLogger.INFO_INT, msg, null, t)
+        }
+    }
+
+    override fun info(marker: Marker?, msg: String?) {
+        if (!delegate.isInfoEnabled) {
+            return
+        }
+
+        withMdc {
+            delegate.log(marker, fqcn, LocationAwareLogger.INFO_INT, msg, null, null)
+        }
+    }
+
+    override fun info(marker: Marker?, format: String?, arg: Any?) {
+        if (!delegate.isInfoEnabled) {
+            return
+        }
+
+        withMdc {
+            val formattedMessage = MessageFormatter.format(format, arg).message
+            delegate.log(marker, fqcn, LocationAwareLogger.INFO_INT, formattedMessage, arrayOf(arg), null)
+        }
+    }
+
+    override fun info(marker: Marker?, format: String?, arg1: Any?, arg2: Any?) {
+        if (!delegate.isInfoEnabled) {
+            return
+        }
+
+        withMdc {
+            val formattedMessage = MessageFormatter.format(format, arg1, arg2).message
+            delegate.log(marker, fqcn, LocationAwareLogger.INFO_INT, formattedMessage, arrayOf(arg1, arg2), null)
+        }
+    }
+
+    override fun info(marker: Marker?, format: String?, argArray: Array<Any?>) {
+        if (!delegate.isInfoEnabled) {
+            return
+        }
+
+        withMdc {
+            val formattedMessage = MessageFormatter.arrayFormat(format, argArray).message
+            delegate.log(marker, fqcn, LocationAwareLogger.INFO_INT, formattedMessage, argArray, null)
+        }
+    }
+
+    override fun info(marker: Marker?, msg: String?, t: Throwable?) {
+        if (!delegate.isInfoEnabled) {
+            return
+        }
+
+        withMdc {
+            delegate.log(marker, fqcn, LocationAwareLogger.INFO_INT, msg, null, t)
+        }
+    }
+
+    override fun warn(msg: String?) {
+        if (!delegate.isWarnEnabled) {
+            return
+        }
+
+        withMdc {
+            delegate.log(null, fqcn, LocationAwareLogger.WARN_INT, msg, null, null)
+        }
+    }
+
+    override fun warn(format: String?, arg: Any?) {
+        if (!delegate.isWarnEnabled) {
+            return
+        }
+
+        withMdc {
+            val formattedMessage = MessageFormatter.format(format, arg).message
+            delegate.log(null, fqcn, LocationAwareLogger.WARN_INT, formattedMessage, arrayOf(arg), null)
+        }
+    }
+
+    override fun warn(format: String?, arg1: Any?, arg2: Any?) {
+        if (!delegate.isWarnEnabled) {
+            return
+        }
+
+        withMdc {
+            val formattedMessage = MessageFormatter.format(format, arg1, arg2).message
+            delegate.log(null, fqcn, LocationAwareLogger.WARN_INT, formattedMessage, arrayOf(arg1, arg2), null)
+        }
+    }
+
+    override fun warn(format: String?, argArray: Array<Any?>) {
+        if (!delegate.isWarnEnabled) {
+            return
+        }
+
+        withMdc {
+            val formattedMessage = MessageFormatter.arrayFormat(format, argArray).message
+            delegate.log(null, fqcn, LocationAwareLogger.WARN_INT, formattedMessage, argArray, null)
+        }
+    }
+
+    override fun warn(msg: String?, t: Throwable?) {
+        if (!delegate.isWarnEnabled) {
+            return
+        }
+
+        withMdc {
+            delegate.log(null, fqcn, LocationAwareLogger.WARN_INT, msg, null, t)
+        }
+    }
+
+    override fun warn(marker: Marker?, msg: String?) {
+        if (!delegate.isWarnEnabled) {
+            return
+        }
+
+        withMdc {
+            delegate.log(marker, fqcn, LocationAwareLogger.WARN_INT, msg, null, null)
+        }
+    }
+
+    override fun warn(marker: Marker?, format: String?, arg: Any?) {
+        if (!delegate.isWarnEnabled) {
+            return
+        }
+
+        withMdc {
+            val formattedMessage = MessageFormatter.format(format, arg).message
+            delegate.log(marker, fqcn, LocationAwareLogger.WARN_INT, formattedMessage, arrayOf(arg), null)
+        }
+    }
+
+    override fun warn(marker: Marker?, format: String?, arg1: Any?, arg2: Any?) {
+        if (!delegate.isWarnEnabled) {
+            return
+        }
+
+        withMdc {
+            val formattedMessage = MessageFormatter.format(format, arg1, arg2).message
+            delegate.log(marker, fqcn, LocationAwareLogger.WARN_INT, formattedMessage, arrayOf(arg1, arg2), null)
+        }
+    }
+
+    override fun warn(marker: Marker?, format: String?, argArray: Array<Any?>) {
+        if (!delegate.isWarnEnabled) {
+            return
+        }
+
+        withMdc {
+            val formattedMessage = MessageFormatter.arrayFormat(format, argArray).message
+            delegate.log(marker, fqcn, LocationAwareLogger.WARN_INT, formattedMessage, argArray, null)
+        }
+    }
+
+    override fun warn(marker: Marker?, msg: String?, t: Throwable?) {
+        if (!delegate.isWarnEnabled) {
+            return
+        }
+
+        withMdc {
+            delegate.log(marker, fqcn, LocationAwareLogger.WARN_INT, msg, null, t)
+        }
+    }
+
+    override fun error(msg: String?) {
+        if (!delegate.isErrorEnabled) {
+            return
+        }
+
+        withMdc {
+            delegate.log(null, fqcn, LocationAwareLogger.ERROR_INT, msg, null, null)
+        }
+    }
+
+    override fun error(format: String?, arg: Any?) {
+        if (!delegate.isErrorEnabled) {
+            return
+        }
+
+        withMdc {
+            val formattedMessage = MessageFormatter.format(format, arg).message
+            delegate.log(null, fqcn, LocationAwareLogger.ERROR_INT, formattedMessage, arrayOf(arg), null)
+        }
+    }
+
+    override fun error(format: String?, arg1: Any?, arg2: Any?) {
+        if (!delegate.isErrorEnabled) {
+            return
+        }
+
+        withMdc {
+            val formattedMessage = MessageFormatter.format(format, arg1, arg2).message
+            delegate.log(null, fqcn, LocationAwareLogger.ERROR_INT, formattedMessage, arrayOf(arg1, arg2), null)
+        }
+    }
+
+    override fun error(format: String?, argArray: Array<Any?>) {
+        if (!delegate.isErrorEnabled) {
+            return
+        }
+
+        withMdc {
+            val formattedMessage = MessageFormatter.arrayFormat(format, argArray).message
+            delegate.log(null, fqcn, LocationAwareLogger.ERROR_INT, formattedMessage, argArray, null)
+        }
+    }
+
+    override fun error(msg: String?, t: Throwable?) {
+        if (!delegate.isErrorEnabled) {
+            return
+        }
+
+        withMdc {
+            delegate.log(null, fqcn, LocationAwareLogger.ERROR_INT, msg, null, t)
+        }
+    }
+
+    override fun error(marker: Marker?, msg: String?) {
+        if (!delegate.isErrorEnabled) {
+            return
+        }
+
+        withMdc {
+            delegate.log(marker, fqcn, LocationAwareLogger.ERROR_INT, msg, null, null)
+        }
+    }
+
+    override fun error(marker: Marker?, format: String?, arg: Any?) {
+        if (!delegate.isErrorEnabled) {
+            return
+        }
+
+        withMdc {
+            val formattedMessage = MessageFormatter.format(format, arg).message
+            delegate.log(marker, fqcn, LocationAwareLogger.ERROR_INT, formattedMessage, arrayOf(arg), null)
+        }
+    }
+
+    override fun error(marker: Marker?, format: String?, arg1: Any?, arg2: Any?) {
+        if (!delegate.isErrorEnabled) {
+            return
+        }
+
+        withMdc {
+            val formattedMessage = MessageFormatter.format(format, arg1, arg2).message
+            delegate.log(marker, fqcn, LocationAwareLogger.ERROR_INT, formattedMessage, arrayOf(arg1, arg2), null)
+        }
+    }
+
+    override fun error(marker: Marker?, format: String?, argArray: Array<Any?>) {
+        if (!delegate.isErrorEnabled) {
+            return
+        }
+
+        withMdc {
+            val formattedMessage = MessageFormatter.arrayFormat(format, argArray).message
+            delegate.log(marker, fqcn, LocationAwareLogger.ERROR_INT, formattedMessage, argArray, null)
+        }
+    }
+
+    override fun error(marker: Marker?, msg: String?, t: Throwable?) {
+        if (!delegate.isErrorEnabled) {
+            return
+        }
+
+        withMdc {
+            delegate.log(marker, fqcn, LocationAwareLogger.ERROR_INT, msg, null, t)
+        }
+    }
+}
diff --git a/odcsim/odcsim-engine-omega/src/main/kotlin/com/atlarge/odcsim/engine/omega/logging/LocationIgnorantLoggerImpl.kt b/odcsim/odcsim-engine-omega/src/main/kotlin/com/atlarge/odcsim/engine/omega/logging/LocationIgnorantLoggerImpl.kt
new file mode 100644
index 00000000..b77e85e7
--- /dev/null
+++ b/odcsim/odcsim-engine-omega/src/main/kotlin/com/atlarge/odcsim/engine/omega/logging/LocationIgnorantLoggerImpl.kt
@@ -0,0 +1,440 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2019 atlarge-research
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.atlarge.odcsim.engine.omega.logging
+
+import com.atlarge.odcsim.ProcessContext
+import org.slf4j.Logger
+import org.slf4j.Marker
+
+/**
+ * A [Logger] implementation that is not aware of the calling location.
+ *
+ * @param ctx The owning [ProcessContext] of this logger.
+ * @param delegate The [Logger] to delegate the messages to.
+ */
+internal class LocationIgnorantLoggerImpl(
+    ctx: ProcessContext,
+    private val delegate: Logger
+) : LoggerImpl(ctx), Logger by delegate {
+    override fun warn(marker: Marker?, format: String?, arg1: Any?, arg2: Any?) {
+        if (!isWarnEnabled) {
+            return
+        }
+
+        withMdc { delegate.warn(marker, format, arg1, arg2) }
+    }
+
+    override fun warn(format: String?, arg1: Any?, arg2: Any?) {
+        if (!isWarnEnabled) {
+            return
+        }
+
+        withMdc { delegate.warn(format, arg1, arg2) }
+    }
+
+    override fun warn(msg: String?) {
+        if (!isWarnEnabled) {
+            return
+        }
+
+        withMdc { delegate.warn(msg) }
+    }
+
+    override fun warn(marker: Marker?, format: String?, arg: Any?) {
+        if (!isWarnEnabled) {
+            return
+        }
+
+        withMdc { delegate.warn(marker, format, arg) }
+    }
+
+    override fun warn(marker: Marker?, format: String?, vararg arguments: Any?) {
+        if (!isWarnEnabled) {
+            return
+        }
+
+        withMdc { delegate.warn(marker, format, arguments) }
+    }
+
+    override fun warn(format: String?, arg: Any?) {
+        if (!isWarnEnabled) {
+            return
+        }
+
+        withMdc { delegate.warn(format, arg) }
+    }
+
+    override fun warn(marker: Marker?, msg: String?) {
+        if (!isWarnEnabled) {
+            return
+        }
+
+        withMdc { delegate.warn(marker, msg) }
+    }
+
+    override fun warn(msg: String?, t: Throwable?) {
+        if (!isWarnEnabled) {
+            return
+        }
+
+        withMdc { delegate.warn(msg, t) }
+    }
+
+    override fun warn(format: String?, vararg arguments: Any?) {
+        if (!isWarnEnabled) {
+            return
+        }
+
+        withMdc { delegate.warn(format, *arguments) }
+    }
+
+    override fun warn(marker: Marker?, msg: String?, t: Throwable?) {
+        if (!isWarnEnabled) {
+            return
+        }
+
+        withMdc { delegate.warn(marker, msg, t) }
+    }
+
+    override fun info(marker: Marker?, format: String?, vararg arguments: Any?) {
+        if (!isInfoEnabled) {
+            return
+        }
+
+        withMdc { delegate.info(marker, format, *arguments) }
+    }
+
+    override fun info(format: String?, arg: Any?) {
+        if (!isInfoEnabled) {
+            return
+        }
+
+        withMdc { delegate.info(format, arg) }
+    }
+
+    override fun info(marker: Marker?, msg: String?, t: Throwable?) {
+        if (!isInfoEnabled) {
+            return
+        }
+
+        withMdc { delegate.info(marker, msg, t) }
+    }
+
+    override fun info(msg: String?) {
+        if (!isInfoEnabled) {
+            return
+        }
+
+        withMdc { delegate.info(msg) }
+    }
+
+    override fun info(format: String?, vararg arguments: Any?) {
+        if (!isInfoEnabled) {
+            return
+        }
+
+        withMdc { delegate.info(format, *arguments) }
+    }
+
+    override fun info(format: String?, arg1: Any?, arg2: Any?) {
+        if (!isInfoEnabled) {
+            return
+        }
+
+        withMdc { delegate.info(format, arg1, arg2) }
+    }
+
+    override fun info(marker: Marker?, msg: String?) {
+        if (!isInfoEnabled) {
+            return
+        }
+
+        withMdc { delegate.info(marker, msg) }
+    }
+
+    override fun info(marker: Marker?, format: String?, arg: Any?) {
+        if (!isInfoEnabled) {
+            return
+        }
+
+        withMdc { delegate.info(marker, format, arg) }
+    }
+
+    override fun info(marker: Marker?, format: String?, arg1: Any?, arg2: Any?) {
+        if (!isInfoEnabled) {
+            return
+        }
+
+        withMdc { delegate.info(marker, format, arg1, arg2) }
+    }
+
+    override fun info(msg: String?, t: Throwable?) {
+        if (!isInfoEnabled) {
+            return
+        }
+
+        withMdc { delegate.info(msg, t) }
+    }
+
+    override fun error(msg: String?) {
+        if (!isErrorEnabled) {
+            return
+        }
+
+        withMdc { delegate.error(msg) }
+    }
+
+    override fun error(marker: Marker?, msg: String?) {
+        if (!isErrorEnabled) {
+            return
+        }
+
+        withMdc { delegate.error(marker, msg) }
+    }
+
+    override fun error(format: String?, vararg arguments: Any?) {
+        if (!isErrorEnabled) {
+            return
+        }
+
+        withMdc { delegate.error(format, *arguments) }
+    }
+
+    override fun error(format: String?, arg: Any?) {
+        if (!isErrorEnabled) {
+            return
+        }
+
+        withMdc { delegate.error(format, arg) }
+    }
+
+    override fun error(msg: String?, t: Throwable?) {
+        if (!isErrorEnabled) {
+            return
+        }
+
+        withMdc { delegate.error(msg, t) }
+    }
+
+    override fun error(marker: Marker?, format: String?, arg1: Any?, arg2: Any?) {
+        if (!isErrorEnabled) {
+            return
+        }
+
+        withMdc { delegate.error(marker, format, arg1, arg2) }
+    }
+
+    override fun error(marker: Marker?, format: String?, vararg arguments: Any?) {
+        if (!isErrorEnabled) {
+            return
+        }
+
+        withMdc { delegate.error(marker, format, *arguments) }
+    }
+
+    override fun error(marker: Marker?, msg: String?, t: Throwable?) {
+        if (!isErrorEnabled) {
+            return
+        }
+
+        withMdc { delegate.error(marker, msg, t) }
+    }
+
+    override fun error(format: String?, arg1: Any?, arg2: Any?) {
+        if (!isErrorEnabled) {
+            return
+        }
+
+        withMdc { delegate.error(format, arg1, arg2) }
+    }
+
+    override fun error(marker: Marker?, format: String?, arg: Any?) {
+        if (!isErrorEnabled) {
+            return
+        }
+
+        withMdc { delegate.error(marker, format, arg) }
+    }
+
+    override fun debug(format: String?, vararg arguments: Any?) {
+        if (!isDebugEnabled) {
+            return
+        }
+
+        withMdc { delegate.debug(format, *arguments) }
+    }
+
+    override fun debug(format: String?, arg1: Any?, arg2: Any?) {
+        if (!isDebugEnabled) {
+            return
+        }
+
+        withMdc { delegate.debug(format, arg1, arg2) }
+    }
+
+    override fun debug(msg: String?, t: Throwable?) {
+        if (!isDebugEnabled) {
+            return
+        }
+
+        withMdc { delegate.debug(msg, t) }
+    }
+
+    override fun debug(format: String?, arg: Any?) {
+        if (!isDebugEnabled) {
+            return
+        }
+
+        withMdc { delegate.debug(format, arg) }
+    }
+
+    override fun debug(marker: Marker?, msg: String?) {
+        if (!isDebugEnabled) {
+            return
+        }
+
+        withMdc { delegate.debug(marker, msg) }
+    }
+
+    override fun debug(msg: String?) {
+        if (!isDebugEnabled) {
+            return
+        }
+
+        withMdc { delegate.debug(msg) }
+    }
+
+    override fun debug(marker: Marker?, msg: String?, t: Throwable?) {
+        if (!isDebugEnabled) {
+            return
+        }
+
+        withMdc { delegate.debug(marker, msg, t) }
+    }
+
+    override fun debug(marker: Marker?, format: String?, arg1: Any?, arg2: Any?) {
+        if (!isDebugEnabled) {
+            return
+        }
+
+        withMdc { delegate.debug(marker, format, arg1, arg2) }
+    }
+
+    override fun debug(marker: Marker?, format: String?, arg: Any?) {
+        if (!isDebugEnabled) {
+            return
+        }
+
+        withMdc { delegate.debug(marker, format, arg) }
+    }
+
+    override fun debug(marker: Marker?, format: String?, vararg arguments: Any?) {
+        if (!isDebugEnabled) {
+            return
+        }
+
+        withMdc { delegate.debug(marker, format, *arguments) }
+    }
+
+    override fun trace(format: String?, arg: Any?) {
+        if (!isTraceEnabled) {
+            return
+        }
+
+        withMdc { delegate.trace(format, arg) }
+    }
+
+    override fun trace(marker: Marker?, msg: String?) {
+        if (!isTraceEnabled) {
+            return
+        }
+
+        withMdc { delegate.trace(marker, msg) }
+    }
+
+    override fun trace(msg: String?) {
+        if (!isTraceEnabled) {
+            return
+        }
+
+        withMdc { delegate.trace(msg) }
+    }
+
+    override fun trace(msg: String?, t: Throwable?) {
+        if (!isTraceEnabled) {
+            return
+        }
+
+        withMdc { delegate.trace(msg, t) }
+    }
+
+    override fun trace(format: String?, arg1: Any?, arg2: Any?) {
+        if (!isTraceEnabled) {
+            return
+        }
+
+        withMdc { delegate.trace(format, arg1, arg2) }
+    }
+
+    override fun trace(marker: Marker?, format: String?, arg1: Any?, arg2: Any?) {
+        if (!isTraceEnabled) {
+            return
+        }
+
+        withMdc { delegate.trace(marker, format, arg1, arg2) }
+    }
+
+    override fun trace(marker: Marker?, format: String?, arg: Any?) {
+        if (!isTraceEnabled) {
+            return
+        }
+
+        withMdc { delegate.trace(marker, format, arg) }
+    }
+
+    override fun trace(marker: Marker?, format: String?, vararg argArray: Any?) {
+        if (!isTraceEnabled) {
+            return
+        }
+
+        withMdc { delegate.trace(marker, format, *argArray) }
+    }
+
+    override fun trace(marker: Marker?, msg: String?, t: Throwable?) {
+        if (!isTraceEnabled) {
+            return
+        }
+
+        withMdc { delegate.trace(marker, msg, t) }
+    }
+
+    override fun trace(format: String?, vararg arguments: Any?) {
+        if (!isTraceEnabled) {
+            return
+        }
+
+        withMdc { delegate.trace(format, *arguments) }
+    }
+}
diff --git a/odcsim/odcsim-engine-omega/src/main/kotlin/com/atlarge/odcsim/engine/omega/logging/LoggerImpl.kt b/odcsim/odcsim-engine-omega/src/main/kotlin/com/atlarge/odcsim/engine/omega/logging/LoggerImpl.kt
new file mode 100644
index 00000000..5a52473b
--- /dev/null
+++ b/odcsim/odcsim-engine-omega/src/main/kotlin/com/atlarge/odcsim/engine/omega/logging/LoggerImpl.kt
@@ -0,0 +1,74 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2019 atlarge-research
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.atlarge.odcsim.engine.omega.logging
+
+import com.atlarge.odcsim.ProcessContext
+import org.slf4j.Logger
+import org.slf4j.LoggerFactory
+import org.slf4j.MDC
+import org.slf4j.spi.LocationAwareLogger
+
+/**
+ * An actor-specific [Logger] implementation.
+ *
+ * @param ctx The owning [ProcessContext] of this logger.
+ */
+internal abstract class LoggerImpl internal constructor(protected val ctx: ProcessContext) : Logger {
+    /**
+     * Configure [MDC] with actor-specific information.
+     */
+    protected inline fun withMdc(block: () -> Unit) {
+        MDC.put(MDC_PROCESS_REF, ctx.self.name)
+        MDC.put(MDC_PROCESS_TIME, String.format("%d", ctx.clock.millis()))
+        try {
+            block()
+        } finally {
+            MDC.remove(MDC_PROCESS_TIME)
+            MDC.remove(MDC_PROCESS_REF)
+        }
+    }
+
+    /**
+     * Mapped Diagnostic Context (MDC) attribute names.
+     */
+    companion object {
+        val MDC_PROCESS_TIME = "process.time"
+        val MDC_PROCESS_REF = "process.ref"
+
+        /**
+         * Create a [Logger] for the specified [ActorContext].
+         *
+         * @param ctx The actor context to create the logger for.
+         */
+        operator fun invoke(ctx: ProcessContext): Logger {
+            val logger = LoggerFactory.getLogger(ctx.javaClass)
+            return if (logger is LocationAwareLogger) {
+                LocationAwareLoggerImpl(ctx, logger)
+            } else {
+                LocationIgnorantLoggerImpl(ctx, logger)
+            }
+        }
+    }
+}