Publish VCC Plus OSS source distribution for 3.6.2 build 60

This commit is contained in:
Brian Holman committed 2026-11-13 00:14:03 -07:00
commit c652a5276d
1192 files changed
+272368

No files matched your search

+113
View File
@@ -0,0 +1,113 @@
// SPDX-License-Identifier: GPL-3.0-or-later
// Opt-in real-time integration runner. Reads a user ROM, never mounts/writes media.
#import <Foundation/Foundation.h>
#import "../../platforms/macos/Bridge/VCCMachineController.h"
#include <mach/mach.h>
#include <algorithm>
#include <chrono>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <stdexcept>
#include <string>
using Clock = std::chrono::steady_clock;
static void pump(double seconds) {
const auto end = Clock::now() + std::chrono::duration<double>(seconds);
while (Clock::now() < end) @autoreleasepool {
[[NSRunLoop mainRunLoop] runUntilDate:[NSDate dateWithTimeIntervalSinceNow:0.005]];
}
}
static VCCMachineSnapshot* command(void (^operation)(VCCMachineCompletion)) {
__block VCCMachineSnapshot* result = nil;
operation(^(VCCMachineSnapshot* snapshot) { result = snapshot; });
const auto deadline = Clock::now() + std::chrono::seconds(10);
while (!result && Clock::now() < deadline) pump(0.005);
if (!result) throw std::runtime_error("Machine command timed out");
if (result.errorMessage) throw std::runtime_error(result.errorMessage.UTF8String);
return result;
}
static uint64_t key(char c) {
if (c >= 'A' && c <= 'Z') return uint64_t(1) << (c - '@');
if (c >= '0' && c <= '9') return uint64_t(1) << (32 + c - '0');
if (c == ',') return uint64_t(1) << 44;
if (c == ' ') return uint64_t(1) << 31;
if (c == '\n') return uint64_t(1) << 48;
throw std::runtime_error("Unsupported probe key");
}
static void type(VCCMachineController* machine, const std::string& text) {
for (char c : text) { [machine setKeyboardMask:key(c)]; pump(0.10); [machine setKeyboardMask:0]; pump(0.10); }
}
static uint64_t residentBytes() {
mach_task_basic_info_data_t info{}; mach_msg_type_number_t count = MACH_TASK_BASIC_INFO_COUNT;
if (task_info(mach_task_self(), MACH_TASK_BASIC_INFO, reinterpret_cast<task_info_t>(&info), &count) != KERN_SUCCESS)
throw std::runtime_error("Unable to read process memory usage");
return info.resident_size;
}
int main(int argc, const char* argv[]) { @autoreleasepool {
if (argc < 4 || argc > 5) {
std::fprintf(stderr, "Usage: SustainedChecks ROM seconds 6809|6309 [silent]\n"); return 2;
}
auto machine = [VCCMachineController new];
try {
std::size_t parsed = 0;
const double duration = std::stod(argv[2], &parsed);
if (parsed != std::string(argv[2]).size()) throw std::runtime_error("Invalid duration");
if (!std::isfinite(duration) || duration < 5 || duration > 86400) throw std::runtime_error("Duration must be 5–86400 seconds");
const std::string cpu = argv[3];
if (cpu != "6809" && cpu != "6309") throw std::runtime_error("Select 6809 or 6309");
const bool audio = argc == 4;
if (argc == 5 && std::string(argv[4]) != "silent") throw std::runtime_error("Unknown pacing mode");
auto rom = [NSData dataWithContentsOfFile:[NSString stringWithUTF8String:argv[1]] options:NSDataReadingMappedIfSafe error:nil];
if (rom.length != 32768) throw std::runtime_error("Supply a readable 32 KiB CoCo 3 ROM");
command(^(VCCMachineCompletion done) { [machine setAudioEnabled:audio volume:0 completion:done]; });
command(^(VCCMachineCompletion done) { [machine loadROM:rom use6309:cpu == "6309" completion:done]; });
command(^(VCCMachineCompletion done) { [machine resumeWithCompletion:done]; });
pump(3);
type(machine, "10 SOUND100,255\n20 PRINT 42\n30 GOTO10\nRUN\n");
pump(5);
auto baseline = command(^(VCCMachineCompletion done) { [machine snapshotWithCompletion:done]; });
const auto start = Clock::now();
const auto initialRSS = residentBytes(); uint64_t maximumRSS = initialRSS;
double maxDrift = 0, maxAudioDrift = 0; unsigned polls = 0; uint64_t previousSignal = baseline.audioSignalSamples;
std::printf("START cpu=%s audio=%d seconds=%.0f frames=%llu consumed=%llu rss=%llu\n",cpu.c_str(),audio,duration,baseline.frames,baseline.audioConsumed,initialRSS); std::fflush(stdout);
VCCMachineSnapshot* latest = baseline;
while (std::chrono::duration<double>(Clock::now() - start).count() < duration) {
@autoreleasepool {
pump(std::min(1.0, duration - std::chrono::duration<double>(Clock::now() - start).count()));
latest = command(^(VCCMachineCompletion done) { [machine snapshotWithCompletion:done]; });
const auto wall = std::chrono::duration<double>(Clock::now() - start).count();
const double emulated = (latest.frames - baseline.frames) * (239856.0 / 14318180.0);
const double consumed = (latest.audioConsumed - baseline.audioConsumed) / 44100.0;
maximumRSS = std::max(maximumRSS, residentBytes());
maxDrift = std::max(maxDrift, std::abs(emulated - wall));
if (audio) maxAudioDrift = std::max(maxAudioDrift, std::abs(consumed - wall));
if (latest.state != VCCMachineStateRunning || latest.generation != baseline.generation || latest.frames <= baseline.frames)
throw std::runtime_error("Machine stopped, reset or failed to advance");
if (++polls % 30 == 0 || wall >= duration) {
if (audio && wall >= 30 && latest.audioSignalSamples == previousSignal)
throw std::runtime_error("BASIC tone loop stopped producing a signal");
previousSignal = latest.audioSignalSamples;
std::printf("SAMPLE wall=%.3f emulated=%.3f audio=%.3f drift_ms=%.3f underruns=%llu overruns=%llu rss=%llu buffered=%llu starts=%llu signal=%llu max_request=%llu max_refill_gap_ms=%.3f\n",
wall, emulated, consumed, (emulated-wall)*1000, latest.audioUnderruns-baseline.audioUnderruns,
latest.audioOverruns-baseline.audioOverruns, residentBytes(), latest.audioBuffered, latest.audioStarts, latest.audioSignalSamples, latest.audioMaximumRequest, latest.audioMaximumRefillGapNanoseconds / 1000000.0); std::fflush(stdout);
}
}
}
auto paused = command(^(VCCMachineCompletion done) { [machine pauseWithCompletion:done]; });
pump(0.25);
auto still = command(^(VCCMachineCompletion done) { [machine snapshotWithCompletion:done]; });
if (still.frames != paused.frames || still.audioConsumed != paused.audioConsumed) throw std::runtime_error("Pause did not stop execution/audio");
command(^(VCCMachineCompletion done) { [machine shutdownWithCompletion:done]; });
std::printf("RESULT seconds=%.3f max_frame_drift_ms=%.3f max_audio_drift_ms=%.3f rss_growth=%lld underruns=%llu overruns=%llu\n",
std::chrono::duration<double>(Clock::now()-start).count(),maxDrift*1000,maxAudioDrift*1000,
static_cast<long long>(maximumRSS-initialRSS),latest.audioUnderruns-baseline.audioUnderruns,latest.audioOverruns-baseline.audioOverruns);
std::fflush(stdout);
if (maxDrift > 0.25 || (audio && maxAudioDrift > 0.25) || maximumRSS > initialRSS + 64*1024*1024 ||
latest.audioUnderruns != baseline.audioUnderruns || latest.audioOverruns != baseline.audioOverruns)
throw std::runtime_error("Sustained timing/buffering/memory acceptance threshold exceeded");
std::puts("PASS: sustained native controller run and pause stability"); return 0;
} catch (const std::exception& error) {
std::fprintf(stderr,"FAIL: %s\n",error.what());
[machine shutdownWithCompletion:^(VCCMachineSnapshot*) {}]; pump(0.1); return 1;
}
} }