Change tests according to new gradient behavior

Author: s-h-a-d-o-w

server/fan-control/index.test.ts

@@ -1,12 +1,13 @@
 // TODO: upgrade packages so that eslint recognizes vitest globals out of the box
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { getCall, setCall } from "../native/index.js";
+import { getCall, setCall } from "../native";
 import { state } from "../state/index.js";
 import {
   fanControl,
   fanPercentToSpeed,
   CYCLE_DURATION,
   WAIT_RAMP_UP_CYCLES,
+  WAIT_RAMP_DOWN_CYCLES,
 } from "./index.js";
 
 vi.mock("../native", () => ({
@@ -32,21 +33,29 @@ function mockTemperatures(cpu: number, gpu: number) {
 }
 
 async function waitUntilFanPercent(fanPercent: number) {
-  let elapsed = 0;
-  const interval = CYCLE_DURATION;
-  const timeout = interval * 20;
-
-  mockedSetCall.mockClear();
-  while (
-    elapsed < timeout &&
-    mockedSetCall.mock.calls[0]?.[2].Data !== fanPercentToSpeed(fanPercent)
-  ) {
-    await vi.advanceTimersByTimeAsync(interval);
-    elapsed += interval;
-  }
+  let advancedTime = 0;
+
+  while (true) {
+    try {
+      expect(mockedSetCall).toHaveBeenLastCalledWith(
+        expect.any(String),
+        expect.any(String),
+        {
+          Data: fanPercentToSpeed(fanPercent),
+        },
+      );
+      return advancedTime / CYCLE_DURATION;
+    } catch (_) {
+      // console.log(
+      //   `Last call: ${
+      //     mockedSetCall.mock.calls[mockedSetCall.mock.calls.length - 1][2]
+      //       .Data
+      //   } (Expected: ${fanPercentToSpeed(fanPercent)})`,
+      // );
+    }
 
-  if (elapsed >= timeout) {
-    throw new Error("Timeout - function never returned true.");
+    await vi.advanceTimersByTimeAsync(10);
+    advancedTime += 10;
   }
 }
 
@@ -126,20 +135,47 @@ describe("fan-control", () => {
       ]
     `);
 
-    // High CPU temperature
+    // High CPU temperature => 50% fan speed
     mockTemperatures(90, 30);
-    await waitUntilFanPercent(
-      state.cpuFanTable[state.cpuFanTable.length - 1][1],
+    await vi.advanceTimersByTimeAsync(
+      3 * WAIT_RAMP_UP_CYCLES * CYCLE_DURATION + 1000,
+    );
+    expect(mockedSetCall).toHaveBeenLastCalledWith(
+      expect.any(String),
+      expect.any(String),
+      {
+        Data: fanPercentToSpeed(
+          state.cpuFanTable[state.cpuFanTable.length - 1][1],
+        ),
+      },
     );
 
-    // Cool CPU
+    // Cool CPU => 15% fan speed
     mockTemperatures(30, 30);
-    await waitUntilFanPercent(state.cpuFanTable[0][1]);
+    await vi.advanceTimersByTimeAsync(
+      3 * WAIT_RAMP_DOWN_CYCLES * CYCLE_DURATION + 1000,
+    );
+    expect(mockedSetCall).toHaveBeenLastCalledWith(
+      expect.any(String),
+      expect.any(String),
+      {
+        Data: fanPercentToSpeed(state.cpuFanTable[0][1]),
+      },
+    );
 
-    // High GPU temperature
+    // High GPU temperature => 100% fan speed
     mockTemperatures(30, 90);
-    await waitUntilFanPercent(
-      state.gpuFanTable[state.gpuFanTable.length - 1][1],
+    await vi.advanceTimersByTimeAsync(
+      5 * WAIT_RAMP_UP_CYCLES * CYCLE_DURATION + 1000,
+    );
+    expect(mockedSetCall).toHaveBeenLastCalledWith(
+      expect.any(String),
+      expect.any(String),
+      {
+        Data: fanPercentToSpeed(
+          state.gpuFanTable[state.gpuFanTable.length - 1][1],
+        ),
+      },
     );
   });
 
@@ -149,26 +185,51 @@ describe("fan-control", () => {
     state.doFixedSpeed = true;
     state.fixedPercentage = 75;
 
-    await waitUntilFanPercent(state.fixedPercentage);
+    await vi.advanceTimersByTimeAsync(CYCLE_DURATION);
+    expect(mockedSetCall).toHaveBeenLastCalledWith(
+      expect.any(String),
+      expect.any(String),
+      {
+        Data: fanPercentToSpeed(state.fixedPercentage),
+      },
+    );
   });
 
-  it("fan speed adjusts after X cycles", async () => {
+  it("fan speed adjusts gradually after temperature change", async () => {
+    // We can't just repeatedly advance the timer in this test because execution times aren't perfect and when allowing for a bit of leeway, we would cut into the time for the next gradient step.
+
     fanControl();
-    // Make sure steady state is reached
-    await vi.advanceTimersByTimeAsync(CYCLE_DURATION * 10);
+    // Make sure steady state is reached at initial temperature
+    await waitUntilFanPercent(state.cpuFanTable[0][1]);
 
+    // Change to high CPU temperature
     mockTemperatures(90, 30);
     vi.clearAllMocks();
-    // Cycle 1: Likely mix of temperatures
-    // Cycle 2: Temp has become stable => target will be changed
-    // Cycles 3+: WAIT_RAMP_UP_CYCLES until target will actually be applied
-    await vi.advanceTimersByTimeAsync(
-      CYCLE_DURATION * (WAIT_RAMP_UP_CYCLES + 2),
-    );
 
-    expect(mockedSetCall.mock.calls[0][2].Data).toEqual(
-      fanPercentToSpeed(state.cpuFanTable[state.cpuFanTable.length - 1][1]),
-    );
+    const initialPercentage = state.cpuFanTable[0][1];
+    const targetPercentage = state.cpuFanTable[state.cpuFanTable.length - 1][1];
+
+    // First gradient step
+    let currentPercentage = initialPercentage;
+    let expectedPercentage =
+      currentPercentage +
+      Math.round((targetPercentage - currentPercentage) / 2);
+    let cycles = await waitUntilFanPercent(expectedPercentage);
+    expect(cycles - WAIT_RAMP_UP_CYCLES).toBeLessThan(1);
+
+    // Second gradient step
+    currentPercentage = expectedPercentage;
+    expectedPercentage =
+      currentPercentage +
+      Math.round((targetPercentage - currentPercentage) / 2);
+    cycles = await waitUntilFanPercent(expectedPercentage);
+    expect(cycles - WAIT_RAMP_UP_CYCLES).toBeLessThan(1);
+
+    // Reaching target
+    currentPercentage = expectedPercentage;
+    expectedPercentage = targetPercentage;
+    cycles = await waitUntilFanPercent(expectedPercentage);
+    expect(cycles - WAIT_RAMP_UP_CYCLES).toBeLessThan(1);
   });
 
   it("should handle fan table changes", async () => {

server/fan-control/index.ts

@@ -3,11 +3,11 @@ import {
   FanTable,
   FanControlActivity,
 } from "../../common/types.js";
-import { getCall, setCall } from "../native/index.js";
+import { getCall, setCall } from "../native";
 import { state } from "../state/index.js";
 
-const WAIT_RAMP_DOWN_CYCLES = 10;
-export const WAIT_RAMP_UP_CYCLES = 2;
+export const WAIT_RAMP_DOWN_CYCLES = 10;
+export const WAIT_RAMP_UP_CYCLES = 3;
 export const CYCLE_DURATION = 1000;
 const TEMP_POLL_INTERVAL = 200;
 
@@ -82,26 +82,30 @@ export function fanControl() {
     return highestMatch;
   }
 
-  function getGradientTarget(lastAppliedSpeed: number, targetSpeed: number) {
-    let gradientTarget = targetSpeed;
-    if (targetSpeed > lastAppliedSpeed) {
+  function getGradientTarget(
+    lastAppliedPercentage: number,
+    targetPercentage: number,
+  ) {
+    let gradientTarget = targetPercentage;
+
+    if (targetPercentage > lastAppliedPercentage) {
       gradientTarget =
-        lastAppliedSpeed + Math.round((targetSpeed - lastAppliedSpeed) / 2);
-    } else if (targetSpeed < lastAppliedSpeed) {
+        lastAppliedPercentage +
+        Math.round((targetPercentage - lastAppliedPercentage) / 2);
+    } else if (targetPercentage < lastAppliedPercentage) {
       gradientTarget =
-        lastAppliedSpeed - Math.round((lastAppliedSpeed - targetSpeed) / 2);
-    }
-
-    if (Math.abs(targetSpeed - gradientTarget) < 5) {
-      gradientTarget = targetSpeed;
+        lastAppliedPercentage -
+        Math.round((lastAppliedPercentage - targetPercentage) / 2);
     }
 
-    return gradientTarget;
+    return Math.abs(targetPercentage - gradientTarget) < 5
+      ? targetPercentage
+      : gradientTarget;
   }
 
-  let appliedSpeed = -1;
-  let currRampDownCycle = 0;
-  let currRampUpCycle = 0;
+  let appliedPercentage = -1;
+  let currRampDownCycle = 1;
+  let currRampUpCycle = 1;
   let prevCPUFanTable = state.cpuFanTable;
   let prevGPUFanTable = state.gpuFanTable;
   const autoFanInterval = setInterval(async () => {
@@ -126,7 +130,7 @@ export function fanControl() {
         const currGPUTemp2 = await getCallInt("0xe3", "getGpuTemp2");
         const currGPUTemp = Math.max(currGPUTemp1, currGPUTemp2);
         // console.log(
-        //   `CPU and GPU1/GPU2 temperatures: ${currCPUTemp} ${currGPUTemp1}/${currGPUTemp2}`
+        //   `CPU and GPU1/GPU2 temperatures: ${currCPUTemp} ${currGPUTemp1}/${currGPUTemp2}`,
         // );
 
         CPUTemps.push(currCPUTemp);
@@ -163,44 +167,51 @@ export function fanControl() {
     ) {
       // When tables change, do nothing in this cycle but reset fans to the
       // lowest percentage currently in state.
-      appliedSpeed = resetFanSpeed();
+      appliedPercentage = resetFanSpeed();
       prevCPUFanTable = state.cpuFanTable;
       prevGPUFanTable = state.gpuFanTable;
-      currRampDownCycle = 0;
-      currRampUpCycle = 0;
-    } else if (appliedSpeed < target) {
+      currRampDownCycle = 1;
+      currRampUpCycle = 1;
+    } else if (appliedPercentage < target) {
       if (currRampUpCycle === WAIT_RAMP_UP_CYCLES) {
-        gradientTarget = getGradientTarget(appliedSpeed, target);
+        gradientTarget = getGradientTarget(
+          appliedPercentage === -1
+            ? state.cpuFanTable[0][1]
+            : appliedPercentage,
+          target,
+        );
+        // console.log(`Ramping up to ${fanPercentToSpeed(gradientTarget)}`);
         setFixedFan(gradientTarget);
 
-        currRampDownCycle = 0;
-        currRampUpCycle = 0;
-        appliedSpeed = gradientTarget;
+        currRampDownCycle = 1;
+        currRampUpCycle = 1;
+        appliedPercentage = gradientTarget;
       } else {
         currRampUpCycle++;
       }
-    } else if (target < appliedSpeed) {
+    } else if (target < appliedPercentage) {
       // Make fan behavior less erratic by waiting a few cycles until we
       // ramp down.
       if (currRampDownCycle === WAIT_RAMP_DOWN_CYCLES) {
-        gradientTarget = getGradientTarget(appliedSpeed, target);
+        gradientTarget = getGradientTarget(appliedPercentage, target);
+        // console.log(`Ramping down to ${fanPercentToSpeed(gradientTarget)}`);
         setFixedFan(gradientTarget);
 
-        currRampDownCycle = 0;
-        currRampUpCycle = 0;
-        appliedSpeed = gradientTarget;
+        currRampDownCycle = 1;
+        currRampUpCycle = 1;
+        appliedPercentage = gradientTarget;
       } else {
         currRampDownCycle++;
       }
     } else {
       // Need to reset if e.g. ramp down phase is
       // interrupted by CPU getting hot again or getting cold again.
-      currRampDownCycle = 0;
-      currRampUpCycle = 0;
+      currRampDownCycle = 1;
+      currRampUpCycle = 1;
     }
 
     sendActivity({
-      appliedSpeed: appliedSpeed === -1 ? null : appliedSpeed,
+      appliedSpeed: appliedPercentage === -1 ? null : appliedPercentage,
       avgCPUTemp,
       avgGPUTemp,
       target,