feat: add support for processable synthetic components

Author: metacosm

measure/src/main/java/net/laprun/sustainability/power/analysis/DefaultProcessors.java

@@ -23,14 +23,22 @@ public void recordMeasure(double[] components, long timestamp) {
         }
 
         for (var index = 0; index < components.length; index++) {
-            final var fIndex = index;
-            final var componentProcessors = processors[index];
-            if (componentProcessors != null) {
-                componentProcessors.forEach(proc -> proc.recordComponentValue(components[fIndex], timestamp));
-            }
+            recordComponentValue(components[index], timestamp, index);
+        }
+    }
+
+    private void recordComponentValue(double value, long timestamp, int componentIndex) {
+        final var componentProcessors = processors[componentIndex];
+        if (componentProcessors != null) {
+            componentProcessors.forEach(proc -> proc.recordComponentValue(value, timestamp));
         }
     }
 
+    @Override
+    public void recordSyntheticComponentValue(double syntheticValue, long timestamp, int componentIndex) {
+        recordComponentValue(syntheticValue, componentIndex, componentIndex);
+    }
+
     @Override
     public void registerProcessorFor(int componentIndex, ComponentProcessor processor) {
         if (processor != null) {

measure/src/main/java/net/laprun/sustainability/power/analysis/Processors.java

@@ -29,4 +29,7 @@ default List<MeasureProcessor> measureProcessors() {
     default String output(SensorMetadata metadata) {
         return "";
     }
+
+    default void recordSyntheticComponentValue(double syntheticValue, long timestamp, int componentIndex) {
+    }
 }

measure/src/main/java/net/laprun/sustainability/power/analysis/RegisteredSyntheticComponent.java

@@ -0,0 +1,27 @@
+package net.laprun.sustainability.power.analysis;
+
+import net.laprun.sustainability.power.SensorMetadata;
+
+public class RegisteredSyntheticComponent implements SyntheticComponent {
+    private final SyntheticComponent syntheticComponent;
+    private final int computedIndex;
+
+    public RegisteredSyntheticComponent(SyntheticComponent syntheticComponent, int computedIndex) {
+        this.syntheticComponent = syntheticComponent;
+        this.computedIndex = computedIndex;
+    }
+
+    @Override
+    public SensorMetadata.ComponentMetadata metadata() {
+        return syntheticComponent.metadata();
+    }
+
+    @Override
+    public double synthesizeFrom(double[] components, long timestamp) {
+        return syntheticComponent.synthesizeFrom(components, timestamp);
+    }
+
+    public int computedIndex() {
+        return computedIndex;
+    }
+}

measure/src/main/java/net/laprun/sustainability/power/analysis/SyntheticComponent.java

@@ -0,0 +1,10 @@
+package net.laprun.sustainability.power.analysis;
+
+import net.laprun.sustainability.power.SensorMetadata;
+
+public interface SyntheticComponent {
+
+    SensorMetadata.ComponentMetadata metadata();
+
+    double synthesizeFrom(double[] components, long timestamp);
+}

measure/src/main/java/net/laprun/sustainability/power/measure/OngoingPowerMeasure.java

@@ -1,35 +1,51 @@
 package net.laprun.sustainability.power.measure;
 
 import java.time.Duration;
+import java.util.Arrays;
 import java.util.BitSet;
+import java.util.List;
 import java.util.Optional;
 import java.util.stream.DoubleStream;
 import java.util.stream.IntStream;
 import java.util.stream.Stream;
 
 import net.laprun.sustainability.power.SensorMetadata;
 import net.laprun.sustainability.power.analysis.Processors;
+import net.laprun.sustainability.power.analysis.RegisteredSyntheticComponent;
+import net.laprun.sustainability.power.analysis.SyntheticComponent;
 
 public class OngoingPowerMeasure extends ProcessorAware implements PowerMeasure {
     private static final int DEFAULT_SIZE = 32;
     private final SensorMetadata metadata;
     private final long startedAt;
     private final BitSet nonZeroComponents;
     private final double[][] measures;
+    private final List<RegisteredSyntheticComponent> syntheticComponents;
     private int samples;
     private long[] timestamps;
 
-    public OngoingPowerMeasure(SensorMetadata metadata) {
+    public OngoingPowerMeasure(SensorMetadata metadata, SyntheticComponent... syntheticComponents) {
         super(Processors.empty);
 
         startedAt = System.currentTimeMillis();
-        this.metadata = metadata;
-
         final var numComponents = metadata.componentCardinality();
         measures = new double[numComponents][DEFAULT_SIZE];
-        timestamps = new long[DEFAULT_SIZE];
-        // we don't need to record the total component as a non-zero component since it's almost never zero and we compute the std dev separately
         nonZeroComponents = new BitSet(numComponents);
+        timestamps = new long[DEFAULT_SIZE];
+
+        if (syntheticComponents != null) {
+            final var builder = SensorMetadata.from(metadata);
+            for (var component : syntheticComponents) {
+                builder.withNewComponent(component.metadata());
+            }
+            this.metadata = builder.build();
+            this.syntheticComponents = Arrays.stream(syntheticComponents)
+                    .map(sc -> new RegisteredSyntheticComponent(sc, this.metadata.metadataFor(sc.metadata().name()).index()))
+                    .toList();
+        } else {
+            this.syntheticComponents = List.of();
+            this.metadata = metadata;
+        }
     }
 
     @Override
@@ -54,7 +70,14 @@ public void recordMeasure(double[] components) {
             recordComponentValue(component, componentValue, timestamp);
         }
 
-        processors().recordMeasure(components, timestamp);
+        final var processors = processors();
+        processors.recordMeasure(components, timestamp);
+
+        if (!syntheticComponents.isEmpty()) {
+            syntheticComponents.forEach(sc -> processors.recordSyntheticComponentValue(sc.synthesizeFrom(components, timestamp),
+                    timestamp, sc.computedIndex()));
+
+        }
     }
 
     private void recordComponentValue(int component, double value, long timestamp) {

measure/src/test/java/net/laprun/sustainability/power/measure/OngoingPowerMeasureTest.java

@@ -10,8 +10,10 @@
 import org.junit.jupiter.api.Test;
 
 import net.laprun.sustainability.power.SensorMetadata;
+import net.laprun.sustainability.power.SensorUnit;
 import net.laprun.sustainability.power.analysis.ComponentProcessor;
 import net.laprun.sustainability.power.analysis.MeasureProcessor;
+import net.laprun.sustainability.power.analysis.SyntheticComponent;
 
 public class OngoingPowerMeasureTest {
     private final static SensorMetadata metadata = SensorMetadata
@@ -97,6 +99,42 @@ void processorsShouldBeCalled() {
         assertThat(measureProc.values.getLast().measures()).isEqualTo(new double[] { m2c1, m2c2, 0 });
     }
 
+    @Test
+    void syntheticComponentsShouldWork() {
+        final var random = Random.from(RandomGenerator.getDefault());
+        final var m1c1 = random.nextDouble();
+        final var m2c1 = random.nextDouble();
+
+        final var doublerName = "doubler";
+        final var doubler = new SyntheticComponent() {
+            @Override
+            public SensorMetadata.ComponentMetadata metadata() {
+                return new SensorMetadata.ComponentMetadata(doublerName, "doubler desc", true, SensorUnit.mW);
+            }
+
+            @Override
+            public double synthesizeFrom(double[] components, long timestamp) {
+                return components[0] * 2;
+            }
+        };
+
+        final var measure = new OngoingPowerMeasure(metadata, doubler);
+        final var testProc = new TestComponentProcessor();
+        // need to get updated metadata
+        final var doublerIndex = measure.metadata().metadataFor(doublerName).index();
+        measure.registerProcessorFor(doublerIndex, testProc);
+
+        final var components = new double[metadata.componentCardinality()];
+        components[0] = m1c1;
+        measure.recordMeasure(components);
+
+        components[0] = m2c1;
+        measure.recordMeasure(components);
+
+        assertThat(testProc.values.getFirst().value()).isEqualTo(m1c1 * 2);
+        assertThat(testProc.values.getLast().value()).isEqualTo(m2c1 * 2);
+    }
+
     private static class TestComponentProcessor implements ComponentProcessor {
         final List<PowerMeasure.TimestampedValue> values = new ArrayList<>();
 

metadata/src/main/java/net/laprun/sustainability/power/SensorMetadata.java

@@ -202,6 +202,15 @@ public Builder withDocumentation(String documentation) {
         public SensorMetadata build() {
             return new SensorMetadata(components, documentation);
         }
+
+        public Builder withNewComponent(ComponentMetadata metadata) {
+            if (-1 == metadata.index) {
+                metadata = new SensorMetadata.ComponentMetadata(metadata.name, currentIndex++, metadata.description,
+                        metadata.isAttributed, metadata.unit);
+            }
+            components.add(metadata);
+            return this;
+        }
     }
 
     /**
@@ -229,6 +238,14 @@ public record ComponentMetadata(String name, int index, String description, bool
             }
         }
 
+        /**
+         * Creates a ComponentMetadata that will be automatically assigned an index whenever added to a {@link SensorMetadata},
+         * based on the contextual order of how other components have been added.
+         */
+        public ComponentMetadata(String name, String description, boolean isAttributed, SensorUnit unit) {
+            this(name, -1, description, isAttributed, unit);
+        }
+
         @JsonCreator(mode = JsonCreator.Mode.PROPERTIES)
         public ComponentMetadata(@JsonProperty("name") String name, @JsonProperty("index") int index,
                 @JsonProperty("description") String description,