mirror of
https://github.com/mikkelam/fast-cli.git
synced 2025-12-18 12:54:05 +00:00
improve default speed testing strategy
This commit is contained in:
mikkelam
parent
34ed84f50f
commit
1ddc7db574
4 changed files with 671 additions and 105 deletions
142
src/cli/root.zig
142
src/cli/root.zig
|
|
@ -5,6 +5,7 @@ const build_options = @import("build_options");
|
|||
const Fast = @import("../lib/fast.zig").Fast;
|
||||
const HTTPSpeedTester = @import("../lib/http_speed_tester_v2.zig").HTTPSpeedTester;
|
||||
const StabilityCriteria = @import("../lib/http_speed_tester_v2.zig").StabilityCriteria;
|
||||
const FastStabilityCriteria = @import("../lib/http_speed_tester_v2.zig").FastStabilityCriteria;
|
||||
const SpeedTestResult = @import("../lib/http_speed_tester_v2.zig").SpeedTestResult;
|
||||
const BandwidthMeter = @import("../lib/bandwidth.zig");
|
||||
const SpeedMeasurement = @import("../lib/bandwidth.zig").SpeedMeasurement;
|
||||
|
|
@ -45,40 +46,11 @@ const json_output_flag = zli.Flag{
|
|||
.default_value = .{ .Bool = false },
|
||||
};
|
||||
|
||||
const test_mode_flag = zli.Flag{
|
||||
.name = "mode",
|
||||
.description = "Test mode: 'duration' or 'stability'",
|
||||
.shortcut = "m",
|
||||
.type = .String,
|
||||
.default_value = .{ .String = "duration" },
|
||||
};
|
||||
|
||||
const test_duration_flag = zli.Flag{
|
||||
const max_duration_flag = zli.Flag{
|
||||
.name = "duration",
|
||||
.description = "Duration in seconds for each test phase - download, then upload if enabled (duration mode only)",
|
||||
.description = "Maximum test duration in seconds (uses Fast.com-style stability detection by default)",
|
||||
.shortcut = "d",
|
||||
.type = .Int,
|
||||
.default_value = .{ .Int = 5 },
|
||||
};
|
||||
|
||||
const stability_min_samples_flag = zli.Flag{
|
||||
.name = "stability-min-samples",
|
||||
.description = "Minimum samples for stability test",
|
||||
.type = .Int,
|
||||
.default_value = .{ .Int = 5 },
|
||||
};
|
||||
|
||||
const stability_max_variance_flag = zli.Flag{
|
||||
.name = "stability-max-variance",
|
||||
.description = "Maximum variance percentage for stability test",
|
||||
.type = .String,
|
||||
.default_value = .{ .String = "10.0" },
|
||||
};
|
||||
|
||||
const stability_max_duration_flag = zli.Flag{
|
||||
.name = "stability-max-duration",
|
||||
.description = "Maximum duration in seconds for stability test",
|
||||
.type = .Int,
|
||||
.default_value = .{ .Int = 30 },
|
||||
};
|
||||
|
||||
|
|
@ -92,11 +64,7 @@ pub fn build(allocator: std.mem.Allocator) !*zli.Command {
|
|||
try root.addFlag(https_flag);
|
||||
try root.addFlag(check_upload_flag);
|
||||
try root.addFlag(json_output_flag);
|
||||
try root.addFlag(test_mode_flag);
|
||||
try root.addFlag(test_duration_flag);
|
||||
try root.addFlag(stability_min_samples_flag);
|
||||
try root.addFlag(stability_max_variance_flag);
|
||||
try root.addFlag(stability_max_duration_flag);
|
||||
try root.addFlag(max_duration_flag);
|
||||
|
||||
return root;
|
||||
}
|
||||
|
|
@ -105,15 +73,10 @@ fn run(ctx: zli.CommandContext) !void {
|
|||
const use_https = ctx.flag("https", bool);
|
||||
const check_upload = ctx.flag("upload", bool);
|
||||
const json_output = ctx.flag("json", bool);
|
||||
const test_mode = ctx.flag("mode", []const u8);
|
||||
const test_duration = ctx.flag("duration", i64);
|
||||
const stability_min_samples = ctx.flag("stability-min-samples", i64);
|
||||
const stability_max_variance_str = ctx.flag("stability-max-variance", []const u8);
|
||||
const stability_max_duration = ctx.flag("stability-max-duration", i64);
|
||||
const max_duration = ctx.flag("duration", i64);
|
||||
|
||||
const stability_max_variance = std.fmt.parseFloat(f64, stability_max_variance_str) catch 10.0;
|
||||
log.info("Config: https={}, upload={}, json={}, mode={s}, duration={}s", .{
|
||||
use_https, check_upload, json_output, test_mode, test_duration,
|
||||
log.info("Config: https={}, upload={}, json={}, max_duration={}s", .{
|
||||
use_https, check_upload, json_output, max_duration,
|
||||
});
|
||||
|
||||
var fast = Fast.init(std.heap.page_allocator, use_https);
|
||||
|
|
@ -156,81 +119,50 @@ fn run(ctx: zli.CommandContext) !void {
|
|||
var speed_tester = HTTPSpeedTester.init(std.heap.page_allocator);
|
||||
defer speed_tester.deinit();
|
||||
|
||||
// Determine test mode
|
||||
const use_stability = std.mem.eql(u8, test_mode, "stability");
|
||||
// Use Fast.com-style stability detection by default
|
||||
const criteria = FastStabilityCriteria{
|
||||
.min_duration_seconds = 7,
|
||||
.max_duration_seconds = @as(u32, @intCast(@min(30, max_duration))),
|
||||
.stability_delta_percent = 5.0,
|
||||
.min_stable_measurements = 6,
|
||||
};
|
||||
|
||||
// Measure download speed
|
||||
|
||||
const download_result = if (use_stability) blk: {
|
||||
const criteria = StabilityCriteria{
|
||||
.min_samples = @as(u32, @intCast(stability_min_samples)),
|
||||
.max_variance_percent = stability_max_variance,
|
||||
.max_duration_seconds = @as(u32, @intCast(stability_max_duration)),
|
||||
};
|
||||
break :blk speed_tester.measure_download_speed_stability(urls, criteria) catch |err| {
|
||||
if (!json_output) {
|
||||
try ctx.spinner.fail("Download test failed: {}", .{err});
|
||||
} else {
|
||||
log.err("Download test failed: {}", .{err});
|
||||
std.debug.print("{{\"error\": \"{}\"}}\n", .{err});
|
||||
}
|
||||
const download_result = if (json_output) blk: {
|
||||
// JSON mode: clean output only
|
||||
break :blk speed_tester.measure_download_speed_fast_stability(urls, criteria) catch |err| {
|
||||
log.err("Download test failed: {}", .{err});
|
||||
std.debug.print("{{\"error\": \"{}\"}}\n", .{err});
|
||||
return;
|
||||
};
|
||||
} else blk: {
|
||||
if (json_output) {
|
||||
// JSON mode: clean output only
|
||||
break :blk speed_tester.measureDownloadSpeed(urls, @as(u32, @intCast(@max(0, test_duration)))) catch |err| {
|
||||
log.err("Download test failed: {}", .{err});
|
||||
std.debug.print("{{\"error\": \"{}\"}}\n", .{err});
|
||||
return;
|
||||
};
|
||||
} else {
|
||||
// Create progress callback with spinner context
|
||||
const progressCallback = progress.createCallback(ctx.spinner, updateSpinnerText);
|
||||
|
||||
break :blk speed_tester.measureDownloadSpeedWithProgress(urls, @as(u32, @intCast(@max(0, test_duration))), progressCallback) catch |err| {
|
||||
try ctx.spinner.fail("Download test failed: {}", .{err});
|
||||
return;
|
||||
};
|
||||
}
|
||||
// Interactive mode with spinner updates
|
||||
const progressCallback = progress.createCallback(ctx.spinner, updateSpinnerText);
|
||||
break :blk speed_tester.measureDownloadSpeedWithFastStabilityProgress(urls, criteria, progressCallback) catch |err| {
|
||||
try ctx.spinner.fail("Download test failed: {}", .{err});
|
||||
return;
|
||||
};
|
||||
};
|
||||
|
||||
var upload_result: ?SpeedTestResult = null;
|
||||
if (check_upload) {
|
||||
if (!json_output) {
|
||||
const upload_mode_str = if (use_stability) "stability" else "duration";
|
||||
try ctx.spinner.start(.{}, "Measuring upload speed ({s} mode)...", .{upload_mode_str});
|
||||
try ctx.spinner.start(.{}, "Measuring upload speed...", .{});
|
||||
}
|
||||
|
||||
upload_result = if (use_stability) blk: {
|
||||
const criteria = StabilityCriteria{
|
||||
.min_samples = @as(u32, @intCast(stability_min_samples)),
|
||||
.max_variance_percent = stability_max_variance,
|
||||
.max_duration_seconds = @as(u32, @intCast(stability_max_duration)),
|
||||
};
|
||||
break :blk speed_tester.measure_upload_speed_stability(urls, criteria) catch |err| {
|
||||
if (!json_output) {
|
||||
try ctx.spinner.fail("Upload test failed: {}", .{err});
|
||||
}
|
||||
upload_result = if (json_output) blk: {
|
||||
// JSON mode: clean output only
|
||||
break :blk speed_tester.measure_upload_speed_fast_stability(urls, criteria) catch |err| {
|
||||
log.err("Upload test failed: {}", .{err});
|
||||
std.debug.print("{{\"error\": \"{}\"}}\n", .{err});
|
||||
return;
|
||||
};
|
||||
} else blk: {
|
||||
if (json_output) {
|
||||
// JSON mode: clean output only
|
||||
break :blk speed_tester.measureUploadSpeed(urls, @as(u32, @intCast(@max(0, test_duration)))) catch |err| {
|
||||
log.err("Upload test failed: {}", .{err});
|
||||
std.debug.print("{{\"error\": \"{}\"}}\n", .{err});
|
||||
return;
|
||||
};
|
||||
} else {
|
||||
// Create progress callback with spinner context
|
||||
const uploadProgressCallback = progress.createCallback(ctx.spinner, updateUploadSpinnerText);
|
||||
|
||||
break :blk speed_tester.measureUploadSpeedWithProgress(urls, @as(u32, @intCast(@max(0, test_duration))), uploadProgressCallback) catch |err| {
|
||||
try ctx.spinner.fail("Upload test failed: {}", .{err});
|
||||
return;
|
||||
};
|
||||
}
|
||||
// Interactive mode with spinner updates
|
||||
const uploadProgressCallback = progress.createCallback(ctx.spinner, updateUploadSpinnerText);
|
||||
break :blk speed_tester.measureUploadSpeedWithFastStabilityProgress(urls, criteria, uploadProgressCallback) catch |err| {
|
||||
try ctx.spinner.fail("Upload test failed: {}", .{err});
|
||||
return;
|
||||
};
|
||||
};
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -7,7 +7,9 @@ const WorkerManager = @import("workers/worker_manager.zig").WorkerManager;
|
|||
const measurement_strategy = @import("measurement_strategy.zig");
|
||||
const DurationStrategy = measurement_strategy.DurationStrategy;
|
||||
const StabilityStrategy = measurement_strategy.StabilityStrategy;
|
||||
const FastStabilityStrategy = measurement_strategy.FastStabilityStrategy;
|
||||
pub const StabilityCriteria = measurement_strategy.StabilityCriteria;
|
||||
pub const FastStabilityCriteria = measurement_strategy.FastStabilityCriteria;
|
||||
|
||||
const print = std.debug.print;
|
||||
|
||||
|
|
@ -71,6 +73,18 @@ pub const HTTPSpeedTester = struct {
|
|||
return self.measureDownloadSpeedWithStability(urls, &strategy);
|
||||
}
|
||||
|
||||
// Fast.com-style stability-based download with optional progress callback
|
||||
pub fn measure_download_speed_fast_stability_duration(self: *HTTPSpeedTester, urls: []const []const u8, criteria: FastStabilityCriteria, comptime ProgressType: ?type, progress_callback: if (ProgressType) |T| T else void) !SpeedTestResult {
|
||||
var strategy = measurement_strategy.createFastStabilityStrategy(self.allocator, criteria);
|
||||
defer strategy.deinit();
|
||||
return self.measureDownloadSpeedWithFastStability(urls, &strategy, ProgressType, progress_callback);
|
||||
}
|
||||
|
||||
// Fast.com-style stability-based download without progress callback
|
||||
pub fn measure_download_speed_fast_stability(self: *HTTPSpeedTester, urls: []const []const u8, criteria: FastStabilityCriteria) !SpeedTestResult {
|
||||
return self.measure_download_speed_fast_stability_duration(urls, criteria, null, {});
|
||||
}
|
||||
|
||||
// Clean duration-based upload with optional progress callback
|
||||
pub fn measure_upload_speed_duration(self: *HTTPSpeedTester, urls: []const []const u8, duration_seconds: u32, comptime ProgressType: ?type, progress_callback: if (ProgressType) |T| T else void) !SpeedTestResult {
|
||||
const upload_data = try self.allocator.alloc(u8, 4 * 1024 * 1024);
|
||||
|
|
@ -92,6 +106,22 @@ pub const HTTPSpeedTester = struct {
|
|||
return self.measureUploadSpeedWithStability(urls, &strategy, upload_data);
|
||||
}
|
||||
|
||||
// Fast.com-style stability-based upload with optional progress callback
|
||||
pub fn measure_upload_speed_fast_stability_duration(self: *HTTPSpeedTester, urls: []const []const u8, criteria: FastStabilityCriteria, comptime ProgressType: ?type, progress_callback: if (ProgressType) |T| T else void) !SpeedTestResult {
|
||||
const upload_data = try self.allocator.alloc(u8, 4 * 1024 * 1024);
|
||||
defer self.allocator.free(upload_data);
|
||||
@memset(upload_data, 'A');
|
||||
|
||||
var strategy = measurement_strategy.createFastStabilityStrategy(self.allocator, criteria);
|
||||
defer strategy.deinit();
|
||||
return self.measureUploadSpeedWithFastStability(urls, &strategy, upload_data, ProgressType, progress_callback);
|
||||
}
|
||||
|
||||
// Fast.com-style stability-based upload without progress callback
|
||||
pub fn measure_upload_speed_fast_stability(self: *HTTPSpeedTester, urls: []const []const u8, criteria: FastStabilityCriteria) !SpeedTestResult {
|
||||
return self.measure_upload_speed_fast_stability_duration(urls, criteria, null, {});
|
||||
}
|
||||
|
||||
// Convenience helpers for cleaner API usage
|
||||
|
||||
/// Simple download speed measurement without progress callback
|
||||
|
|
@ -114,6 +144,16 @@ pub const HTTPSpeedTester = struct {
|
|||
return self.measure_upload_speed_duration(urls, duration_seconds, @TypeOf(progress_callback), progress_callback);
|
||||
}
|
||||
|
||||
/// Fast stability download speed measurement with progress callback (type inferred)
|
||||
pub fn measureDownloadSpeedWithFastStabilityProgress(self: *HTTPSpeedTester, urls: []const []const u8, criteria: FastStabilityCriteria, progress_callback: anytype) !SpeedTestResult {
|
||||
return self.measure_download_speed_fast_stability_duration(urls, criteria, @TypeOf(progress_callback), progress_callback);
|
||||
}
|
||||
|
||||
/// Fast stability upload speed measurement with progress callback (type inferred)
|
||||
pub fn measureUploadSpeedWithFastStabilityProgress(self: *HTTPSpeedTester, urls: []const []const u8, criteria: FastStabilityCriteria, progress_callback: anytype) !SpeedTestResult {
|
||||
return self.measure_upload_speed_fast_stability_duration(urls, criteria, @TypeOf(progress_callback), progress_callback);
|
||||
}
|
||||
|
||||
// Private implementation for duration-based download
|
||||
fn measureDownloadSpeedWithDuration(
|
||||
self: *HTTPSpeedTester,
|
||||
|
|
@ -359,4 +399,150 @@ pub const HTTPSpeedTester = struct {
|
|||
const speed_bytes_per_sec = @as(f64, @floatFromInt(totals.bytes)) / actual_duration_s;
|
||||
return SpeedTestResult.fromBytesPerSecond(speed_bytes_per_sec);
|
||||
}
|
||||
|
||||
// Private implementation for Fast.com-style stability-based download
|
||||
fn measureDownloadSpeedWithFastStability(
|
||||
self: *HTTPSpeedTester,
|
||||
urls: []const []const u8,
|
||||
strategy: *FastStabilityStrategy,
|
||||
comptime ProgressType: ?type,
|
||||
progress_callback: if (ProgressType) |T| T else void,
|
||||
) !SpeedTestResult {
|
||||
const has_progress = ProgressType != null;
|
||||
var timer = try speed_worker.RealTimer.init();
|
||||
var should_stop = std.atomic.Value(bool).init(false);
|
||||
|
||||
// Initialize bandwidth meter for progress tracking
|
||||
var bandwidth_meter = BandwidthMeter.init();
|
||||
if (has_progress) {
|
||||
try bandwidth_meter.start();
|
||||
}
|
||||
|
||||
// Setup worker manager
|
||||
const num_workers = @min(urls.len, self.concurrent_connections);
|
||||
var worker_manager = try WorkerManager.init(self.allocator, &should_stop, num_workers);
|
||||
defer worker_manager.deinit();
|
||||
|
||||
// Setup download workers
|
||||
const workers = try worker_manager.setupDownloadWorkers(
|
||||
urls,
|
||||
self.concurrent_connections,
|
||||
timer.timer_interface(),
|
||||
strategy.max_duration_ns,
|
||||
);
|
||||
defer worker_manager.cleanupWorkers(workers);
|
||||
|
||||
// Start workers
|
||||
try worker_manager.startDownloadWorkers(workers);
|
||||
|
||||
// Main measurement loop
|
||||
while (strategy.shouldContinue(timer.timer_interface().read())) {
|
||||
std.time.sleep(strategy.getSleepInterval());
|
||||
|
||||
const current_bytes = worker_manager.getCurrentDownloadBytes(workers);
|
||||
|
||||
if (has_progress) {
|
||||
bandwidth_meter.update_total(current_bytes);
|
||||
const measurement = bandwidth_meter.bandwidthWithUnits();
|
||||
progress_callback.call(measurement);
|
||||
}
|
||||
|
||||
const should_stop_early = try strategy.handleProgress(
|
||||
timer.timer_interface().read(),
|
||||
current_bytes,
|
||||
);
|
||||
|
||||
if (should_stop_early) break;
|
||||
}
|
||||
|
||||
// Stop and wait for workers
|
||||
worker_manager.stopAndJoinWorkers();
|
||||
|
||||
// Calculate results
|
||||
const totals = worker_manager.calculateDownloadTotals(workers);
|
||||
if (totals.errors > 0) {
|
||||
print("Download completed with {} errors\n", .{totals.errors});
|
||||
}
|
||||
|
||||
const actual_duration_ns = timer.timer_interface().read();
|
||||
const actual_duration_s = @as(f64, @floatFromInt(actual_duration_ns)) / std.time.ns_per_s;
|
||||
|
||||
if (actual_duration_s == 0) return SpeedTestResult.fromBytesPerSecond(0);
|
||||
const speed_bytes_per_sec = @as(f64, @floatFromInt(totals.bytes)) / actual_duration_s;
|
||||
return SpeedTestResult.fromBytesPerSecond(speed_bytes_per_sec);
|
||||
}
|
||||
|
||||
// Private implementation for Fast.com-style stability-based upload
|
||||
fn measureUploadSpeedWithFastStability(
|
||||
self: *HTTPSpeedTester,
|
||||
urls: []const []const u8,
|
||||
strategy: *FastStabilityStrategy,
|
||||
upload_data: []const u8,
|
||||
comptime ProgressType: ?type,
|
||||
progress_callback: if (ProgressType) |T| T else void,
|
||||
) !SpeedTestResult {
|
||||
const has_progress = ProgressType != null;
|
||||
var timer = try speed_worker.RealTimer.init();
|
||||
var should_stop = std.atomic.Value(bool).init(false);
|
||||
|
||||
// Initialize bandwidth meter for progress tracking
|
||||
var bandwidth_meter = BandwidthMeter.init();
|
||||
if (has_progress) {
|
||||
try bandwidth_meter.start();
|
||||
}
|
||||
|
||||
// Setup worker manager
|
||||
const num_workers = @min(urls.len, self.concurrent_connections);
|
||||
var worker_manager = try WorkerManager.init(self.allocator, &should_stop, num_workers);
|
||||
defer worker_manager.deinit();
|
||||
|
||||
// Setup upload workers
|
||||
const workers = try worker_manager.setupUploadWorkers(
|
||||
urls,
|
||||
self.concurrent_connections,
|
||||
timer.timer_interface(),
|
||||
strategy.max_duration_ns,
|
||||
upload_data,
|
||||
);
|
||||
defer worker_manager.cleanupWorkers(workers);
|
||||
|
||||
// Start workers
|
||||
try worker_manager.startUploadWorkers(workers);
|
||||
|
||||
// Main measurement loop
|
||||
while (strategy.shouldContinue(timer.timer_interface().read())) {
|
||||
std.time.sleep(strategy.getSleepInterval());
|
||||
|
||||
const current_bytes = worker_manager.getCurrentUploadBytes(workers);
|
||||
|
||||
if (has_progress) {
|
||||
bandwidth_meter.update_total(current_bytes);
|
||||
const measurement = bandwidth_meter.bandwidthWithUnits();
|
||||
progress_callback.call(measurement);
|
||||
}
|
||||
|
||||
const should_stop_early = try strategy.handleProgress(
|
||||
timer.timer_interface().read(),
|
||||
current_bytes,
|
||||
);
|
||||
|
||||
if (should_stop_early) break;
|
||||
}
|
||||
|
||||
// Stop and wait for workers
|
||||
worker_manager.stopAndJoinWorkers();
|
||||
|
||||
// Calculate results
|
||||
const totals = worker_manager.calculateUploadTotals(workers);
|
||||
if (totals.errors > 0) {
|
||||
print("Upload completed with {} errors\n", .{totals.errors});
|
||||
}
|
||||
|
||||
const actual_duration_ns = timer.timer_interface().read();
|
||||
const actual_duration_s = @as(f64, @floatFromInt(actual_duration_ns)) / std.time.ns_per_s;
|
||||
|
||||
if (actual_duration_s == 0) return SpeedTestResult.fromBytesPerSecond(0);
|
||||
const speed_bytes_per_sec = @as(f64, @floatFromInt(totals.bytes)) / actual_duration_s;
|
||||
return SpeedTestResult.fromBytesPerSecond(speed_bytes_per_sec);
|
||||
}
|
||||
};
|
||||
|
|
|
|||
|
|
@ -1,5 +1,13 @@
|
|||
const std = @import("std");
|
||||
|
||||
pub const FastStabilityCriteria = struct {
|
||||
min_duration_seconds: u32 = 7,
|
||||
max_duration_seconds: u32 = 30,
|
||||
stability_delta_percent: f64 = 5.0,
|
||||
min_stable_measurements: u32 = 6,
|
||||
};
|
||||
|
||||
// Keep old struct for backward compatibility during transition
|
||||
pub const StabilityCriteria = struct {
|
||||
min_samples: u32,
|
||||
max_variance_percent: f64,
|
||||
|
|
@ -19,6 +27,86 @@ pub const DurationStrategy = struct {
|
|||
}
|
||||
};
|
||||
|
||||
pub const FastStabilityStrategy = struct {
|
||||
criteria: FastStabilityCriteria,
|
||||
min_duration_ns: u64,
|
||||
max_duration_ns: u64,
|
||||
speed_measurements: std.ArrayList(SpeedMeasurement),
|
||||
last_sample_time: u64 = 0,
|
||||
last_total_bytes: u64 = 0,
|
||||
|
||||
const SpeedMeasurement = struct {
|
||||
speed: f64,
|
||||
time: u64,
|
||||
};
|
||||
|
||||
pub fn init(allocator: std.mem.Allocator, criteria: FastStabilityCriteria) FastStabilityStrategy {
|
||||
return FastStabilityStrategy{
|
||||
.criteria = criteria,
|
||||
.min_duration_ns = @as(u64, criteria.min_duration_seconds) * std.time.ns_per_s,
|
||||
.max_duration_ns = @as(u64, criteria.max_duration_seconds) * std.time.ns_per_s,
|
||||
.speed_measurements = std.ArrayList(SpeedMeasurement).init(allocator),
|
||||
};
|
||||
}
|
||||
|
||||
pub fn deinit(self: *FastStabilityStrategy) void {
|
||||
self.speed_measurements.deinit();
|
||||
}
|
||||
|
||||
pub fn shouldContinue(self: FastStabilityStrategy, current_time: u64) bool {
|
||||
return current_time < self.max_duration_ns;
|
||||
}
|
||||
|
||||
pub fn getSleepInterval(self: FastStabilityStrategy) u64 {
|
||||
_ = self;
|
||||
return std.time.ns_per_ms * 150; // Fast.com uses 150ms
|
||||
}
|
||||
|
||||
pub fn shouldSample(self: *FastStabilityStrategy, current_time: u64) bool {
|
||||
return current_time - self.last_sample_time >= std.time.ns_per_s;
|
||||
}
|
||||
|
||||
pub fn addSample(self: *FastStabilityStrategy, current_time: u64, current_total_bytes: u64) !bool {
|
||||
// Skip first sample
|
||||
if (self.last_sample_time > 0) {
|
||||
const bytes_diff = current_total_bytes - self.last_total_bytes;
|
||||
const time_diff_s = @as(f64, @floatFromInt(current_time - self.last_sample_time)) / std.time.ns_per_s;
|
||||
const current_speed = @as(f64, @floatFromInt(bytes_diff)) / time_diff_s;
|
||||
|
||||
try self.speed_measurements.append(SpeedMeasurement{
|
||||
.speed = current_speed,
|
||||
.time = current_time,
|
||||
});
|
||||
|
||||
// Apply Fast.com stability logic
|
||||
if (current_time >= self.min_duration_ns) {
|
||||
if (self.speed_measurements.items.len >= self.criteria.min_stable_measurements) {
|
||||
if (isFastStable(
|
||||
self.speed_measurements.items,
|
||||
current_speed,
|
||||
self.criteria.stability_delta_percent,
|
||||
self.criteria.min_stable_measurements,
|
||||
)) {
|
||||
return true; // Stable, can stop
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
self.last_sample_time = current_time;
|
||||
self.last_total_bytes = current_total_bytes;
|
||||
return false; // Not stable yet
|
||||
}
|
||||
|
||||
pub fn handleProgress(self: *FastStabilityStrategy, current_time: u64, current_bytes: u64) !bool {
|
||||
if (self.shouldSample(current_time)) {
|
||||
return try self.addSample(current_time, current_bytes);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
||||
// Keep old strategy for backward compatibility
|
||||
pub const StabilityStrategy = struct {
|
||||
criteria: StabilityCriteria,
|
||||
max_duration_ns: u64,
|
||||
|
|
@ -81,6 +169,39 @@ pub const StabilityStrategy = struct {
|
|||
}
|
||||
};
|
||||
|
||||
/// Simplified stability detection using recent measurements
|
||||
fn isFastStable(
|
||||
measurements: []const FastStabilityStrategy.SpeedMeasurement,
|
||||
current_speed: f64,
|
||||
stability_delta_percent: f64,
|
||||
min_stable_measurements: u32,
|
||||
) bool {
|
||||
if (measurements.len < min_stable_measurements) return false;
|
||||
if (current_speed == 0) return false;
|
||||
|
||||
// Check if recent measurements are within delta threshold
|
||||
const window_size = @min(measurements.len, min_stable_measurements);
|
||||
const recent_start = measurements.len - window_size;
|
||||
|
||||
// Calculate average of recent measurements
|
||||
var speed_sum: f64 = 0;
|
||||
for (measurements[recent_start..]) |measurement| {
|
||||
speed_sum += measurement.speed;
|
||||
}
|
||||
const avg_speed = speed_sum / @as(f64, @floatFromInt(window_size));
|
||||
|
||||
// Check if all recent measurements are within threshold of average
|
||||
for (measurements[recent_start..]) |measurement| {
|
||||
const deviation_percent = @abs(measurement.speed - avg_speed) / avg_speed * 100.0;
|
||||
if (deviation_percent > stability_delta_percent) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/// Legacy variance-based stability detection (for backward compatibility)
|
||||
fn isStable(samples: []const f64, max_variance_percent: f64) bool {
|
||||
if (samples.len < 2) return false;
|
||||
|
||||
|
|
@ -116,6 +237,10 @@ pub fn createDurationStrategy(duration_seconds: u32, progress_update_interval_ms
|
|||
};
|
||||
}
|
||||
|
||||
pub fn createFastStabilityStrategy(allocator: std.mem.Allocator, criteria: FastStabilityCriteria) FastStabilityStrategy {
|
||||
return FastStabilityStrategy.init(allocator, criteria);
|
||||
}
|
||||
|
||||
pub fn createStabilityStrategy(allocator: std.mem.Allocator, criteria: StabilityCriteria) StabilityStrategy {
|
||||
return StabilityStrategy.init(allocator, criteria);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3,6 +3,7 @@ const testing = std.testing;
|
|||
const measurement_strategy = @import("../measurement_strategy.zig");
|
||||
const MeasurementStrategy = measurement_strategy.MeasurementStrategy;
|
||||
const StabilityCriteria = measurement_strategy.StabilityCriteria;
|
||||
const FastStabilityCriteria = measurement_strategy.FastStabilityCriteria;
|
||||
const BandwidthMeter = @import("../bandwidth.zig").BandwidthMeter;
|
||||
|
||||
test "createDurationStrategy" {
|
||||
|
|
@ -130,3 +131,325 @@ test "StabilityStrategy addSample basic functionality" {
|
|||
try testing.expect(strategy.speed_samples.items.len == 2);
|
||||
// Result depends on variance calculation, but should not crash
|
||||
}
|
||||
|
||||
// Fast.com-style stability tests
|
||||
|
||||
test "FastStabilityCriteria default values" {
|
||||
const criteria = FastStabilityCriteria{};
|
||||
|
||||
try testing.expect(criteria.min_duration_seconds == 7);
|
||||
try testing.expect(criteria.max_duration_seconds == 30);
|
||||
try testing.expect(criteria.stability_delta_percent == 2.0);
|
||||
try testing.expect(criteria.min_stable_measurements == 6);
|
||||
}
|
||||
|
||||
test "createFastStabilityStrategy" {
|
||||
const criteria = FastStabilityCriteria{
|
||||
.min_duration_seconds = 10,
|
||||
.max_duration_seconds = 25,
|
||||
.stability_delta_percent = 3.0,
|
||||
.min_stable_measurements = 8,
|
||||
};
|
||||
|
||||
var strategy = measurement_strategy.createFastStabilityStrategy(testing.allocator, criteria);
|
||||
defer strategy.deinit();
|
||||
|
||||
try testing.expect(strategy.criteria.min_duration_seconds == 10);
|
||||
try testing.expect(strategy.criteria.max_duration_seconds == 25);
|
||||
try testing.expect(strategy.criteria.stability_delta_percent == 3.0);
|
||||
try testing.expect(strategy.criteria.min_stable_measurements == 8);
|
||||
try testing.expect(strategy.min_duration_ns == 10 * std.time.ns_per_s);
|
||||
try testing.expect(strategy.max_duration_ns == 25 * std.time.ns_per_s);
|
||||
}
|
||||
|
||||
test "FastStabilityStrategy shouldContinue" {
|
||||
const criteria = FastStabilityCriteria{
|
||||
.max_duration_seconds = 20,
|
||||
};
|
||||
|
||||
var strategy = measurement_strategy.createFastStabilityStrategy(testing.allocator, criteria);
|
||||
defer strategy.deinit();
|
||||
|
||||
// Should continue before max duration
|
||||
try testing.expect(strategy.shouldContinue(15 * std.time.ns_per_s));
|
||||
|
||||
// Should not continue after max duration
|
||||
try testing.expect(!strategy.shouldContinue(25 * std.time.ns_per_s));
|
||||
}
|
||||
|
||||
test "FastStabilityStrategy getSleepInterval" {
|
||||
const criteria = FastStabilityCriteria{};
|
||||
var strategy = measurement_strategy.createFastStabilityStrategy(testing.allocator, criteria);
|
||||
defer strategy.deinit();
|
||||
|
||||
// Should use Fast.com's 150ms interval
|
||||
try testing.expect(strategy.getSleepInterval() == 150 * std.time.ns_per_ms);
|
||||
}
|
||||
|
||||
test "FastStabilityStrategy shouldSample timing" {
|
||||
const criteria = FastStabilityCriteria{};
|
||||
var strategy = measurement_strategy.createFastStabilityStrategy(testing.allocator, criteria);
|
||||
defer strategy.deinit();
|
||||
|
||||
// First call should not sample (last_sample_time is 0)
|
||||
try testing.expect(!strategy.shouldSample(0));
|
||||
|
||||
// Should not sample if less than 1 second has passed
|
||||
strategy.last_sample_time = 500 * std.time.ns_per_ms; // 0.5 seconds
|
||||
try testing.expect(!strategy.shouldSample(800 * std.time.ns_per_ms)); // 0.8 seconds
|
||||
|
||||
// Should sample if 1 second or more has passed
|
||||
try testing.expect(strategy.shouldSample(1600 * std.time.ns_per_ms)); // 1.6 seconds
|
||||
}
|
||||
|
||||
test "FastStabilityStrategy addSample basic functionality" {
|
||||
const criteria = FastStabilityCriteria{
|
||||
.min_duration_seconds = 1, // Short for testing
|
||||
.min_stable_measurements = 3,
|
||||
.stability_delta_percent = 50.0, // High threshold to avoid early stability
|
||||
};
|
||||
|
||||
var strategy = measurement_strategy.createFastStabilityStrategy(testing.allocator, criteria);
|
||||
defer strategy.deinit();
|
||||
|
||||
// First sample should be skipped
|
||||
const is_stable1 = try strategy.addSample(1 * std.time.ns_per_s, 1000);
|
||||
try testing.expect(!is_stable1);
|
||||
try testing.expect(strategy.speed_measurements.items.len == 0);
|
||||
|
||||
// Second sample should be added
|
||||
const is_stable2 = try strategy.addSample(2 * std.time.ns_per_s, 2000);
|
||||
try testing.expect(!is_stable2); // Not stable yet, need min_stable_measurements
|
||||
try testing.expect(strategy.speed_measurements.items.len == 1);
|
||||
|
||||
// Third sample should be added
|
||||
const is_stable3 = try strategy.addSample(3 * std.time.ns_per_s, 3000);
|
||||
try testing.expect(!is_stable3); // Still need more measurements
|
||||
try testing.expect(strategy.speed_measurements.items.len == 2);
|
||||
|
||||
// Fourth sample should trigger stability check (we have 3 measurements now)
|
||||
_ = try strategy.addSample(4 * std.time.ns_per_s, 4000);
|
||||
try testing.expect(strategy.speed_measurements.items.len == 3);
|
||||
}
|
||||
|
||||
test "FastStabilityStrategy requires minimum duration" {
|
||||
const criteria = FastStabilityCriteria{
|
||||
.min_duration_seconds = 10,
|
||||
.min_stable_measurements = 2,
|
||||
.stability_delta_percent = 1.0, // Low threshold for easy stability
|
||||
};
|
||||
|
||||
var strategy = measurement_strategy.createFastStabilityStrategy(testing.allocator, criteria);
|
||||
defer strategy.deinit();
|
||||
|
||||
// Add samples before minimum duration - should not be stable
|
||||
_ = try strategy.addSample(1 * std.time.ns_per_s, 1000);
|
||||
_ = try strategy.addSample(2 * std.time.ns_per_s, 2000);
|
||||
const is_stable_early = try strategy.addSample(3 * std.time.ns_per_s, 3000);
|
||||
try testing.expect(!is_stable_early); // Should not be stable before min duration
|
||||
|
||||
// Add sample after minimum duration - might be stable
|
||||
_ = try strategy.addSample(11 * std.time.ns_per_s, 11000);
|
||||
// Result depends on stability calculation, but should not crash
|
||||
}
|
||||
|
||||
test "FastStabilityStrategy handleProgress integration" {
|
||||
const criteria = FastStabilityCriteria{
|
||||
.min_duration_seconds = 2,
|
||||
.min_stable_measurements = 2,
|
||||
.stability_delta_percent = 10.0,
|
||||
};
|
||||
|
||||
var strategy = measurement_strategy.createFastStabilityStrategy(testing.allocator, criteria);
|
||||
defer strategy.deinit();
|
||||
|
||||
// Should not trigger sampling immediately
|
||||
const should_stop1 = try strategy.handleProgress(500 * std.time.ns_per_ms, 500);
|
||||
try testing.expect(!should_stop1);
|
||||
|
||||
// Should not trigger sampling if less than 1 second elapsed
|
||||
const should_stop2 = try strategy.handleProgress(800 * std.time.ns_per_ms, 800);
|
||||
try testing.expect(!should_stop2);
|
||||
|
||||
// Should trigger sampling after 1 second
|
||||
_ = try strategy.handleProgress(1500 * std.time.ns_per_ms, 1500);
|
||||
try testing.expect(strategy.speed_measurements.items.len == 0); // First sample skipped
|
||||
|
||||
// Should add second sample
|
||||
_ = try strategy.handleProgress(2500 * std.time.ns_per_ms, 2500);
|
||||
try testing.expect(strategy.speed_measurements.items.len == 1);
|
||||
}
|
||||
|
||||
test "Fast.com delta stability detection algorithm" {
|
||||
const criteria = FastStabilityCriteria{
|
||||
.min_duration_seconds = 1, // Short for testing
|
||||
.min_stable_measurements = 4,
|
||||
.stability_delta_percent = 5.0, // 5% deviation threshold
|
||||
};
|
||||
|
||||
var strategy = measurement_strategy.createFastStabilityStrategy(testing.allocator, criteria);
|
||||
defer strategy.deinit();
|
||||
|
||||
// Add samples that should be stable (within 5% of each other)
|
||||
_ = try strategy.addSample(1 * std.time.ns_per_s, 1000); // Skip first
|
||||
_ = try strategy.addSample(2 * std.time.ns_per_s, 2000); // 1000 bytes/s
|
||||
_ = try strategy.addSample(3 * std.time.ns_per_s, 3050); // 1050 bytes/s (5% higher)
|
||||
_ = try strategy.addSample(4 * std.time.ns_per_s, 4000); // 950 bytes/s (5% lower)
|
||||
|
||||
// This should be stable since all speeds are within 5% of 1000 bytes/s
|
||||
const is_stable = try strategy.addSample(5 * std.time.ns_per_s, 5000); // 1000 bytes/s
|
||||
|
||||
// Should be stable with consistent speeds
|
||||
try testing.expect(is_stable);
|
||||
}
|
||||
|
||||
test "Fast.com delta stability detection - unstable case" {
|
||||
const criteria = FastStabilityCriteria{
|
||||
.min_duration_seconds = 1, // Short for testing
|
||||
.min_stable_measurements = 3,
|
||||
.stability_delta_percent = 2.0, // Strict 2% threshold
|
||||
};
|
||||
|
||||
var strategy = measurement_strategy.createFastStabilityStrategy(testing.allocator, criteria);
|
||||
defer strategy.deinit();
|
||||
|
||||
// Add samples that should NOT be stable (outside 2% threshold)
|
||||
_ = try strategy.addSample(1 * std.time.ns_per_s, 1000); // Skip first
|
||||
_ = try strategy.addSample(2 * std.time.ns_per_s, 2000); // 1000 bytes/s
|
||||
_ = try strategy.addSample(3 * std.time.ns_per_s, 3100); // 1100 bytes/s (10% higher)
|
||||
|
||||
// This should NOT be stable due to large deviation
|
||||
const is_stable = try strategy.addSample(4 * std.time.ns_per_s, 4000); // 900 bytes/s (10% lower)
|
||||
|
||||
// Should not be stable with inconsistent speeds
|
||||
try testing.expect(!is_stable);
|
||||
}
|
||||
|
||||
test "Fast.com stability requires measurements after max speed" {
|
||||
const criteria = FastStabilityCriteria{
|
||||
.min_duration_seconds = 1,
|
||||
.min_stable_measurements = 6,
|
||||
.stability_delta_percent = 5.0,
|
||||
};
|
||||
|
||||
var strategy = measurement_strategy.createFastStabilityStrategy(testing.allocator, criteria);
|
||||
defer strategy.deinit();
|
||||
|
||||
// Add samples with a peak in the middle, then lower speeds
|
||||
_ = try strategy.addSample(1 * std.time.ns_per_s, 1000); // Skip first
|
||||
_ = try strategy.addSample(2 * std.time.ns_per_s, 2000); // 1000 bytes/s
|
||||
_ = try strategy.addSample(3 * std.time.ns_per_s, 4000); // 2000 bytes/s (peak)
|
||||
_ = try strategy.addSample(4 * std.time.ns_per_s, 5000); // 1000 bytes/s (back down)
|
||||
_ = try strategy.addSample(5 * std.time.ns_per_s, 6000); // 1000 bytes/s
|
||||
|
||||
// Should not be stable yet - need more measurements after the peak
|
||||
const is_stable = try strategy.addSample(6 * std.time.ns_per_s, 7000); // 1000 bytes/s
|
||||
|
||||
// Fast.com algorithm should detect this pattern and require more stability
|
||||
// Either not stable yet OR we have collected enough measurements to make a decision
|
||||
if (is_stable) {
|
||||
try testing.expect(strategy.speed_measurements.items.len >= 6);
|
||||
}
|
||||
// Test should not crash and should have collected measurements
|
||||
try testing.expect(strategy.speed_measurements.items.len > 0);
|
||||
}
|
||||
|
||||
test "Fast.com API integration with legacy API" {
|
||||
// Test that both old and new APIs can coexist
|
||||
const old_criteria = StabilityCriteria{
|
||||
.min_samples = 5,
|
||||
.max_variance_percent = 10.0,
|
||||
.max_duration_seconds = 30,
|
||||
};
|
||||
|
||||
const new_criteria = FastStabilityCriteria{
|
||||
.min_duration_seconds = 7,
|
||||
.max_duration_seconds = 30,
|
||||
.stability_delta_percent = 2.0,
|
||||
.min_stable_measurements = 6,
|
||||
};
|
||||
|
||||
var old_strategy = measurement_strategy.createStabilityStrategy(testing.allocator, old_criteria);
|
||||
defer old_strategy.deinit();
|
||||
|
||||
var new_strategy = measurement_strategy.createFastStabilityStrategy(testing.allocator, new_criteria);
|
||||
defer new_strategy.deinit();
|
||||
|
||||
// Both should compile and initialize without conflicts
|
||||
try testing.expect(old_strategy.criteria.min_samples == 5);
|
||||
try testing.expect(new_strategy.criteria.min_stable_measurements == 6);
|
||||
}
|
||||
|
||||
test "Fast.com stability detection realistic scenario" {
|
||||
const criteria = FastStabilityCriteria{
|
||||
.min_duration_seconds = 5,
|
||||
.max_duration_seconds = 20,
|
||||
.stability_delta_percent = 2.0, // Fast.com's 2% threshold
|
||||
.min_stable_measurements = 6, // Fast.com's requirement
|
||||
};
|
||||
|
||||
var strategy = measurement_strategy.createFastStabilityStrategy(testing.allocator, criteria);
|
||||
defer strategy.deinit();
|
||||
|
||||
// Simulate realistic speed test progression: ramp up, then stabilize
|
||||
_ = try strategy.addSample(1 * std.time.ns_per_s, 1000); // Skip first
|
||||
_ = try strategy.addSample(2 * std.time.ns_per_s, 3000); // 2000 bytes/s (ramp up)
|
||||
_ = try strategy.addSample(3 * std.time.ns_per_s, 6000); // 3000 bytes/s (still ramping)
|
||||
|
||||
// Before min duration - should not be stable regardless of measurements
|
||||
const stable_before_min = try strategy.addSample(4 * std.time.ns_per_s, 10000); // 4000 bytes/s (peak)
|
||||
try testing.expect(!stable_before_min);
|
||||
|
||||
// After min duration with stable measurements
|
||||
_ = try strategy.addSample(6 * std.time.ns_per_s, 16000); // 4000 bytes/s (stable)
|
||||
_ = try strategy.addSample(7 * std.time.ns_per_s, 20000); // 4000 bytes/s (stable)
|
||||
_ = try strategy.addSample(8 * std.time.ns_per_s, 24000); // 4000 bytes/s (stable)
|
||||
const stable_after_min = try strategy.addSample(9 * std.time.ns_per_s, 28000); // 4000 bytes/s (stable)
|
||||
|
||||
// Should be able to detect stability after minimum duration with consistent speeds
|
||||
try testing.expect(stable_after_min or strategy.speed_measurements.items.len >= 6);
|
||||
}
|
||||
|
||||
test "Fast.com timing intervals match specification" {
|
||||
const criteria = FastStabilityCriteria{};
|
||||
var strategy = measurement_strategy.createFastStabilityStrategy(testing.allocator, criteria);
|
||||
defer strategy.deinit();
|
||||
|
||||
// Fast.com uses 150ms progress frequency (vs our old 100ms)
|
||||
try testing.expect(strategy.getSleepInterval() == 150 * std.time.ns_per_ms);
|
||||
|
||||
// Should enforce 1-second sampling intervals like Fast.com
|
||||
try testing.expect(!strategy.shouldSample(0));
|
||||
strategy.last_sample_time = 500 * std.time.ns_per_ms;
|
||||
try testing.expect(!strategy.shouldSample(999 * std.time.ns_per_ms));
|
||||
try testing.expect(strategy.shouldSample(1500 * std.time.ns_per_ms));
|
||||
}
|
||||
|
||||
test "Fast.com delta algorithm handles edge cases correctly" {
|
||||
const criteria = FastStabilityCriteria{
|
||||
.min_duration_seconds = 1,
|
||||
.min_stable_measurements = 3,
|
||||
.stability_delta_percent = 5.0,
|
||||
};
|
||||
|
||||
var strategy = measurement_strategy.createFastStabilityStrategy(testing.allocator, criteria);
|
||||
defer strategy.deinit();
|
||||
|
||||
// Test very small speed changes (edge case for percentage calculation)
|
||||
_ = try strategy.addSample(1 * std.time.ns_per_s, 1000); // Skip first
|
||||
_ = try strategy.addSample(2 * std.time.ns_per_s, 1001); // 1 byte/s
|
||||
_ = try strategy.addSample(3 * std.time.ns_per_s, 1002); // 1 byte/s
|
||||
const stable_small = try strategy.addSample(4 * std.time.ns_per_s, 1003); // 1 byte/s
|
||||
|
||||
// Should handle small speeds without division errors
|
||||
_ = stable_small; // May or may not be stable, but shouldn't crash
|
||||
|
||||
// Test zero speed edge case
|
||||
strategy.speed_measurements.clearRetainingCapacity();
|
||||
strategy.last_sample_time = 0;
|
||||
_ = try strategy.addSample(1 * std.time.ns_per_s, 1000); // Skip first
|
||||
const stable_zero = try strategy.addSample(2 * std.time.ns_per_s, 1000); // 0 bytes/s
|
||||
|
||||
// Zero speed should not be considered stable
|
||||
try testing.expect(!stable_zero);
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue