This repository has been archived by the owner on Aug 25, 2020. It is now read-only.
-
Notifications
You must be signed in to change notification settings - Fork 7
/
OmegaSimulation.kt
436 lines (373 loc) · 14.7 KB
/
OmegaSimulation.kt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
/*
* MIT License
*
* Copyright (c) 2017 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.opendc.omega
import com.atlarge.opendc.simulator.*
import com.atlarge.opendc.simulator.instrumentation.Instrument
import com.atlarge.opendc.simulator.instrumentation.InstrumentScope
import com.atlarge.opendc.simulator.instrumentation.Port
import com.atlarge.opendc.simulator.kernel.Simulation
import kotlinx.coroutines.experimental.channels.Channel
import kotlinx.coroutines.experimental.channels.ReceiveChannel
import kotlinx.coroutines.experimental.channels.SendChannel
import mu.KotlinLogging
import java.lang.ref.WeakReference
import java.util.*
import kotlin.coroutines.experimental.*
/**
* The Omega simulation kernel is the reference simulation kernel implementation for the OpenDC Simulator core.
*
* This simulator implementation is a single-threaded implementation, running simulation kernels synchronously and
* provides a single priority queue for all events (messages, ticks, etc) that occur in the entities.
*
* @property model The model that is simulated.
* @author Fabian Mastenbroek (f.s.mastenbroek@student.tudelft.nl)
*/
internal class OmegaSimulation<M>(bootstrap: Bootstrap<M>) : Simulation<M>, Bootstrap.Context<M> {
/**
* The logger instance to use for the simulator.
*/
private val logger = KotlinLogging.logger {}
/**
* The registry of the processes used in the simulation.
*/
private val registry: MutableMap<Entity<*, *>, OmegaContext<*>> = HashMap()
/**
* The message queue.
*/
private val queue: Queue<Envelope> = PriorityQueue(Comparator
.comparingLong(Envelope::time)
.thenComparingLong(Envelope::id))
/**
* The kernel process instance that handles internal operations during the simulation.
*/
private val process = object : Process<Unit, M> {
override val initialState = Unit
override suspend fun Context<Unit, M>.run() {
while(true) {
val msg = receive()
when (msg) {
is Launch<*> ->
@Suppress("UNCHECKED_CAST")
launch((msg as Launch<M>).process)
}
}
}
}
/**
* The context associated with an [Entity].
*/
@Suppress("UNCHECKED_CAST")
private val <E : Entity<S, M>, S, M> E.context: OmegaContext<S>?
get() = registry[this] as? OmegaContext<S>
/**
* The simulation time.
*/
override var time: Instant = 0
/**
* The model of simulation.
*/
// XXX: the bootstrap requires the properties of this class to be initialised, so changing the order may cause NPEs
override var model: M = bootstrap.apply(this)
/**
* The observable state of an [Entity] in simulation, which is provided by the simulation context.
*/
override val <E : Entity<S, *>, S> E.state: S
get() = context?.state ?: initialState
/**
* Initialise the simulation instance.
*/
init {
// Launch the Omega kernel process
launch(process)
}
// Bootstrap Context implementation
override fun register(entity: Entity<*, M>): Boolean {
if (!registry.containsKey(entity) && entity !is Process) {
return false
}
schedule(Launch(entity as Process<*, M>), process)
return true
}
override fun deregister(entity: Entity<*, M>): Boolean {
val context = entity.context ?: return false
context.resume(Unit)
return true
}
override fun schedule(message: Any, destination: Entity<*, *>, sender: Entity<*, *>?, delay: Duration) =
schedule(prepare(message, destination, sender, delay))
// Simulation implementation
override fun openPort(): Port<M> = object : Port<M> {
val channels: MutableSet<WeakReference<Channel<*>>> = mutableSetOf()
override fun <T> install(capacity: Int, instrument: Instrument<T, M>): ReceiveChannel<T> {
val channel = Channel<T>(capacity)
val process = object : Process<Unit, M> {
override val initialState = Unit
override suspend fun Context<Unit, M>.run() {
val builder = object : InstrumentScope<T, M>, SendChannel<T> by channel, Context<Unit, M> by this {}
try {
instrument(builder)
channel.close()
} catch (cause: Throwable) {
channel.close(cause)
}
}
}
channels.add(WeakReference(channel))
register(process)
return channel
}
override fun close(cause: Throwable?): Boolean = channels
.map { it.get()?.close(cause) ?: false }
.any()
}
override fun step() {
while (true) {
val envelope = queue.peek() ?: return
val delivery = envelope.time
if (delivery > time) {
// Tick has yet to occur
// Jump in time to next event
time = delivery
break
} else if (delivery < time) {
// Tick has already occurred
logger.warn { "Message processed out of order" }
}
queue.poll()
// If the sender has canceled the message, we move on to the next message
if (envelope.canceled) {
continue
}
val context = envelope.destination.context ?: continue
if (envelope.message !is Interrupt) {
context.continuation.resume(envelope)
} else {
context.continuation.resumeWithException(envelope.message)
}
context.last = time
}
}
override fun run() {
while (queue.isNotEmpty()) {
step()
}
}
override fun run(until: Instant) {
require(until > 0) { "The given instant must be a non-zero positive number" }
if (time >= until) {
return
}
while (time < until && queue.isNotEmpty()) {
step()
}
// Fix clock if step() jumped too far in time to give the impression to the user that simulation stopped at
// exactly the tick it gave. This has not effect on the actual simulation results as the next call to run() will
// just jump forward again.
if (time > until) {
time = until
}
}
/**
* The identifier for the next message to be scheduled.
*/
private var nextId: Long = 0
/**
* A wrapper around a message that has been scheduled for processing.
*
* @property id The identifier of the message to keep the priority queue stable
* @property message The message to wrap.
* @property time The point in time to deliver the message.
* @property sender The sender of the message.
* @property destination The destination of the message.
*/
private data class Envelope(val id: Long,
val message: Any,
val time: Instant,
val sender: Entity<*, *>?,
val destination: Entity<*, *>) {
/**
* A flag to indicate the message has been canceled.
*/
internal var canceled: Boolean = false
}
/**
* Schedule the given envelope to be processed by the kernel.
*
* @param envelope The envelope containing the message to schedule.
*/
private fun schedule(envelope: Envelope) {
queue.add(envelope)
}
/**
* Prepare a message for scheduling by wrapping it into an envelope.
*
* @param message The message to send.
* @param destination The destination entity that should receive the message.
* @param sender The optional sender of the message.
* @param delay The time to delay the message.
*/
private fun prepare(message: Any, destination: Entity<*, *>, sender: Entity<*, *>? = null,
delay: Duration): Envelope {
require(delay >= 0) { "The amount of time to delay the message must be a positive number" }
return Envelope(nextId++, message, time + delay, sender, destination)
}
/**
* Launch the given [Process].
*
* @param process The process to launch.
*/
private fun launch(process: Process<*, M>) {
val context = OmegaContext(process).also { registry[process] = it }
// Bootstrap the process coroutine
val block: suspend () -> Unit = { context.start() }
block.startCoroutine(context)
}
/**
* This internal class provides the default implementation for the [Context] interface for this simulator.
*/
private inner class OmegaContext<S>(val process: Process<S, M>) : Context<S, M>, Continuation<Unit>,
AbstractCoroutineContextElement(Context) {
/**
* The model in which the process exists.
*/
override val model: M
get() = this@OmegaSimulation.model
/**
* The current point in simulation time.
*/
override val time: Instant
get() = this@OmegaSimulation.time
/**
* The [Entity] associated with this context.
*/
override val self: Entity<S, M>
get() = process
/**
* The duration between the current point in simulation time and the last point in simulation time where the
* [Context] has executed some work.
*/
override val delta: Duration
get() = maxOf(time - last, 0)
/**
* The state of the entity.
*/
override var state: S = process.initialState
/**
* The observable state of an [Entity] within the simulation is provided by the context of the simulation.
*/
override val <T : Entity<S, *>, S> T.state: S
get() = context?.state ?: initialState
/**
* The sender of the last received message or `null` in case the process has not received any messages yet.
*/
override var sender: Entity<*, *>? = null
/**
* The [CoroutineContext] for a [Context].
*/
override val context: CoroutineContext = this
/**
* The continuation to resume the execution of the process.
*/
lateinit var continuation: Continuation<Envelope>
/**
* The last point in time the process has done some work.
*/
var last: Instant = -1
override suspend fun receive(): Any = receiveEnvelope().message
override suspend fun receive(timeout: Duration): Any? {
val send = prepare(Timeout, process, process, timeout).also { schedule(it) }
try {
val received = receiveEnvelope()
if (received.message != Timeout) {
send.canceled = true
return received.message
}
return null
} finally {
send.canceled = true
}
}
override suspend fun Entity<*, *>.send(msg: Any, sender: Entity<*, *>, delay: Duration) =
schedule(prepare(msg, this, sender, delay))
override suspend fun Entity<*, *>.interrupt(interrupt: Interrupt) = send(interrupt)
override suspend fun hold(duration: Duration) {
require(duration >= 0) { "The amount of time to hold must be a positive number" }
val envelope = prepare(Resume, process, process, duration).also { schedule(it) }
try {
while (true) {
if (receive() == Resume)
return
}
} finally {
envelope.canceled = true
}
}
override suspend fun hold(duration: Duration, queue: Queue<Any>) {
require(duration >= 0) { "The amount of time to hold must be a positive number" }
val envelope = prepare(Resume, process, process, duration).also { schedule(it) }
try {
while (true) {
val msg = receive()
if (msg == Resume)
return
queue.add(msg)
}
} finally {
envelope.canceled = true
}
}
/**
* Start the process associated with this context.
*/
internal suspend fun start() = process.run { run() }
/**
* Retrieve and remove and single message from the mailbox of the [Entity] and suspend the [Context] until the
* message has been received.
*
* @return The envelope containing the message.
*/
suspend fun receiveEnvelope() = suspendCoroutine<Envelope> { continuation = it }
.also { sender = it.sender }
// Completion continuation implementation
/**
* Resume the execution of this continuation with the given value.
*
* @param value The value to resume with.
*/
override fun resume(value: Unit) {
// Deregister process from registry in order to have the GC collect this context
registry.remove(process)
}
/**
* Resume the execution of this continuation with an exception.
*
* @param exception The exception to resume with.
*/
override fun resumeWithException(exception: Throwable) {
// Deregister process from registry in order to have the GC collect this context:w
registry.remove(process)
logger.error(exception) { "An exception occurred during the execution of a process" }
}
}
}