6502/CLK
1
0
Fork 0
mirror of https://github.com/TomHarte/CLK.git synced 2025-07-25 13:24:23 +00:00
Code Issues Projects Releases Wiki Activity

Converts Time::get into a template, introduces a via-a-double fallback for the timed event loop.

Browse Source
This commit is contained in:
Thomas Harte
2018-04-25 19:54:39 -04:00
parent b4f6dee954
commit 4c6dc597f4
11 changed files with 36 additions and 22 deletions
Download Patch File Download Diff File Expand all files Collapse all files

31
Storage/TimedEventLoop.cpp
View File

@@ -64,7 +64,9 @@ void TimedEventLoop::jump_to_next_event() {
}
void TimedEventLoop::set_next_event_time_interval(Time interval) {
// Calculate [interval]*[input clock rate] + [subcycles until this event].
// Calculate [interval]*[input clock rate] + [subcycles until this event]
// = interval.numerator * input clock / interval.denominator + subcycles.numerator / subcycles.denominator
// = (interval.numerator * input clock * subcycles.denominator + subcycles.numerator * interval.denominator) / (interval.denominator * subcycles.denominator)
int64_t denominator = static_cast<int64_t>(interval.clock_rate) * static_cast<int64_t>(subcycles_until_event_.clock_rate);
int64_t numerator =
static_cast<int64_t>(subcycles_until_event_.clock_rate) * static_cast<int64_t>(input_clock_rate_) * static_cast<int64_t>(interval.length) +
@@ -72,7 +74,7 @@ void TimedEventLoop::set_next_event_time_interval(Time interval) {
// Simplify if necessary: try just simplifying the interval and recalculating; if that doesn't
// work then try simplifying the whole thing.
if(numerator < 0 || denominator < 0 || denominator > std::numeric_limits<unsigned int>::max()) {
if(numerator < 0 || denominator < 0 || denominator > std::numeric_limits<int>::max()) {
interval.simplify();
denominator = static_cast<int64_t>(interval.clock_rate) * static_cast<int64_t>(subcycles_until_event_.clock_rate);
numerator =
@@ -80,19 +82,36 @@ void TimedEventLoop::set_next_event_time_interval(Time interval) {
static_cast<int64_t>(interval.clock_rate) * static_cast<int64_t>(subcycles_until_event_.length);
}
if(numerator < 0 || denominator < 0 || denominator > std::numeric_limits<unsigned int>::max()) {
if(numerator < 0 || denominator < 0 || denominator > std::numeric_limits<int>::max()) {
int64_t common_divisor = NumberTheory::greatest_common_divisor(numerator % denominator, denominator);
denominator /= common_divisor;
numerator /= common_divisor;
}
// TODO: if that doesn't work then reduce precision.
// If even that doesn't work then reduce precision.
if(numerator < 0 || denominator < 0 || denominator > std::numeric_limits<int>::max()) {
const double double_interval = interval.get<double>();
const double double_subcycles_remaining = subcycles_until_event_.get<double>();
const double output = double_interval * static_cast<double>(input_clock_rate_) + double_subcycles_remaining;
if(output < 1.0) {
denominator = std::numeric_limits<int>::max();
numerator = static_cast<int>(denominator * output);
} else {
numerator = std::numeric_limits<int>::max();
denominator = static_cast<int>(numerator / output);
}
}
// So this event will fire in the integral number of cycles from now, putting us at the remainder
// number of subcycles
const int addition = static_cast<int>(numerator / denominator);
assert(cycles_until_event_ == 0);
cycles_until_event_ += static_cast<int>(numerator / denominator);
assert(cycles_until_event_ >= 0);
assert(addition >= 0);
if(addition < 0) {
assert(false);
}
cycles_until_event_ += addition;
subcycles_until_event_.length = static_cast<unsigned int>(numerator % denominator);
subcycles_until_event_.clock_rate = static_cast<unsigned int>(denominator);
subcycles_until_event_.simplify();