From 3363df4c72a064e590ca98f8e01832cfa4e15a3f Mon Sep 17 00:00:00 2001 From: Dante Niewenhuis Date: Tue, 27 Aug 2024 13:48:46 +0200 Subject: Renamed input files and internally server is changed to task (#246) * 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 --- .../kotlin/org/opendc/compute/simulator/SimHost.kt | 66 +++++++++++----------- .../compute/simulator/SimMetaWorkloadMapper.kt | 8 +-- .../opendc/compute/simulator/SimWorkloadMapper.kt | 8 +-- .../simulator/internal/DefaultWorkloadMapper.kt | 6 +- .../org/opendc/compute/simulator/internal/Guest.kt | 62 ++++++++++---------- .../org/opendc/compute/simulator/SimHostTest.kt | 42 +++++++------- 6 files changed, 96 insertions(+), 96 deletions(-) (limited to 'opendc-compute/opendc-compute-simulator') diff --git a/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimHost.kt b/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimHost.kt index 624a612f..ac0a8043 100644 --- a/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimHost.kt +++ b/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimHost.kt @@ -23,8 +23,8 @@ package org.opendc.compute.simulator import org.opendc.compute.api.Flavor -import org.opendc.compute.api.Server -import org.opendc.compute.api.ServerState +import org.opendc.compute.api.Task +import org.opendc.compute.api.TaskState import org.opendc.compute.service.driver.Host import org.opendc.compute.service.driver.HostListener import org.opendc.compute.service.driver.HostModel @@ -60,7 +60,7 @@ import java.util.function.Supplier * @param clock The (virtual) clock used to track time. * @param machine The [SimBareMetalMachine] on which the host runs. * @param hypervisor The [SimHypervisor] to run on top of the machine. - * @param mapper A [SimWorkloadMapper] to map a [Server] to a [SimWorkload]. + * @param mapper A [SimWorkloadMapper] to map a [Task] to a [SimWorkload]. * @param bootModel A [Supplier] providing the [SimWorkload] to execute during the boot procedure of the hypervisor. * @param optimize A flag to indicate to optimize the machine models of the virtual machines. */ @@ -83,7 +83,7 @@ public class SimHost( /** * The virtual machines running on the hypervisor. */ - private val guests = HashMap() + private val guests = HashMap() private val localGuests = mutableListOf() private var localState: HostState = HostState.DOWN @@ -108,11 +108,11 @@ public class SimHost( private val guestListener = object : GuestListener { override fun onStart(guest: Guest) { - listeners.forEach { it.onStateChanged(this@SimHost, guest.server, guest.state) } + listeners.forEach { it.onStateChanged(this@SimHost, guest.task, guest.state) } } override fun onStop(guest: Guest) { - listeners.forEach { it.onStateChanged(this@SimHost, guest.server, guest.state) } + listeners.forEach { it.onStateChanged(this@SimHost, guest.task, guest.state) } } } @@ -140,21 +140,21 @@ public class SimHost( return localState } - override fun getInstances(): Set { + override fun getInstances(): Set { return guests.keys } - override fun canFit(server: Server): Boolean { - val sufficientMemory = model.memoryCapacity >= server.flavor.memorySize - val enoughCpus = model.coreCount >= server.flavor.coreCount - val canFit = hypervisor.canFit(server.flavor.toMachineModel()) + override fun canFit(task: Task): Boolean { + val sufficientMemory = model.memoryCapacity >= task.flavor.memorySize + val enoughCpus = model.coreCount >= task.flavor.coreCount + val canFit = hypervisor.canFit(task.flavor.toMachineModel()) return sufficientMemory && enoughCpus && canFit } - override fun spawn(server: Server) { - guests.computeIfAbsent(server) { key -> - require(canFit(key)) { "Server does not fit" } + override fun spawn(task: Task) { + guests.computeIfAbsent(task) { key -> + require(canFit(key)) { "Task does not fit" } val machine = hypervisor.newMachine(key.flavor.toMachineModel()) val newGuest = @@ -164,7 +164,7 @@ public class SimHost( hypervisor, mapper, guestListener, - server, + task, machine, ) @@ -173,25 +173,25 @@ public class SimHost( } } - override fun contains(server: Server): Boolean { - return server in guests + override fun contains(task: Task): Boolean { + return task in guests } - override fun start(server: Server) { - val guest = requireNotNull(guests[server]) { "Unknown server ${server.uid} at host $uid" } + override fun start(task: Task) { + val guest = requireNotNull(guests[task]) { "Unknown task ${task.uid} at host $uid" } guest.start() } - override fun stop(server: Server) { - val guest = requireNotNull(guests[server]) { "Unknown server ${server.uid} at host $uid" } + override fun stop(task: Task) { + val guest = requireNotNull(guests[task]) { "Unknown task ${task.uid} at host $uid" } guest.stop() } - override fun delete(server: Server) { - val guest = guests[server] ?: return + override fun delete(task: Task) { + val guest = guests[task] ?: return guest.delete() - guests.remove(server) + guests.remove(task) localGuests.remove(guest) } @@ -219,12 +219,12 @@ public class SimHost( val guests = localGuests.listIterator() for (guest in guests) { when (guest.state) { - ServerState.TERMINATED -> terminated++ - ServerState.RUNNING -> running++ - ServerState.ERROR -> error++ - ServerState.DELETED -> { + TaskState.TERMINATED -> terminated++ + TaskState.RUNNING -> running++ + TaskState.ERROR -> error++ + TaskState.DELETED -> { // Remove guests that have been deleted - this.guests.remove(guest.server) + this.guests.remove(guest.task) guests.remove() } else -> invalid++ @@ -244,8 +244,8 @@ public class SimHost( ) } - override fun getSystemStats(server: Server): GuestSystemStats { - val guest = requireNotNull(guests[server]) { "Unknown server ${server.uid} at host $uid" } + override fun getSystemStats(task: Task): GuestSystemStats { + val guest = requireNotNull(guests[task]) { "Unknown task ${task.uid} at host $uid" } return guest.getSystemStats() } @@ -265,8 +265,8 @@ public class SimHost( ) } - override fun getCpuStats(server: Server): GuestCpuStats { - val guest = requireNotNull(guests[server]) { "Unknown server ${server.uid} at host $uid" } + override fun getCpuStats(task: Task): GuestCpuStats { + val guest = requireNotNull(guests[task]) { "Unknown task ${task.uid} at host $uid" } return guest.getCpuStats() } diff --git a/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimMetaWorkloadMapper.kt b/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimMetaWorkloadMapper.kt index c05f1a2c..907f6acd 100644 --- a/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimMetaWorkloadMapper.kt +++ b/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimMetaWorkloadMapper.kt @@ -22,14 +22,14 @@ package org.opendc.compute.simulator -import org.opendc.compute.api.Server +import org.opendc.compute.api.Task import org.opendc.simulator.compute.workload.SimWorkload /** - * A [SimWorkloadMapper] that maps a [Server] to a workload via the meta-data. + * A [SimWorkloadMapper] that maps a [Task] to a workload via the meta-data. */ public class SimMetaWorkloadMapper(private val key: String = "workload") : SimWorkloadMapper { - override fun createWorkload(server: Server): SimWorkload { - return requireNotNull(server.meta[key] ?: server.image.meta[key]) as SimWorkload + override fun createWorkload(task: Task): SimWorkload { + return requireNotNull(task.meta[key] ?: task.image.meta[key]) as SimWorkload } } diff --git a/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimWorkloadMapper.kt b/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimWorkloadMapper.kt index 83baa61a..a85091a0 100644 --- a/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimWorkloadMapper.kt +++ b/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimWorkloadMapper.kt @@ -23,15 +23,15 @@ package org.opendc.compute.simulator import org.opendc.compute.api.Image -import org.opendc.compute.api.Server +import org.opendc.compute.api.Task import org.opendc.simulator.compute.workload.SimWorkload /** - * A [SimWorkloadMapper] is responsible for mapping a [Server] and [Image] to a [SimWorkload] that can be simulated. + * A [SimWorkloadMapper] is responsible for mapping a [Task] and [Image] to a [SimWorkload] that can be simulated. */ public fun interface SimWorkloadMapper { /** - * Map the specified [server] to a [SimWorkload] that can be simulated. + * Map the specified [task] to a [SimWorkload] that can be simulated. */ - public fun createWorkload(server: Server): SimWorkload + public fun createWorkload(task: Task): SimWorkload } diff --git a/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/internal/DefaultWorkloadMapper.kt b/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/internal/DefaultWorkloadMapper.kt index 7d4b7302..24c382dd 100644 --- a/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/internal/DefaultWorkloadMapper.kt +++ b/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/internal/DefaultWorkloadMapper.kt @@ -22,7 +22,7 @@ package org.opendc.compute.simulator.internal -import org.opendc.compute.api.Server +import org.opendc.compute.api.Task import org.opendc.compute.simulator.SimMetaWorkloadMapper import org.opendc.compute.simulator.SimWorkloadMapper import org.opendc.simulator.compute.workload.SimWorkload @@ -36,8 +36,8 @@ import java.time.Duration internal object DefaultWorkloadMapper : SimWorkloadMapper { private val delegate = SimMetaWorkloadMapper() - override fun createWorkload(server: Server): SimWorkload { - val workload = delegate.createWorkload(server) + override fun createWorkload(task: Task): SimWorkload { + val workload = delegate.createWorkload(task) // FIXME: look at connecting this to frontend. Probably not needed since the duration is so small val bootWorkload = SimWorkloads.runtime(Duration.ofMillis(1), 0.8, 0L, 0L) return SimWorkloads.chain(bootWorkload, workload) diff --git a/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/internal/Guest.kt b/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/internal/Guest.kt index cbdda0cb..1925233f 100644 --- a/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/internal/Guest.kt +++ b/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/internal/Guest.kt @@ -23,8 +23,8 @@ package org.opendc.compute.simulator.internal import mu.KotlinLogging -import org.opendc.compute.api.Server -import org.opendc.compute.api.ServerState +import org.opendc.compute.api.Task +import org.opendc.compute.api.TaskState import org.opendc.compute.service.driver.telemetry.GuestCpuStats import org.opendc.compute.service.driver.telemetry.GuestSystemStats import org.opendc.compute.simulator.SimHost @@ -46,16 +46,16 @@ internal class Guest( private val hypervisor: SimHypervisor, private val mapper: SimWorkloadMapper, private val listener: GuestListener, - val server: Server, + val task: Task, val machine: SimVirtualMachine, ) { /** * The state of the [Guest]. * - * [ServerState.PROVISIONING] is an invalid value for a guest, since it applies before the host is selected for - * a server. + * [TaskState.PROVISIONING] is an invalid value for a guest, since it applies before the host is selected for + * a task. */ - var state: ServerState = ServerState.TERMINATED + var state: TaskState = TaskState.TERMINATED private set /** @@ -63,14 +63,14 @@ internal class Guest( */ fun start() { when (state) { - ServerState.TERMINATED, ServerState.ERROR -> { - LOGGER.info { "User requested to start server ${server.uid}" } + TaskState.TERMINATED, TaskState.ERROR -> { + LOGGER.info { "User requested to start task ${task.uid}" } doStart() } - ServerState.RUNNING -> return - ServerState.DELETED -> { - LOGGER.warn { "User tried to start deleted server" } - throw IllegalArgumentException("Server is deleted") + TaskState.RUNNING -> return + TaskState.DELETED -> { + LOGGER.warn { "User tried to start deleted task" } + throw IllegalArgumentException("Task is deleted") } else -> assert(false) { "Invalid state transition" } } @@ -81,9 +81,9 @@ internal class Guest( */ fun stop() { when (state) { - ServerState.RUNNING -> doStop(ServerState.TERMINATED) - ServerState.ERROR -> doRecover() - ServerState.TERMINATED, ServerState.DELETED -> return + TaskState.RUNNING -> doStop(TaskState.TERMINATED) + TaskState.ERROR -> doRecover() + TaskState.TERMINATED, TaskState.DELETED -> return else -> assert(false) { "Invalid state transition" } } } @@ -97,28 +97,28 @@ internal class Guest( fun delete() { stop() - state = ServerState.DELETED + state = TaskState.DELETED hypervisor.removeMachine(machine) } /** * Fail the guest if it is active. * - * This operation forcibly stops the guest and puts the server into an error state. + * This operation forcibly stops the guest and puts the task into an error state. */ fun fail() { - if (state != ServerState.RUNNING) { + if (state != TaskState.RUNNING) { return } - doStop(ServerState.ERROR) + doStop(TaskState.ERROR) } /** * Recover the guest if it is in an error state. */ fun recover() { - if (state != ServerState.ERROR) { + if (state != TaskState.ERROR) { return } @@ -170,23 +170,23 @@ internal class Guest( onStart() - val workload: SimWorkload = mapper.createWorkload(server) + val workload: SimWorkload = mapper.createWorkload(task) workload.setOffset(clock.millis()) - val meta = mapOf("driver" to host, "server" to server) + server.meta + val meta = mapOf("driver" to host, "task" to task) + task.meta ctx = machine.startWorkload(workload, meta) { cause -> - onStop(if (cause != null) ServerState.ERROR else ServerState.TERMINATED) + onStop(if (cause != null) TaskState.ERROR else TaskState.TERMINATED) ctx = null } } /** - * Attempt to stop the server and put it into [target] state. + * Attempt to stop the task and put it into [target] state. */ - private fun doStop(target: ServerState) { + private fun doStop(target: TaskState) { assert(ctx != null) { "Invalid job state" } val ctx = ctx ?: return - if (target == ServerState.ERROR) { + if (target == TaskState.ERROR) { ctx.shutdown(Exception("Stopped because of ERROR")) } else { ctx.shutdown() @@ -199,7 +199,7 @@ internal class Guest( * Attempt to recover from an error state. */ private fun doRecover() { - state = ServerState.TERMINATED + state = TaskState.TERMINATED } /** @@ -207,14 +207,14 @@ internal class Guest( */ private fun onStart() { localBootTime = clock.instant() - state = ServerState.RUNNING + state = TaskState.RUNNING listener.onStart(this) } /** * This method is invoked when the guest stopped. */ - private fun onStop(target: ServerState) { + private fun onStop(target: TaskState) { updateUptime() state = target @@ -235,9 +235,9 @@ internal class Guest( val duration = now - localLastReport localLastReport = now - if (state == ServerState.RUNNING) { + if (state == TaskState.RUNNING) { localUptime += duration - } else if (state == ServerState.ERROR) { + } else if (state == TaskState.ERROR) { localDowntime += duration } } diff --git a/opendc-compute/opendc-compute-simulator/src/test/kotlin/org/opendc/compute/simulator/SimHostTest.kt b/opendc-compute/opendc-compute-simulator/src/test/kotlin/org/opendc/compute/simulator/SimHostTest.kt index 8c2ffd0c..ec3bf225 100644 --- a/opendc-compute/opendc-compute-simulator/src/test/kotlin/org/opendc/compute/simulator/SimHostTest.kt +++ b/opendc-compute/opendc-compute-simulator/src/test/kotlin/org/opendc/compute/simulator/SimHostTest.kt @@ -31,9 +31,9 @@ import org.junit.jupiter.api.Test import org.junit.jupiter.api.assertAll import org.opendc.compute.api.Flavor import org.opendc.compute.api.Image -import org.opendc.compute.api.Server -import org.opendc.compute.api.ServerState -import org.opendc.compute.api.ServerWatcher +import org.opendc.compute.api.Task +import org.opendc.compute.api.TaskState +import org.opendc.compute.api.TaskWatcher import org.opendc.compute.service.driver.Host import org.opendc.compute.service.driver.HostListener import org.opendc.simulator.compute.SimBareMetalMachine @@ -119,16 +119,16 @@ internal class SimHostTest { override fun onStateChanged( host: Host, - server: Server, - newState: ServerState, + task: Task, + newState: TaskState, ) { - if (newState == ServerState.TERMINATED && ++finished == 1) { + if (newState == TaskState.TERMINATED && ++finished == 1) { cont.resume(Unit) } } }, ) - val server = MockServer(UUID.randomUUID(), "a", flavor, vmImage) + val server = MockTask(UUID.randomUUID(), "a", flavor, vmImage) host.spawn(server) host.start(server) } @@ -211,18 +211,18 @@ internal class SimHostTest { override fun onStateChanged( host: Host, - server: Server, - newState: ServerState, + task: Task, + newState: TaskState, ) { - if (newState == ServerState.TERMINATED && ++finished == 2) { + if (newState == TaskState.TERMINATED && ++finished == 2) { cont.resume(Unit) } } }, ) - val serverA = MockServer(UUID.randomUUID(), "a", flavor, vmImageA) + val serverA = MockTask(UUID.randomUUID(), "a", flavor, vmImageA) host.spawn(serverA) - val serverB = MockServer(UUID.randomUUID(), "b", flavor, vmImageB) + val serverB = MockTask(UUID.randomUUID(), "b", flavor, vmImageB) host.spawn(serverB) host.start(serverA) @@ -282,7 +282,7 @@ internal class SimHostTest { ), ) val flavor = MockFlavor(2, 0) - val server = MockServer(UUID.randomUUID(), "a", flavor, image) + val server = MockTask(UUID.randomUUID(), "a", flavor, image) coroutineScope { host.spawn(server) @@ -297,10 +297,10 @@ internal class SimHostTest { object : HostListener { override fun onStateChanged( host: Host, - server: Server, - newState: ServerState, + task: Task, + newState: TaskState, ) { - if (newState == ServerState.TERMINATED) { + if (newState == TaskState.TERMINATED) { cont.resume(Unit) } } @@ -360,17 +360,17 @@ internal class SimHostTest { } } - private class MockServer( + private class MockTask( override val uid: UUID, override val name: String, override val flavor: Flavor, override val image: Image, - ) : Server { + ) : Task { override val labels: Map = emptyMap() override val meta: Map = emptyMap() - override val state: ServerState = ServerState.TERMINATED + override val state: TaskState = TaskState.TERMINATED override val launchedAt: Instant? = null @@ -380,9 +380,9 @@ internal class SimHostTest { override fun delete() {} - override fun watch(watcher: ServerWatcher) {} + override fun watch(watcher: TaskWatcher) {} - override fun unwatch(watcher: ServerWatcher) {} + override fun unwatch(watcher: TaskWatcher) {} override fun reload() {} } -- cgit v1.2.3