6502/CLK
1
0
Fork 0
mirror of https://github.com/TomHarte/CLK.git synced 2024-12-25 03:32:01 +00:00
Code Issues Projects Releases Wiki Activity

Makes minor Vic-20 optimisations.

Browse Source 
Specifically: the 6560 is updated only upon writes (more nuance can arrive), and tape sleeps are observed.
This commit is contained in:
Thomas Harte 2018-03-27 21:52:52 -04:00
parent b7ff5ef9dd
commit ec353ce663
1 changed files with 23 additions and 20 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

43
Machines/Commodore/Vic-20/Vic20.cpp
View File

@ -299,7 +299,8 @@ class ConcreteMachine:
public MOS::MOS6522::IRQDelegatePortHandler::Delegate,
public Utility::TypeRecipient,
public Storage::Tape::BinaryTapePlayer::Delegate,
public Machine {
public Machine,
public Sleeper::SleepObserver {
public:
ConcreteMachine() :
m6502_(*this),
@ -325,15 +326,12 @@ class ConcreteMachine:
user_port_via_port_handler_->set_interrupt_delegate(this);
keyboard_via_port_handler_->set_interrupt_delegate(this);
tape_->set_delegate(this);
tape_->set_sleep_observer(this);
// install a joystick
joysticks_.emplace_back(new Joystick(*user_port_via_port_handler_, *keyboard_via_port_handler_));
}
~ConcreteMachine() {
delete[] rom_;
}
// Obtains the system ROMs.
bool set_rom_fetcher(const std::function<std::vector<std::unique_ptr<std::vector<uint8_t>>>(const std::string &machine, const std::vector<std::string> &names)> &roms_with_names) override {
rom_fetcher_ = roms_with_names;
@ -405,9 +403,8 @@ class ConcreteMachine:
std::vector<uint8_t> rom_image = media.cartridges.front()->get_segments().front().data;
rom_length_ = static_cast<uint16_t>(rom_image.size());
rom_ = new uint8_t[0x2000];
std::memcpy(rom_, rom_image.data(), rom_image.size());
write_to_map(processor_read_memory_map_, rom_, rom_address_, 0x2000);
rom_ = rom_image;
rom_.resize(0x2000);
}
set_use_fast_tape();
@ -517,15 +514,15 @@ class ConcreteMachine:
write_to_map(processor_read_memory_map_, roms_[kernel_rom].data(), 0xe000, static_cast<uint16_t>(roms_[kernel_rom].size()));
// install the inserted ROM if there is one
if(rom_) {
write_to_map(processor_read_memory_map_, rom_, rom_address_, rom_length_);
if(!rom_.empty()) {
write_to_map(processor_read_memory_map_, rom_.data(), rom_address_, rom_length_);
}
}
// to satisfy CPU::MOS6502::Processor
forceinline Cycles perform_bus_operation(CPU::MOS6502::BusOperation operation, uint16_t address, uint8_t *value) {
// run the phase-1 part of this cycle, in which the VIC accesses memory
if(!is_running_at_zero_cost_) mos6560_->run_for(Cycles(1));
cycles_since_mos6560_update_++;
// run the phase-2 part of the cycle, which is whatever the 6502 said it should be
if(isReadOperation(operation)) {
@ -537,10 +534,7 @@ class ConcreteMachine:
}
*value = result;
// This combined with the stuff below constitutes the fast tape hack. Performed here: if the
// PC hits the start of the loop that just waits for an interesting tape interrupt to have
// occurred then skip both 6522s and the tape ahead to the next interrupt without any further
// CPU or 6560 costs.
// Consider applying the fast tape hack.
if(use_fast_tape_hack_ && operation == CPU::MOS6502::BusOperation::ReadOpcode) {
if(address == 0xf7b2) {
// Address 0xf7b2 contains a JSR to 0xf8c0 that will fill the tape buffer with the next header.
@ -601,6 +595,8 @@ class ConcreteMachine:
}
}
} else {
mos6560_->run_for(cycles_since_mos6560_update_.flush());
uint8_t *ram = processor_write_memory_map_[address >> 10];
if(ram) ram[address & 0x3ff] = *value;
if((address&0xfc00) == 0x9000) {
@ -618,13 +614,14 @@ class ConcreteMachine:
typer_.reset();
}
}
tape_->run_for(Cycles(1));
if(!tape_is_sleeping_) tape_->run_for(Cycles(1));
if(c1540_) c1540_->run_for(Cycles(1));
return Cycles(1);
}
forceinline void flush() {
void flush() {
mos6560_->run_for(cycles_since_mos6560_update_.flush());
mos6560_->flush();
}
@ -694,6 +691,11 @@ class ConcreteMachine:
return selection_set;
}
void set_component_is_sleeping(void *component, bool is_sleeping) override {
tape_is_sleeping_ = is_sleeping;
set_use_fast_tape();
}
private:
Analyser::Static::Commodore::Target commodore_target_;
@ -706,7 +708,7 @@ class ConcreteMachine:
std::vector<uint8_t> kernel_rom_;
uint8_t expansion_ram_[0x8000];
uint8_t *rom_ = nullptr;
std::vector<uint8_t> rom_;
uint16_t rom_address_, rom_length_;
uint8_t user_basic_memory_[0x0400];
@ -730,6 +732,7 @@ class ConcreteMachine:
Commodore::Vic20::KeyboardMapper keyboard_mapper_;
std::vector<std::unique_ptr<Inputs::Joystick>> joysticks_;
Cycles cycles_since_mos6560_update_;
std::unique_ptr<Vic6560> mos6560_;
std::shared_ptr<UserPortVIA> user_port_via_port_handler_;
std::shared_ptr<KeyboardVIA> keyboard_via_port_handler_;
@ -743,9 +746,9 @@ class ConcreteMachine:
std::shared_ptr<Storage::Tape::BinaryTapePlayer> tape_;
bool use_fast_tape_hack_ = false;
bool allow_fast_tape_hack_ = false;
bool is_running_at_zero_cost_ = false;
bool tape_is_sleeping_ = true;
void set_use_fast_tape() {
use_fast_tape_hack_ = allow_fast_tape_hack_ && tape_->has_tape();
use_fast_tape_hack_ = !tape_is_sleeping_ && allow_fast_tape_hack_ && tape_->has_tape();
}
// Disk