refactor(core): add clock and controller

Author: exuanbo

eslint.config.js

@@ -138,6 +138,7 @@ export default tseslint.config(
         exceptions: {
           ObjectExpression: true,
           TSEnumMember: true,
+          TSTypeAnnotation: true,
           VariableDeclarator: true,
         },
       }],

src/core/bus/bus.ts

@@ -1,52 +1,41 @@
-import { asapScheduler, BehaviorSubject, filter, observeOn, shareReplay, skipWhile } from 'rxjs'
-
-export const enum Control {
-  CLOCK_IDLE   = 0b0000,
-  MEMORY_READ  = 0b1000,
-  IO_READ      = 0b1001,
-  MEMORY_WRITE = 0b1010,
-  IO_WRITE     = 0b1011,
-  INTERRUPT    = 0b1100,
-}
-
-export interface Signals {
-  data: number
-  address: number
-  control: Control
+import { BehaviorSubject, filter, type Observable, share } from 'rxjs'
+
+export type Signal = 0b0 | 0b1
+
+export interface ControlLines {
+  RD:   Signal
+  WR:   Signal
+  MREQ: Signal
+  IORQ: Signal
+  CLK:  Signal
+  WAIT: Signal
+  IRQ:  Signal
+  HALT: Signal
 }
 
-const initialSignals: Signals = {
-  data: 0x00,
-  address: 0x00,
-  control: Control.CLOCK_IDLE,
+const initialControlLines: ControlLines = {
+  RD:   0b0,
+  WR:   0b0,
+  MREQ: 0b0,
+  IORQ: 0b0,
+  CLK:  0b0,
+  WAIT: 0b0,
+  IRQ:  0b0,
+  HALT: 0b0,
 }
 
 export class Bus {
-  private readonly source$ = new BehaviorSubject(initialSignals)
+  readonly data$ = new BehaviorSubject(0x00)
+  readonly address$ = new BehaviorSubject(0x00)
+  readonly control$ = new BehaviorSubject(initialControlLines)
 
-  private readonly shared$ = this.source$.pipe(
-    observeOn(asapScheduler),
-    shareReplay(1),
+  readonly controlOnClockRise$: Observable<ControlLines> = this.control$.pipe(
+    filter((control, index) => (index && control.CLK)),
+    share(),
   )
 
-  get signals$() {
-    return this.shared$
-  }
-
-  get idle$() {
-    return this.shared$.pipe(
-      filter((signals) => (signals.control === Control.CLOCK_IDLE)),
-    )
-  }
-
-  put(next: Partial<Signals>) {
-    const nextSignals = {
-      ...this.source$.getValue(),
-      ...next,
-    }
-    this.source$.next(nextSignals)
-    return this.shared$.pipe(
-      skipWhile((signals) => (signals !== nextSignals)),
-    )
+  setControl(lines: Partial<ControlLines>): void {
+    const control = this.control$.getValue()
+    this.control$.next(Object.assign(control, lines))
   }
 }

src/core/clock/README.md

@@ -0,0 +1 @@
+# Clock

src/core/clock/clock.ts

@@ -0,0 +1,12 @@
+import type { Bus } from '../bus/bus'
+
+export class Clock {
+  constructor(
+    private readonly bus: Bus,
+  ) {}
+
+  tick = (): void => {
+    this.bus.setControl({ CLK: 0b1 })
+    this.bus.setControl({ CLK: 0b0 })
+  }
+}

src/core/controller/README.md

@@ -0,0 +1 @@
+# Controller

src/core/controller/controller.spec.ts

@@ -0,0 +1,24 @@
+import { firstValueFrom } from 'rxjs'
+import { describe, expect, it } from 'vitest'
+
+import { Bus } from '../bus/bus'
+import { Clock } from '../clock/clock'
+import { Cpu } from '../cpu/cpu'
+import { Memory } from '../memory/memory'
+import { Controller } from './controller'
+
+describe('Controller', () => {
+  it('should step', async () => {
+    const bus = new Bus()
+    const memory = new Memory(bus)
+    memory.load(new Uint8Array([0x01, 0x02]), 0x00)
+    const controller = new Controller(
+      bus,
+      new Cpu(bus),
+      new Clock(bus),
+      memory,
+    )
+    await firstValueFrom(controller.step())
+    expect(memory.getData()[0x02]).toBe(0x03)
+  })
+})

src/core/controller/controller.ts

@@ -0,0 +1,37 @@
+import { Observable, type Subscription } from 'rxjs'
+
+import type { Bus, ControlLines } from '../bus/bus'
+import type { Clock } from '../clock/clock'
+import type { Cpu } from '../cpu/cpu'
+import type { Memory } from '../memory/memory'
+
+export class Controller {
+  constructor(
+    private readonly bus: Bus,
+    private readonly cpu: Cpu,
+    private readonly clock: Clock,
+    private readonly memory: Memory,
+  ) {}
+
+  step = (): Observable<void> => {
+    return new Observable<void>((subscriber) => {
+      const step = this.cpu.step()
+      let subscription: Subscription
+
+      const handleResult = (result: IteratorResult<Observable<ControlLines>, void>) => {
+        if (result.done) {
+          subscriber.next()
+          subscriber.complete()
+          return
+        }
+        queueMicrotask(this.clock.tick)
+        subscription = result.value.subscribe((signals) => {
+          handleResult(step.next(signals))
+        })
+      }
+
+      handleResult(step.next())
+      return () => subscription.unsubscribe()
+    })
+  }
+}

src/core/cpu/cpu.ts

@@ -1,43 +1,46 @@
-import { filter, firstValueFrom, map, skipUntil } from 'rxjs'
+import { type Observable, take } from 'rxjs'
 
-import { type Bus, Control, type Signals } from '../bus/bus'
+import type { Bus, ControlLines } from '../bus/bus'
+
+type AsyncControlGenerator<T> = Generator<Observable<ControlLines>, T, ControlLines>
 
 export class Cpu {
   constructor(
     private readonly bus: Bus,
-  ) {
-    this.bus.signals$.pipe(
-      filter((signals) => (signals.control === Control.INTERRUPT)),
-    ).subscribe(this.handleInterrupt)
-  }
-
-  async step() {
-    // TODO: implement step
-    // const opcode = await this.readMemory(...)
-  }
+  ) {}
 
-  private readMemory(address: number) {
-    const data$ = this.bus.put({
-      address,
-      control: Control.MEMORY_READ,
-    }).pipe(
-      skipUntil(this.bus.idle$),
-      map((signals) => signals.data),
-    )
-    return firstValueFrom(data$)
+  *step(): AsyncControlGenerator<void> {
+    const x = yield* this.readMemory(0x00)
+    const y = yield* this.readMemory(0x01)
+    const result = x + y
+    yield* this.writeMemory(result, 0x02)
   }
 
-  private writeMemory(address: number, data: number) {
-    const complete$ = this.bus.put({
-      data,
-      address,
-      control: Control.MEMORY_WRITE,
+  *readMemory(address: number): AsyncControlGenerator<number> {
+    this.bus.address$.next(address)
+    this.bus.setControl({
+      RD:   0b1,
+      MREQ: 0b1,
     })
-    return firstValueFrom(complete$)
+    yield this.bus.controlOnClockRise$.pipe(take(1))
+    this.bus.setControl({
+      RD:   0b0,
+      MREQ: 0b0,
+    })
+    return this.bus.data$.getValue()
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  private handleInterrupt = (_signals: Signals) => {
-    // TODO: implement interrupt handling
+  *writeMemory(data: number, address: number): AsyncControlGenerator<void> {
+    this.bus.data$.next(data)
+    this.bus.address$.next(address)
+    this.bus.setControl({
+      WR:   0b1,
+      MREQ: 0b1,
+    })
+    yield this.bus.controlOnClockRise$.pipe(take(1))
+    this.bus.setControl({
+      WR:   0b0,
+      MREQ: 0b0,
+    })
   }
 }

src/core/memory/memory.ts

@@ -1,60 +1,85 @@
-import { filter, map, type Observable, share, tap } from 'rxjs'
+import { filter, map, type Observable, share } from 'rxjs'
 
-import { type Bus, Control, type Signals } from '../bus/bus'
+import type { Bus } from '../bus/bus'
+
+export enum MemoryOperationType {
+  READ  = 'READ',
+  WRITE = 'WRITE',
+}
+
+export interface MemoryOperation {
+  type: MemoryOperationType
+  data: number
+  address: number
+}
 
 export class Memory {
   // TODO: use shared constants
   private readonly data = new Uint8Array(0x100)
 
-  private readonly read$: Observable<Signals>
-  private readonly write$: Observable<Signals>
+  readonly read$: Observable<MemoryOperation>
+  readonly write$: Observable<MemoryOperation>
 
   constructor(
     private readonly bus: Bus,
   ) {
-    this.read$ = this.bus.signals$.pipe(
-      filter((signals) => signals.control === Control.MEMORY_READ),
-      tap(this.read),
+    const control$ = this.bus.control$.pipe(
+      filter((control) => control.MREQ),
       share(),
     )
 
-    this.write$ = this.bus.signals$.pipe(
-      filter((signals) => signals.control === Control.MEMORY_WRITE),
-      tap(this.write),
+    this.read$ = control$.pipe(
+      filter((control) => control.RD),
+      map(this.read),
+      share(),
+    )
+
+    this.write$ = control$.pipe(
+      filter((control) => control.WR),
+      map(this.write),
       share(),
     )
 
     this.read$.subscribe()
     this.write$.subscribe()
   }
 
-  private read = (signals: Signals) => {
-    this.bus.put({
-      data: this.data[signals.address],
-      control: Control.CLOCK_IDLE,
-    })
+  private read = (): MemoryOperation => {
+    const address = this.bus.address$.getValue()
+    const data = this.data[address]
+    this.bus.data$.next(data)
+    return {
+      type: MemoryOperationType.READ,
+      data,
+      address,
+    }
   }
 
-  private write = (signals: Signals) => {
-    this.data[signals.address] = signals.data
-    this.bus.put({
-      control: Control.CLOCK_IDLE,
-    })
+  private write = (): MemoryOperation => {
+    const address = this.bus.address$.getValue()
+    const data = this.bus.data$.getValue()
+    this.data[address] = data
+    return {
+      type: MemoryOperationType.WRITE,
+      data,
+      address,
+    }
   }
 
-  get data$() {
-    return this.write$.pipe(map(() => this.getData()))
+  getData = (): number[] => {
+    return Array.from(this.data)
   }
 
-  getData() {
-    return Array.from(this.data)
+  subscribeData = (onDataChange: (() => void)): (() => void) => {
+    const subscription = this.write$.subscribe(onDataChange)
+    return () => subscription.unsubscribe()
   }
 
-  load(data: Uint8Array, offset: number) {
+  load(data: Uint8Array, offset: number): void {
     this.data.set(data, offset)
   }
 
-  reset() {
+  reset(): void {
     this.data.fill(0)
   }
 }

src/rxjs.d.ts

@@ -0,0 +1,6 @@
+import type { MonoTypeOperatorFunction } from 'rxjs'
+
+declare module 'rxjs' {
+  export function filter<T>(predicate: (value: T, index: number) => unknown): MonoTypeOperatorFunction<T>
+  export function skipWhile<T>(predicate: (value: T, index: number) => unknown): MonoTypeOperatorFunction<T>
+}

src/ts-reset.d.ts

@@ -2,8 +2,11 @@
 type WithRequired<T, K extends keyof T> = T & Omit<T, K> & Required<Pick<T, K>>
 
 interface ObjectConstructor {
+  hasOwn<T extends Record<K, any>, K extends PropertyKey>(o: T, v: K):
+    v is keyof T
+
   hasOwn<T, K extends PropertyKey>(o: T, v: K):
     o is K extends keyof T
       ? WithRequired<T, K>
-      : Extract<T, Record<K, unknown>>
+      : Extract<T, Record<K, any>>
 }