Add Periodic Refresh Timer

Signed-off-by: Jens Reinecke <[email protected]>

Author: jreineckearm

src/debug-session/gdbtarget-debug-session.ts

@@ -18,15 +18,22 @@ import * as vscode from 'vscode';
 import { DebugProtocol } from '@vscode/debugprotocol';
 import { logger } from '../logger';
 import { CbuildRunReader } from '../cbuild-run';
+import { PeriodicRefreshTimer } from './periodic-refresh-timer';
 
 /**
  * GDBTargetDebugSession - Wrapper class to provide session state/details
  */
 export class GDBTargetDebugSession {
+    public readonly refreshTimer: PeriodicRefreshTimer<GDBTargetDebugSession>;
     private _cbuildRun: CbuildRunReader|undefined;
     private _cbuildRunParsePromise: Promise<void>|undefined;
 
-    constructor(public session: vscode.DebugSession) {}
+    constructor(public session: vscode.DebugSession) {
+        this.refreshTimer = new PeriodicRefreshTimer(this);
+        if (this.session.configuration.type === 'gdbtarget') {
+            this.refreshTimer.enabled = this.session.configuration['auxiliaryGdb'] === true;
+        }
+    }
 
     public async getCbuildRun(): Promise<CbuildRunReader|undefined> {
         if (!this._cbuildRun) {
@@ -89,7 +96,7 @@ export class GDBTargetDebugSession {
     }
 
     public async readMemoryU32(address: number): Promise<number|undefined> {
-        const data = await this.readMemory(address, 4);
+        const data = await this.readMemory(address, 8 /* 4 */); // Temporary workaround for GDB servers with extra caching of 4 byte reads
         if (!data) {
             return undefined;
         }

src/debug-session/gdbtarget-debug-tracker.ts

@@ -120,8 +120,10 @@ export class GDBTargetDebugTracker {
         switch (event.event) {
             case 'continued':
                 this._onContinued.fire({ session: gdbTargetSession, event } as ContinuedEvent);
+                gdbTargetSession?.refreshTimer.start();
                 break;
             case 'stopped':
+                gdbTargetSession?.refreshTimer.stop();
                 this._onStopped.fire({ session: gdbTargetSession, event } as StoppedEvent);
                 break;
         }

src/debug-session/periodic-refresh-timer.ts

@@ -0,0 +1,60 @@
+/**
+ * Copyright 2025 Arm Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import * as vscode from 'vscode';
+
+const DEFAULT_REFRESH_INTERVAL = 500;
+
+export class PeriodicRefreshTimer<T> {
+    private _enabled: boolean = false;
+    private _timer: NodeJS.Timeout|undefined;
+
+    private readonly _onRefresh: vscode.EventEmitter<T> = new vscode.EventEmitter<T>();
+    public readonly onRefresh: vscode.Event<T> = this._onRefresh.event;
+
+    public get enabled(): boolean {
+        return this._enabled;
+    }
+
+    public set enabled(value: boolean) {
+        this._enabled = value;
+        if (!value) {
+            this.stop();
+        }
+    }
+
+    constructor(public session: T, public interval: number = DEFAULT_REFRESH_INTERVAL) {
+    }
+
+    public start(): void {
+        this.stop();
+        if (!this._enabled) {
+            return;
+        }
+        const doPeriodicRefresh = () => {
+            this._onRefresh.fire(this.session);
+            this._timer = setTimeout(doPeriodicRefresh, this.interval);
+        };
+        this._timer = setTimeout(doPeriodicRefresh, this.interval);
+    }
+
+    public stop(): void {
+        if (this._timer) {
+            clearTimeout(this._timer);
+            this._timer = undefined;
+        }
+    }
+}

src/features/cpu-states/cpu-states.ts

@@ -77,6 +77,7 @@ export class CpuStates {
             hasStates: undefined
         };
         this.sessionCpuStates.set(session.session.id, states);
+        session.refreshTimer.onRefresh(async (refreshSession) => this.handlePeriodicRefresh(refreshSession));
     }
 
     protected handleOnWillStopSession(session: GDBTargetDebugSession): void {
@@ -109,23 +110,41 @@ export class CpuStates {
         cpuStates.isRunning = true;
     }
 
+    private async shouldUpdate(session: GDBTargetDebugSession, cpuStates: SessionCpuStates): Promise<boolean> {
+        if (cpuStates.hasStates === undefined) {
+            // Retry if early read after launch/attach response failed (e.g. if
+            // target was running).
+            cpuStates.hasStates = await this.supportsCpuStates(session);
+        }
+        return cpuStates.hasStates;
+    }
+
     protected async handleStoppedEvent(event: StoppedEvent): Promise<void> {
         const cpuStates = this.sessionCpuStates.get(event.session.session.id);
         if (!cpuStates) {
             return;
         }
         cpuStates.isRunning = false;
-        if (cpuStates.hasStates === undefined) {
-            // Retry if early read after launch/attach response failed (e.g. if
-            // target was running).
-            cpuStates.hasStates = await this.supportsCpuStates(event.session);
-        }
-        if (!cpuStates.hasStates) {
+        const doUpdate = await this.shouldUpdate(event.session, cpuStates);
+        if (!doUpdate) {
             return;
         }
         return this.updateCpuStates(event.session, event.event.body.threadId, event.event.body.reason);
     }
 
+    protected async handlePeriodicRefresh(session: GDBTargetDebugSession): Promise<void> {
+        const cpuStates = this.sessionCpuStates.get(session.session.id);
+        if (!cpuStates) {
+            return;
+        }
+        const doUpdate = await this.shouldUpdate(session, cpuStates);
+        if (!doUpdate) {
+            return;
+        }
+        await this.updateCpuStates(session);
+        this._onRefresh.fire(0);
+    }
+
     protected handleStackTrace(stackTrace: SessionStackTrace): void {
         const states = this.activeCpuStates;
         if (!states) {
@@ -186,7 +205,10 @@ export class CpuStates {
         // Caution with types...
         states.lastCycles = newCycles;
         states.states += BigInt(cycleAdd);
-        states.statesHistory.updateHistory(states.states, threadId, reason);
+        if (reason) {
+            // Stopped events always have a reason, only update history for them
+            states.statesHistory.updateHistory(states.states, threadId, reason);
+        }
     }
 
     protected async getFrequency(): Promise<number|undefined> {