multi gpu support (#351)

11 files changed, 140 insertions, 183 deletions

diff --git a/opendc-compute/opendc-compute-simulator/src/main/java/org/opendc/compute/simulator/telemetry/HostGpuStats.java b/opendc-compute/opendc-compute-simulator/src/main/java/org/opendc/compute/simulator/telemetry/HostGpuStats.java
index e42d7704..e7790975 100644
--- a/opendc-compute/opendc-compute-simulator/src/main/java/org/opendc/compute/simulator/telemetry/HostGpuStats.java
+++ b/opendc-compute/opendc-compute-simulator/src/main/java/org/opendc/compute/simulator/telemetry/HostGpuStats.java
@@ -43,4 +43,5 @@ public record HostGpuStats(
         double capacity,
         double demand,
         double usage,
-        double utilization) {}
+        double utilization,
+        double powerDraw) {}
diff --git a/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/host/SimHost.kt b/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/host/SimHost.kt
index effe3d5b..b7d3b730 100644
--- a/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/host/SimHost.kt
+++ b/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/host/SimHost.kt
@@ -361,6 +361,7 @@ public class SimHost(
         for (gpu in simMachine!!.gpus) {
             gpu.updateCounters(this.clock.millis())
             val counters = simMachine!!.getGpuPerformanceCounters(gpu.id)
+            val powerDraw = simMachine!!.psu.getPowerDraw(ResourceType.GPU, gpu.id)
 
             gpuStats.add(
                 HostGpuStats(
@@ -372,13 +373,14 @@ public class SimHost(
                     counters.demand,
                     counters.supply,
                     counters.supply / gpu.getCapacity(ResourceType.GPU),
+                    powerDraw,
                 ),
             )
         }
         return gpuStats
     }
 
-    public fun getGpuStats(task: ServiceTask): List<GuestGpuStats> {
+    public fun getGpuStats(task: ServiceTask): GuestGpuStats? {
         val guest = requireNotNull(taskToGuestMap[task]) { "Unknown task ${task.name} at host $name" }
         return guest.getGpuStats()
     }
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 a980f6cb..40de94bb 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
@@ -258,27 +258,24 @@ public class Guest(
         )
     }
 
-    public fun getGpuStats(): List<GuestGpuStats> {
+    public fun getGpuStats(): GuestGpuStats? {
         virtualMachine!!.updateCounters(this.clock.millis())
         val counters = virtualMachine!!.gpuPerformanceCounters
 
-        val gpuStats = mutableListOf<GuestGpuStats>()
-        for (gpuCounter in counters) {
-            gpuStats.add(
-                GuestGpuStats(
-                    gpuCounter.activeTime / 1000L,
-                    gpuCounter.idleTime / 1000L,
-                    gpuCounter.stealTime / 1000L,
-                    gpuCounter.lostTime / 1000L,
-                    gpuCounter.capacity,
-                    gpuCounter.supply,
-                    gpuCounter.demand,
-                    // Assuming similar scaling as CPU
-                    gpuCounter.supply / gpuLimit,
-                ),
+        return if (counters == null) {
+            null
+        } else {
+            GuestGpuStats(
+                counters.activeTime / 1000L,
+                counters.idleTime / 1000L,
+                counters.stealTime / 1000L,
+                counters.lostTime / 1000L,
+                counters.capacity,
+                counters.supply,
+                counters.demand,
+                counters.supply / gpuLimit,
             )
         }
-        return gpuStats
     }
 
     /**
diff --git a/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/telemetry/parquet/ComputeExportConfig.kt b/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/telemetry/parquet/ComputeExportConfig.kt
index c7549433..43b9b449 100644
--- a/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/telemetry/parquet/ComputeExportConfig.kt
+++ b/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/telemetry/parquet/ComputeExportConfig.kt
@@ -217,6 +217,11 @@ public data class ComputeExportConfig(
     }
 }
 
+public fun ComputeExportConfig.withGpuColumns(count: Int): ComputeExportConfig {
+    val hostCols = hostExportColumns + DfltHostExportColumns.gpuColumns(count)
+    return copy(hostExportColumns = hostCols)
+}
+
 private val json = Json { ignoreUnknownKeys = true }
 
 private inline fun <reified T : Exportable> JsonElement?.toFieldList(): List<ExportColumn<T>> =
diff --git a/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/telemetry/parquet/DfltHostExportColumns.kt b/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/telemetry/parquet/DfltHostExportColumns.kt
index affaab58..7a091379 100644
--- a/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/telemetry/parquet/DfltHostExportColumns.kt
+++ b/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/telemetry/parquet/DfltHostExportColumns.kt
@@ -144,48 +144,6 @@ public object DfltHostExportColumns {
             field = Types.required(INT64).named("cpu_time_lost"),
         ) { it.cpuLostTime }
 
-    // TODO: support multiple GPUs
-
-    public val GPU_CAPACITY: ExportColumn<HostTableReader> =
-        ExportColumn(
-            field = Types.optional(FLOAT).named("gpu_capacity"),
-        ) { it.gpuCapacities.getOrNull(0) }
-
-    public val GPU_USAGE: ExportColumn<HostTableReader> =
-        ExportColumn(
-            field = Types.optional(FLOAT).named("gpu_usage"),
-        ) { it.gpuUsages.getOrNull(0) }
-
-    public val GPU_DEMAND: ExportColumn<HostTableReader> =
-        ExportColumn(
-            field = Types.optional(FLOAT).named("gpu_demand"),
-        ) { it.gpuDemands.getOrNull(0) }
-
-    public val GPU_UTILIZATION: ExportColumn<HostTableReader> =
-        ExportColumn(
-            field = Types.optional(FLOAT).named("gpu_utilization"),
-        ) { it.gpuUtilizations.getOrNull(0) }
-
-    public val GPU_TIME_ACTIVE: ExportColumn<HostTableReader> =
-        ExportColumn(
-            field = Types.optional(INT64).named("gpu_time_active"),
-        ) { it.gpuActiveTimes.getOrNull(0) }
-
-    public val GPU_TIME_IDLE: ExportColumn<HostTableReader> =
-        ExportColumn(
-            field = Types.optional(INT64).named("gpu_time_idle"),
-        ) { it.gpuIdleTimes.getOrNull(0) }
-
-    public val GPU_TIME_STEAL: ExportColumn<HostTableReader> =
-        ExportColumn(
-            field = Types.optional(INT64).named("gpu_time_steal"),
-        ) { it.gpuStealTimes.getOrNull(0) }
-
-    public val GPU_TIME_LOST: ExportColumn<HostTableReader> =
-        ExportColumn(
-            field = Types.optional(INT64).named("gpu_time_lost"),
-        ) { it.gpuLostTimes.getOrNull(0) }
-
     public val POWER_DRAW: ExportColumn<HostTableReader> =
         ExportColumn(
             field = Types.required(FLOAT).named("power_draw"),
@@ -217,6 +175,42 @@ public object DfltHostExportColumns {
         ) { it.bootTime?.toEpochMilli() }
 
     /**
+     * Returns GPU-related export columns for the given number of GPUs.
+     */
+    public fun gpuColumns(count: Int): Set<ExportColumn<HostTableReader>> =
+        (0 until count).flatMap { i ->
+            listOf<ExportColumn<HostTableReader>>(
+                ExportColumn(
+                    field = Types.optional(FLOAT).named("gpu_capacity_$i"),
+                ) { it.gpuCapacities.getOrNull(i) },
+                ExportColumn(
+                    field = Types.optional(FLOAT).named("gpu_usage_$i"),
+                ) { it.gpuUsages.getOrNull(i) },
+                ExportColumn(
+                    field = Types.optional(FLOAT).named("gpu_demand_$i"),
+                ) { it.gpuDemands.getOrNull(i) },
+                ExportColumn(
+                    field = Types.optional(FLOAT).named("gpu_utilization_$i"),
+                ) { it.gpuUtilizations.getOrNull(i) },
+                ExportColumn(
+                    field = Types.optional(INT64).named("gpu_time_active_$i"),
+                ) { it.gpuActiveTimes.getOrNull(i) },
+                ExportColumn(
+                    field = Types.optional(INT64).named("gpu_time_idle_$i"),
+                ) { it.gpuIdleTimes.getOrNull(i) },
+                ExportColumn(
+                    field = Types.optional(INT64).named("gpu_time_steal_$i"),
+                ) { it.gpuStealTimes.getOrNull(i) },
+                ExportColumn(
+                    field = Types.optional(INT64).named("gpu_time_lost_$i"),
+                ) { it.gpuLostTimes.getOrNull(i) },
+                ExportColumn(
+                    field = Types.optional(FLOAT).named("gpu_power_draw_$i"),
+                ) { it.gpuPowerDraws.getOrNull(i) },
+            )
+        }.toSet()
+
+    /**
      * The columns that are always included in the output file.
      */
     internal val BASE_EXPORT_COLUMNS =
diff --git a/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/telemetry/parquet/DfltTaskExportColumns.kt b/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/telemetry/parquet/DfltTaskExportColumns.kt
index ad7a1d52..07750114 100644
--- a/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/telemetry/parquet/DfltTaskExportColumns.kt
+++ b/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/telemetry/parquet/DfltTaskExportColumns.kt
@@ -132,42 +132,45 @@ public object DfltTaskExportColumns {
             field = Types.required(INT64).named("cpu_time_lost"),
         ) { it.cpuLostTime }
 
-    // TODO: support multiple GPUs
+    public val GPU_COUNT: ExportColumn<TaskTableReader> =
+        ExportColumn(
+            field = Types.optional(INT32).named("gpu_count"),
+        ) { it.taskInfo.gpuCount }
 
-    public val GPU_CAPACITY: ExportColumn<TaskTableReader> =
+    public val GPU_LIMIT: ExportColumn<TaskTableReader> =
         ExportColumn(
-            field = Types.optional(FLOAT).named("gpu_capacity"),
-        ) { it.gpuLimits?.getOrNull(0) }
+            field = Types.optional(FLOAT).named("gpu_limit"),
+        ) { it.gpuLimit }
 
     public val GPU_USAGE: ExportColumn<TaskTableReader> =
         ExportColumn(
             field = Types.optional(FLOAT).named("gpu_usage"),
-        ) { it.gpuUsages?.getOrNull(0) }
+        ) { it.gpuUsage }
 
     public val GPU_DEMAND: ExportColumn<TaskTableReader> =
         ExportColumn(
             field = Types.optional(FLOAT).named("gpu_demand"),
-        ) { it.gpuDemands?.getOrNull(0) }
+        ) { it.gpuDemand }
 
     public val GPU_TIME_ACTIVE: ExportColumn<TaskTableReader> =
         ExportColumn(
             field = Types.optional(INT64).named("gpu_time_active"),
-        ) { it.gpuActiveTimes?.getOrNull(0) }
+        ) { it.gpuActiveTime }
 
     public val GPU_TIME_IDLE: ExportColumn<TaskTableReader> =
         ExportColumn(
             field = Types.optional(INT64).named("gpu_time_idle"),
-        ) { it.gpuIdleTimes?.getOrNull(0) }
+        ) { it.gpuIdleTime }
 
     public val GPU_TIME_STEAL: ExportColumn<TaskTableReader> =
         ExportColumn(
             field = Types.optional(INT64).named("gpu_time_steal"),
-        ) { it.gpuStealTimes?.getOrNull(0) }
+        ) { it.gpuStealTime }
 
     public val GPU_TIME_LOST: ExportColumn<TaskTableReader> =
         ExportColumn(
             field = Types.optional(INT64).named("gpu_time_lost"),
-        ) { it.gpuLostTimes?.getOrNull(0) }
+        ) { it.gpuLostTime }
 
     public val UP_TIME: ExportColumn<TaskTableReader> =
         ExportColumn(
diff --git a/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/telemetry/table/host/HostTableReader.kt b/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/telemetry/table/host/HostTableReader.kt
index fbffd508..f904ac9e 100644
--- a/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/telemetry/table/host/HostTableReader.kt
+++ b/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/telemetry/table/host/HostTableReader.kt
@@ -113,16 +113,11 @@ public interface HostTableReader : Exportable {
     public val cpuLostTime: Long
 
     /**
-     * The capacity of the CPUs in the host (in MHz).
+     * The capacity of the GPUs in the host (in MHz).They inserted by GPU ID.
      */
     public val gpuCapacities: ArrayList<Double>
 
     /**
-     * The capacity of the GPUs in the host (in MHz). They inserted by GPU ID.
-     */
-    public val gpuLimits: ArrayList<Double>
-
-    /**
      * The usage per GPU in the host (in MHz). They inserted by GPU ID
      */
     public val gpuUsages: ArrayList<Double>
@@ -158,6 +153,11 @@ public interface HostTableReader : Exportable {
     public val gpuLostTimes: ArrayList<Long>
 
     /**
+     * The power draw of the respective GPU in the host (in W). They inserted by GPU ID.
+     */
+    public val gpuPowerDraws: ArrayList<Double>
+
+    /**
      * The current power draw of the host in W.
      */
     public val powerDraw: Double
diff --git a/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/telemetry/table/host/HostTableReaderImpl.kt b/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/telemetry/table/host/HostTableReaderImpl.kt
index cb25358a..e46edc88 100644
--- a/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/telemetry/table/host/HostTableReaderImpl.kt
+++ b/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/telemetry/table/host/HostTableReaderImpl.kt
@@ -60,7 +60,6 @@ public class HostTableReaderImpl(
         _cpuLostTime = table.cpuLostTime
         // GPU stats
         _gpuCapacities = table.gpuCapacities
-        _gpuLimits = table.gpuLimits
         _gpuDemands = table.gpuDemands
         _gpuUsages = table.gpuUsages
         _gpuUtilizations = table.gpuUtilizations
@@ -68,6 +67,7 @@ public class HostTableReaderImpl(
         _gpuIdleTimes = table.gpuIdleTimes
         _gpuStealTimes = table.gpuStealTimes
         _gpuLostTimes = table.gpuLostTimes
+        _gpuPowerDraws = table.gpuPowerDraws
 
         // energy & carbon stats
         _powerDraw = table.powerDraw
@@ -152,10 +152,6 @@ public class HostTableReaderImpl(
         get() = _gpuCapacities
     private var _gpuCapacities: ArrayList<Double> = ArrayList()
 
-    override val gpuLimits: ArrayList<Double>
-        get() = _gpuLimits
-    private var _gpuLimits: ArrayList<Double> = ArrayList()
-
     override val gpuUsages: ArrayList<Double>
         get() = _gpuUsages
     private var _gpuUsages: ArrayList<Double> = ArrayList()
@@ -170,7 +166,6 @@ public class HostTableReaderImpl(
 
     // half of the CPU stats
     override val gpuActiveTimes: ArrayList<Long>
-//        get() = _gpuActiveTimes.zip(previousGpuActiveTimes) { current, previous -> current - previous} as ArrayList<Long>
         get() =
             (0 until _gpuActiveTimes.size).map {
                     i ->
@@ -180,7 +175,6 @@ public class HostTableReaderImpl(
     private var previousGpuActiveTimes: ArrayList<Long> = ArrayList()
 
     override val gpuIdleTimes: ArrayList<Long>
-//        get() = _gpuIdleTimes.zip(previousGpuIdleTimes) { current, previous -> current - previous} as ArrayList<Long>
         get() =
             (0 until _gpuIdleTimes.size).map {
                     i ->
@@ -207,6 +201,10 @@ public class HostTableReaderImpl(
     private var _gpuLostTimes: ArrayList<Long> = ArrayList()
     private var previousGpuLostTimes: ArrayList<Long> = ArrayList()
 
+    override val gpuPowerDraws: ArrayList<Double>
+        get() = _gpuPowerDraws
+    private var _gpuPowerDraws: ArrayList<Double> = ArrayList()
+
     override val powerDraw: Double
         get() = _powerDraw
     private var _powerDraw = 0.0
@@ -258,7 +256,7 @@ public class HostTableReaderImpl(
         _cpuStealTime = hostCpuStats.stealTime
         _cpuLostTime = hostCpuStats.lostTime
         // GPU stats
-        _gpuLimits = hostGpuStats.map { it.capacity } as ArrayList<Double>
+        _gpuCapacities = hostGpuStats.map { it.capacity } as ArrayList<Double>
         _gpuDemands = hostGpuStats.map { it.demand } as ArrayList<Double>
         _gpuUsages = hostGpuStats.map { it.usage } as ArrayList<Double>
         _gpuUtilizations = hostGpuStats.map { it.utilization } as ArrayList<Double>
@@ -266,6 +264,7 @@ public class HostTableReaderImpl(
         _gpuIdleTimes = hostGpuStats.map { it.idleTime } as ArrayList<Long>
         _gpuStealTimes = hostGpuStats.map { it.stealTime } as ArrayList<Long>
         _gpuLostTimes = hostGpuStats.map { it.lostTime } as ArrayList<Long>
+        _gpuPowerDraws = hostGpuStats.map { it.powerDraw } as ArrayList<Double>
         // energy & carbon stats
         _powerDraw = hostSysStats.powerDraw
         _energyUsage = hostSysStats.energyUsage
diff --git a/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/telemetry/table/task/TaskInfo.kt b/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/telemetry/table/task/TaskInfo.kt
index e0b28379..c1a14613 100644
--- a/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/telemetry/table/task/TaskInfo.kt
+++ b/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/telemetry/table/task/TaskInfo.kt
@@ -32,4 +32,5 @@ public data class TaskInfo(
     val arch: String,
     val cpuCount: Int,
     val memCapacity: Long,
+    val gpuCount: Int,
 )
diff --git a/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/telemetry/table/task/TaskTableReader.kt b/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/telemetry/table/task/TaskTableReader.kt
index f71587c7..e3860606 100644
--- a/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/telemetry/table/task/TaskTableReader.kt
+++ b/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/telemetry/table/task/TaskTableReader.kt
@@ -133,37 +133,37 @@ public interface TaskTableReader : Exportable {
     /**
      * The capacity of the GPUs of Host on which the task is running (in MHz).
      */
-    public val gpuLimits: DoubleArray?
+    public val gpuLimit: Double?
 
     /**
      * The amount of GPus allocated to the task (in MHz).
      */
-    public val gpuUsages: DoubleArray?
+    public val gpuUsage: Double?
 
     /**
      * The GPU demanded by this task (in MHz).
      */
-    public val gpuDemands: DoubleArray?
+    public val gpuDemand: Double?
 
     /**
      * The duration (in seconds) that a GPU was active in the task.
      */
-    public val gpuActiveTimes: LongArray?
+    public val gpuActiveTime: Long?
 
     /**
      * The duration (in seconds) that a GPU was idle in the task.
      */
-    public val gpuIdleTimes: LongArray?
+    public val gpuIdleTime: Long?
 
     /**
      * The duration (in seconds) that a vGPU wanted to run, but no capacity was available.
      */
-    public val gpuStealTimes: LongArray?
+    public val gpuStealTime: Long?
 
     /**
      * The duration (in seconds) of GPU time that was lost due to interference.
      */
-    public val gpuLostTimes: LongArray?
+    public val gpuLostTime: Long?
 
     /**
      * The state of the task
diff --git a/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/telemetry/table/task/TaskTableReaderImpl.kt b/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/telemetry/table/task/TaskTableReaderImpl.kt
index 6128c9a2..ce62fdb0 100644
--- a/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/telemetry/table/task/TaskTableReaderImpl.kt
+++ b/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/telemetry/table/task/TaskTableReaderImpl.kt
@@ -64,13 +64,13 @@ public class TaskTableReaderImpl(
         _cpuStealTime = table.cpuStealTime
         _cpuLostTime = table.cpuLostTime
         // GPU stats
-        _gpuLimits = table.gpuLimits
-        _gpuDemands = table.gpuDemands
-        _gpuUsages = table.gpuUsages
-        _gpuActiveTimes = table.gpuActiveTimes
-        _gpuIdleTimes = table.gpuIdleTimes
-        _gpuStealTimes = table.gpuStealTimes
-        _gpuLostTimes = table.gpuLostTimes
+        _gpuLimit = table.gpuLimit
+        _gpuDemand = table.gpuDemand
+        _gpuUsage = table.gpuUsage
+        _gpuActiveTime = table.gpuActiveTime
+        _gpuIdleTime = table.gpuIdleTime
+        _gpuStealTime = table.gpuStealTime
+        _gpuLostTime = table.gpuLostTime
 
         _uptime = table.uptime
         _downtime = table.downtime
@@ -95,6 +95,7 @@ public class TaskTableReaderImpl(
             "x86",
             task.flavor.cpuCoreCount,
             task.flavor.memorySize,
+            task.flavor.gpuCoreCount,
         )
 
     /**
@@ -177,73 +178,37 @@ public class TaskTableReaderImpl(
     private var _cpuLostTime = 0L
     private var previousCpuLostTime = 0L
 
-    override val gpuLimits: DoubleArray?
-        get() = _gpuLimits ?: DoubleArray(0)
-    private var _gpuLimits: DoubleArray? = null
+    override val gpuLimit: Double?
+        get() = _gpuLimit
+    private var _gpuLimit: Double? = 0.0
 
-    override val gpuUsages: DoubleArray?
-        get() = _gpuUsages ?: DoubleArray(0)
-    private var _gpuUsages: DoubleArray? = null
+    override val gpuUsage: Double?
+        get() = _gpuUsage
+    private var _gpuUsage: Double? = 0.0
 
-    override val gpuDemands: DoubleArray?
-        get() = _gpuDemands ?: DoubleArray(0)
-    private var _gpuDemands: DoubleArray? = null
+    override val gpuDemand: Double?
+        get() = _gpuDemand
+    private var _gpuDemand: Double? = 0.0
 
-    override val gpuActiveTimes: LongArray?
-        get() {
-            val current = _gpuActiveTimes ?: return LongArray(0)
-            val previous = previousGpuActiveTimes
+    override val gpuActiveTime: Long?
+        get() = (_gpuActiveTime ?: 0L) - (previousGpuActiveTime ?: 0L)
+    private var _gpuActiveTime: Long? = null
+    private var previousGpuActiveTime: Long? = null
 
-            return if (previous == null || current.size != previous.size) { // not sure if I like the second clause
-                current
-            } else {
-                LongArray(current.size) { i -> current[i] - previous[i] }
-            }
-        }
-    private var _gpuActiveTimes: LongArray? = null
-    private var previousGpuActiveTimes: LongArray? = null
-
-    override val gpuIdleTimes: LongArray?
-        get() {
-            val current = _gpuIdleTimes ?: return LongArray(0)
-            val previous = previousGpuIdleTimes
-
-            return if (previous == null || current.size != previous.size) { // not sure if I like the second clause
-                current
-            } else {
-                LongArray(current.size) { i -> current[i] - previous[i] }
-            }
-        }
-    private var _gpuIdleTimes: LongArray? = null
-    private var previousGpuIdleTimes: LongArray? = null
-
-    override val gpuStealTimes: LongArray?
-        get() {
-            val current = _gpuStealTimes ?: return LongArray(0)
-            val previous = previousGpuStealTimes
-
-            return if (previous == null || current.size != previous.size) {
-                current
-            } else {
-                LongArray(current.size) { i -> current[i] - previous[i] }
-            }
-        }
-    private var _gpuStealTimes: LongArray? = null
-    private var previousGpuStealTimes: LongArray? = null
-
-    override val gpuLostTimes: LongArray?
-        get() {
-            val current = _gpuLostTimes ?: return LongArray(0)
-            val previous = previousGpuLostTimes
-
-            return if (previous == null || current.size != previous.size) {
-                current
-            } else {
-                LongArray(current.size) { i -> current[i] - previous[i] }
-            }
-        }
-    private var _gpuLostTimes: LongArray? = null
-    private var previousGpuLostTimes: LongArray? = null
+    override val gpuIdleTime: Long?
+        get() = (_gpuIdleTime ?: 0L) - (previousGpuIdleTime ?: 0L)
+    private var _gpuIdleTime: Long? = null
+    private var previousGpuIdleTime: Long? = null
+
+    override val gpuStealTime: Long?
+        get() = (_gpuStealTime ?: 0L) - (previousGpuStealTime ?: 0L)
+    private var _gpuStealTime: Long? = null
+    private var previousGpuStealTime: Long? = null
+
+    override val gpuLostTime: Long?
+        get() = (_gpuLostTime ?: 0L) - (previousGpuLostTime ?: 0L)
+    private var _gpuLostTime: Long? = null
+    private var previousGpuLostTime: Long? = null
 
     override val taskState: TaskState?
         get() = _taskState
@@ -292,24 +257,14 @@ public class TaskTableReaderImpl(
         _scheduleTime = task.scheduledAt
         _finishTime = task.finishedAt
 
-        if (gpuStats != null && gpuStats.isNotEmpty()) {
-            val size = gpuStats.size
-            _gpuLimits = DoubleArray(size) { i -> gpuStats[i].capacity }
-            _gpuDemands = DoubleArray(size) { i -> gpuStats[i].demand }
-            _gpuUsages = DoubleArray(size) { i -> gpuStats[i].usage }
-            _gpuActiveTimes = LongArray(size) { i -> gpuStats[i].activeTime }
-            _gpuIdleTimes = LongArray(size) { i -> gpuStats[i].idleTime }
-            _gpuStealTimes = LongArray(size) { i -> gpuStats[i].stealTime }
-            _gpuLostTimes = LongArray(size) { i -> gpuStats[i].lostTime }
-        } else {
-            _gpuIdleTimes = null
-            _gpuStealTimes = null
-            _gpuLostTimes = null
-            _gpuIdleTimes = null
-            _gpuLimits = null
-            _gpuUsages = null
-            _gpuDemands = null
-            _gpuActiveTimes = null
+        if (gpuStats != null) {
+            _gpuLimit = gpuStats.capacity
+            _gpuDemand = gpuStats.demand
+            _gpuUsage = gpuStats.usage
+            _gpuActiveTime = gpuStats.activeTime
+            _gpuIdleTime = gpuStats.idleTime
+            _gpuStealTime = gpuStats.stealTime
+            _gpuLostTime = gpuStats.lostTime
         }
 
         _taskState = task.state
@@ -325,10 +280,10 @@ public class TaskTableReaderImpl(
         previousCpuIdleTime = _cpuIdleTime
         previousCpuStealTime = _cpuStealTime
         previousCpuLostTime = _cpuLostTime
-        previousGpuActiveTimes = _gpuActiveTimes
-        previousGpuIdleTimes = _gpuIdleTimes
-        previousGpuStealTimes = _gpuStealTimes
-        previousGpuLostTimes = _gpuLostTimes
+        previousGpuActiveTime = _gpuActiveTime
+        previousGpuIdleTime = _gpuIdleTime
+        previousGpuStealTime = _gpuStealTime
+        previousGpuLostTime = _gpuLostTime
 
         simHost = null
         _cpuLimit = 0.0