Commodore64: More progress on experimental framework plus a small speedup in the current framework.

BizHawk.Emulation/BizHawk.Emulation.csproj

@@ -107,6 +107,7 @@
     <Compile Include="Computers\Commodore64\Experimental\Chips\Internals\Sid.SoundProvider.cs" />
     <Compile Include="Computers\Commodore64\Experimental\Chips\Internals\Userport.cs" />
     <Compile Include="Computers\Commodore64\Experimental\Chips\Internals\Vic.VideoProvider.cs" />
+    <Compile Include="Computers\Commodore64\Experimental\Chips\MOS6581.cs" />
     <Compile Include="Computers\Commodore64\Experimental\IMotherboard.cs" />
     <Compile Include="Computers\Commodore64\Experimental\Chips\Internals\Cpu.Interface.cs" />
     <Compile Include="Computers\Commodore64\Experimental\Chips\Internals\Cpu.Internal.cs" />

BizHawk.Emulation/Computers/Commodore64/C64.cs

@@ -7,7 +7,7 @@ namespace BizHawk.Emulation.Computers.Commodore64
 {
 	public partial class  C64 : IEmulator
 	{
-		private uint cyclesPerFrame;
+		private int cyclesPerFrame;
 		private string extension;
 		private byte[] inputFile;
 
@@ -17,7 +17,7 @@ namespace BizHawk.Emulation.Computers.Commodore64
 			inputFile = rom;
 			extension = romextension;
 			Init(Region.PAL);
-			cyclesPerFrame = (uint)board.vic.CyclesPerFrame;
+			cyclesPerFrame = board.vic.CyclesPerFrame;
 			CoreComm.UsesDriveLed = true;
 			SetupMemoryDomains();
 		}
@@ -110,7 +110,7 @@ namespace BizHawk.Emulation.Computers.Commodore64
 
             board.inputRead = false;
 			board.PollInput();
-			for (uint count = cyclesPerFrame; count > 0; count--)
+			for (int count = cyclesPerFrame; count > 0; count--)
 			{
 				//disk.Execute();
 				board.Execute();

BizHawk.Emulation/Computers/Commodore64/Experimental/C64.Glue.cs

@@ -16,7 +16,6 @@ namespace BizHawk.Emulation.Computers.Commodore64.Experimental
             characterRom.InputData = ReadData;
 
             cia1.InputAddress = ReadAddress;
-            cia1.InputClock = vic.OutputPHI0;
             cia1.InputCNT = user.OutputCNT1;
             cia1.InputData = ReadData;
             cia1.InputFlag = ReadCia1Flag;
@@ -27,7 +26,6 @@ namespace BizHawk.Emulation.Computers.Commodore64.Experimental
             cia1.InputSP = user.OutputSP1;
 
             cia2.InputAddress = ReadAddress;
-            cia2.InputClock = vic.OutputPHI0;
             cia2.InputCNT = user.OutputCNT2;
             cia2.InputData = ReadData;
             cia2.InputFlag = user.OutputFLAG2;
@@ -43,7 +41,6 @@ namespace BizHawk.Emulation.Computers.Commodore64.Experimental
 
             cpu.InputAddress = ReadAddress;
             cpu.InputAEC = vic.OutputAEC;
-            cpu.InputClock = vic.OutputPHI0;
             cpu.InputData = ReadData;
             cpu.InputIRQ = ReadIRQ;
             cpu.InputNMI = ReadNMI;
@@ -54,7 +51,6 @@ namespace BizHawk.Emulation.Computers.Commodore64.Experimental
             expansion.InputAddress = ReadAddress;
             expansion.InputBA = vic.OutputBA;
             expansion.InputData = ReadData;
-            expansion.InputDotClock = vic.OutputPixelClock;
             expansion.InputHiExpansion = ReadHiExpansion;
             expansion.InputHiRom = pla.OutputRomHi;
             expansion.InputIRQ = ReadIRQ;
@@ -160,27 +156,68 @@ namespace BizHawk.Emulation.Computers.Commodore64.Experimental
 
         int ReadData()
         {
+            int addr = ReadAddress();
             int data = 0xFF;
+
             data &= expansion.Data;
             if (pla.Basic)
+            {
+                basicRom.Precache();
                 data &= basicRom.Data;
+            }
             if (pla.CharRom)
+            {
+                characterRom.Precache();
                 data &= characterRom.Data;
+            }
             if (pla.GraphicsRead)
+            {
+                colorRam.Precache();
                 data &= colorRam.Data;
+            }
             if (pla.IO)
             {
-                data &= cia1.Data;
+                if ((addr & 0x0F00) == 0x0C00)
-                data &= cia2.Data;
+                {
-                data &= sid.Data;
+                    cia1.Precache();
-                data &= vic.Data;
+                    data &= cia1.Data;
+                }
+                if ((addr & 0x0F00) == 0x0D00)
+                {
+                    cia2.Precache();
+                    data &= cia2.Data;
+                }
+                if ((addr & 0x0C00) == 0x0800)
+                {
+                    colorRam.Precache();
+                    data &= colorRam.Data;
+                }
+                if ((addr & 0x0C00) == 0x0400)
+                {
+                    sid.Precache();
+                    data &= sid.Data;
+                }
+                if ((addr & 0x0C00) == 0x0000)
+                {
+                    vic.Precache();
+                    data &= vic.Data;
+                }
             }
             if (vic.BA)
+            {
+                cpu.Precache();
                 data &= cpu.Data;
+            }
             if (pla.Kernal)
+            {
+                kernalRom.Precache();
                 data &= kernalRom.Data;
+            }
             if (pla.CASRam)
+            {
+                memory.Precache();
                 data &= memory.Data;
+            }
             return data;
         }
 

BizHawk.Emulation/Computers/Commodore64/Experimental/C64.cs

@@ -8,24 +8,24 @@ namespace BizHawk.Emulation.Computers.Commodore64.Experimental
 {
     public abstract partial class C64 : IMotherboard
     {
-        Rom basicRom;
+        protected Rom basicRom;
-        Cassette cassette;
+        protected Cassette cassette;
-        Rom characterRom;
+        protected Rom characterRom;
-        Cia cia1;
+        protected Cia cia1;
-        Cia cia2;
+        protected Cia cia2;
-        Ram colorRam;
+        protected Ram colorRam;
-        Cpu cpu;
+        protected Cpu cpu;
-        Expansion expansion;
+        protected Expansion expansion;
-        Joystick joystickA;
+        protected Joystick joystickA;
-        Joystick joystickB;
+        protected Joystick joystickB;
-        Rom kernalRom;
+        protected Rom kernalRom;
-        Keyboard keyboard;
+        protected Keyboard keyboard;
-        Ram memory;
+        protected Ram memory;
-        Pla pla;
+        protected Pla pla;
-        Serial serial;
+        protected Serial serial;
-        Sid sid;
+        protected Sid sid;
-        Userport user;
+        protected Userport user;
-        Vic vic;
+        protected Vic vic;
 
         public C64(C64Timing timing)
         {
@@ -33,6 +33,13 @@ namespace BizHawk.Emulation.Computers.Commodore64.Experimental
 
         public void ExecuteFrame()
         {
+            vic.Clock();
+            vic.Clock();
+            vic.Clock();
+            vic.Clock();
+            vic.Precache();
+            cpu.Clock();
+            cpu.Precache();
         }
 
         public byte PeekBasicRom(int addr)

BizHawk.Emulation/Computers/Commodore64/Experimental/C64NTSC.cs

@@ -1,4 +1,6 @@
-using System;
+using BizHawk.Emulation.Computers.Commodore64.Experimental.Chips;
+using BizHawk.Emulation.Computers.Commodore64.Experimental.Chips.Internals;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
@@ -9,7 +11,7 @@ namespace BizHawk.Emulation.Computers.Commodore64.Experimental
     {
         static private C64Timing timing;
 
-        public C64NTSC() : base(timing)
+        public C64NTSC(byte[] basicRom, byte[] charRom, byte[] kernalRom) : base(timing)
         {
         }
     }

BizHawk.Emulation/Computers/Commodore64/Experimental/C64PAL.cs

@@ -1,4 +1,6 @@
-using System;
+using BizHawk.Emulation.Computers.Commodore64.Experimental.Chips;
+using BizHawk.Emulation.Computers.Commodore64.Experimental.Chips.Internals;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
@@ -11,6 +13,25 @@ namespace BizHawk.Emulation.Computers.Commodore64.Experimental
 
         public C64PAL() : base(timing)
         {
+            this.basicRom = new Rom2364();
+            this.cassette = new Cassette();
+            this.characterRom = new Rom2332();
+            this.cia1 = new Cia();
+            this.cia2 = new Cia();
+            this.colorRam = new Ram2114();
+            this.cpu = new Cpu();
+            this.expansion = new Expansion();
+            this.joystickA = new Joystick();
+            this.joystickB = new Joystick();
+            this.kernalRom = new Rom2364();
+            this.keyboard = new Keyboard();
+            this.memory = new Ram4864();
+            this.pla = new Pla();
+            this.serial = new Serial();
+            this.sid = new MOS6581();
+            this.user = new Userport();
+            this.vic = new MOS6569();
+            InitializeConnections();
         }
     }
 }

BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Cia.Interface.cs

@@ -8,7 +8,6 @@ namespace BizHawk.Emulation.Computers.Commodore64.Experimental.Chips.Internals
     public partial class Cia
     {
         public Func<int> InputAddress;
-        public Func<bool> InputClock;
         public Func<bool> InputCNT;
         public Func<int> InputData;
         public Func<bool> InputFlag;
@@ -18,9 +17,9 @@ namespace BizHawk.Emulation.Computers.Commodore64.Experimental.Chips.Internals
         public Func<bool> InputReset;
         public Func<bool> InputSP;
 
-        virtual public bool CNT { get { return true; } }
+        public bool CNT { get { return true; } }
-        virtual public int Data { get { return 0xFF; } }
+        public int Data { get { return 0xFF; } }
-        virtual public bool IRQ { get { return true; } }
+        public bool IRQ { get { return true; } }
         public bool OutputCNT() { return CNT; }
         public int OutputData() { return Data; }
         public bool OutputIRQ() { return IRQ; }
@@ -28,9 +27,12 @@ namespace BizHawk.Emulation.Computers.Commodore64.Experimental.Chips.Internals
         public int OutputPortA() { return PortA; }
         public int OutputPortB() { return PortB; }
         public bool OutputSP() { return SP; }
-        virtual public bool PC { get { return true; } }
+        public bool PC { get { return true; } }
-        virtual public int PortA { get { return 0xFF; } }
+        public int PortA { get { return 0xFF; } }
-        virtual public int PortB { get { return 0xFF; } }
+        public int PortB { get { return 0xFF; } }
-        virtual public bool SP { get { return true; } }
+        public bool SP { get { return true; } }
+
+        public void Clock() { }
+        public void Precache() { }
     }
 }

BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Cpu.Interface.cs

@@ -5,11 +5,10 @@ using System.Text;
 
 namespace BizHawk.Emulation.Computers.Commodore64.Experimental.Chips.Internals
 {
-    public partial class Cpu
+    sealed public partial class Cpu
     {
         public Func<int> InputAddress;
         public Func<bool> InputAEC;
-        public Func<bool> InputClock;
         public Func<int> InputData;
         public Func<bool> InputIRQ;
         public Func<bool> InputNMI;
@@ -17,15 +16,15 @@ namespace BizHawk.Emulation.Computers.Commodore64.Experimental.Chips.Internals
         public Func<bool> InputRDY;
         public Func<bool> InputReset;
 
-        virtual public int Address { get { return 0xFFFF; } }
+        public int Address { get { return cachedAddress; } }
-        virtual public int Data { get { return 0xFF; } }
+        public int Data { get { return cachedData; } }
         public int OutputAddress() { return Address; }
         public int OutputData() { return Data; }
         public int OutputPort() { return Port; }
         public bool OutputRead() { return Read; }
-        virtual public int Port { get { return 0xFF; } }
+        public int Port { get { return cachedPort; } }
-        virtual public bool Read { get { return true; } }
+        public bool Read { get { return cachedRead; } }
-        virtual public void Precache() { }
+        public void Precache() { }
-        virtual public void SyncState(Serializer ser) { }
+        public void SyncState(Serializer ser) { }
     }
 }

BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Cpu.Internal.cs

@@ -1,11 +1,125 @@
-using System;
+using BizHawk.Emulation.CPUs.M6502;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 
 namespace BizHawk.Emulation.Computers.Commodore64.Experimental.Chips.Internals
 {
-    public partial class Cpu
+    sealed public partial class Cpu
     {
+        int cachedAddress;
+        int cachedData;
+        int cachedPort;
+        bool cachedRead;
+        int delayCycles;
+        int portDirection;
+        int portLatch;
+        MOS6502X processor;
+        bool resetBuffer;
+        bool resetEdge;
+        int resetPC;
+
+        public Cpu()
+        {
+            processor = new MOS6502X();
+            processor.DummyReadMemory = CoreReadMemory;
+            processor.ReadMemory = CoreReadMemory;
+            processor.WriteMemory = CoreWriteMemory;
+            resetBuffer = false;
+            resetEdge = false;
+            cachedAddress = 0xFFFF;
+            cachedData = 0xFF;
+            cachedPort = 0xFF;
+            cachedRead = true;
+        }
+
+        public void Clock()
+        {
+            bool reset = InputReset();
+            if (reset)
+            {
+                if (delayCycles > 0)
+                {
+                    delayCycles--;
+                    if (delayCycles == 1)
+                    {
+                        cachedAddress = 0xFFFC;
+                        resetPC = InputData();
+                    }
+                    else if (delayCycles == 0)
+                    {
+                        cachedAddress = 0xFFFD;
+                        resetPC |= InputData() << 8;
+                        processor.PC = (ushort)resetPC;
+                    }
+                }
+                else
+                {
+                    if (!resetBuffer)
+                    {
+                        // perform these actions on positive edge of /reset
+                        processor.Reset();
+                        processor.BCD_Enabled = true;
+                        processor.PC = (ushort)((CoreReadMemory(0xFFFD) << 8) | CoreReadMemory(0xFFFC));
+                    }
+                    else if (InputAEC())
+                    {
+                        processor.IRQ = !InputIRQ(); //6502 core expects inverted input
+                        processor.NMI = !InputNMI(); //6502 core expects inverted input
+                        processor.RDY = InputRDY();
+                        processor.ExecuteOne();
+                    }
+                }
+            }
+            else
+            {
+                cachedAddress = 0xFFFF;
+                cachedData = 0xFF;
+                delayCycles = 8;
+                portDirection = 0xFF;
+                portLatch = 0xFF;
+            }
+            resetBuffer = reset;
+        }
+
+        byte CoreReadMemory(ushort addr)
+        {
+            cachedAddress = addr;
+            cachedRead = true;
+            if (addr == 0x0000)
+            {
+                cachedData = portDirection;
+            }
+            else if (addr == 0x0001)
+            {
+                cachedData = InputPort() | (portDirection ^ 0xFF);
+            }
+            else
+            {
+                cachedData = InputData();
+            }
+            return (byte)(cachedData & 0xFF);
+        }
+
+        void CoreWriteMemory(ushort addr, byte val)
+        {
+            cachedAddress = addr;
+            cachedData = val;
+            if (addr == 0x0000)
+            {
+                cachedRead = true;
+                portDirection = val;
+            }
+            else if (addr == 0x0001)
+            {
+                cachedRead = true;
+                portLatch = val;
+            }
+            else
+            {
+                cachedRead = false;
+            }
+        }
     }
 }

BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Pla.cs

@@ -8,13 +8,15 @@ namespace BizHawk.Emulation.Computers.Commodore64.Experimental.Chips.Internals
     sealed public class Pla
     {
         #region CACHE
-        bool a12;
+        bool[] basicStates;
-        bool a13;
+        bool[] casStates;
-        bool a14;
+        bool[] charStates;
-        bool a15;
+        bool[] grStates;
-        int addr;
+        bool[] ioStates;
-        bool aec;
+        bool[] kernalStates;
-        bool ba;
+        bool[] romHiStates;
+        bool[] romLoStates;
+
         bool cachedBasic;
         bool cachedCASRam;
         bool cachedCharRom;
@@ -23,48 +25,6 @@ namespace BizHawk.Emulation.Computers.Commodore64.Experimental.Chips.Internals
         bool cachedKernal;
         bool cachedRomHi;
         bool cachedRomLo;
-        bool cas;
-        bool charen;
-        bool exrom;
-        bool game;
-        bool hiram;
-        bool loram;
-        bool p0;
-        bool p1;
-        bool p2;
-        bool p3;
-        bool p4;
-        bool p5;
-        bool p6;
-        bool p7;
-        bool p9;
-        bool p10;
-        bool p11;
-        bool p12;
-        bool p13;
-        bool p14;
-        bool p15;
-        bool p16;
-        bool p17;
-        bool p18;
-        bool p19;
-        bool p20;
-        bool p21;
-        bool p22;
-        bool p23;
-        bool p24;
-        bool p25;
-        bool p26;
-        bool p27;
-        bool p28;
-        bool p30;
-        bool p31;
-        bool read;
-        int vaddr;
-        bool va12;
-        bool va13;
-        bool va14;
-        bool va15;
         #endregion
 
         #region INPUTS
@@ -101,74 +61,163 @@ namespace BizHawk.Emulation.Computers.Commodore64.Experimental.Chips.Internals
         public void SyncState(Serializer ser) { }
         #endregion
 
+        #region LOOKUP_TABLE_GENERATOR
+
+        // PLA line information is from the PDF titled "The C64 PLA Dissected"
+        // Written by Thomas 'skoe' Giesel.
+
+        void GenerateLookup()
+        {
+            bool a12;
+            bool a13;
+            bool a14;
+            bool a15;
+            bool aec;
+            bool ba;
+            bool cas;
+            bool charen;
+            bool exrom;
+            bool game;
+            bool hiram;
+            bool loram;
+            bool p0;
+            bool p1;
+            bool p2;
+            bool p3;
+            bool p4;
+            bool p5;
+            bool p6;
+            bool p7;
+            bool p9;
+            bool p10;
+            bool p11;
+            bool p12;
+            bool p13;
+            bool p14;
+            bool p15;
+            bool p16;
+            bool p17;
+            bool p18;
+            bool p19;
+            bool p20;
+            bool p21;
+            bool p22;
+            bool p23;
+            bool p24;
+            bool p25;
+            bool p26;
+            bool p27;
+            bool p28;
+            bool p30;
+            bool p31;
+            bool read;
+            bool va12;
+            bool va13;
+            bool va14;
+
+            basicStates = new bool[65536];
+            casStates = new bool[65536];
+            charStates = new bool[65536];
+            grStates = new bool[65536];
+            ioStates = new bool[65536];
+            kernalStates = new bool[65536];
+            romHiStates = new bool[65536];
+            romLoStates = new bool[65536];
+
+            for (int i = 0; i < 65536; i++)
+            {
+                aec = (i & 0x0001) != 0;
+                ba = (i & 0x0002) != 0;
+                cas = (i & 0x0004) != 0;
+                charen = (i & 0x0008) != 0;
+                exrom = (i & 0x0010) != 0;
+                game = (i & 0x0020) != 0;
+                loram = (i & 0x0040) != 0;
+                hiram = (i & 0x0080) != 0;
+                read = (i & 0x0100) != 0;
+                va12 = (i & 0x0200) != 0;
+                va13 = (i & 0x0400) != 0;
+                va14 = (i & 0x0800) != 0;
+                a12 = (i & 0x1000) != 0;
+                a13 = (i & 0x2000) != 0;
+                a14 = (i & 0x4000) != 0;
+                a15 = (i & 0x8000) != 0;
+
+                p0 = loram && hiram && a15 && !a14 && a13 && !aec && read && game;
+                p1 = hiram && a15 && a14 && a13 && !aec && read && game;
+                p2 = hiram && a15 && a14 && a13 && !aec && read && !exrom && !game;
+                p3 = hiram && !charen && a15 && a14 && !a13 && a12 && !aec && read && game;
+                p4 = loram && !charen && a15 && a14 && !a13 && a12 && !aec && read && game;
+                p5 = hiram && !charen && a15 && a14 && !a13 && a12 && !aec && read && !exrom && !game;
+                p6 = va14 && !va13 && va12 && aec && game;
+                p7 = va14 && !va13 && va12 && aec && !exrom && !game;
+                //p8 = cas && a15 && a14 && !a13 && a12 && !aec && !rd;
+                p9 = hiram && charen && a15 && a14 && !a13 && a12 && !aec && ba && read && game;
+                p10 = hiram && charen && a15 && a14 && !a13 && a12 && !aec && !read && game;
+                p11 = loram && charen && a15 && a14 && !a13 && a12 && !aec && ba && read && game;
+                p12 = loram && charen && a15 && a14 && !a13 && a12 && !aec && !read && game;
+                p13 = hiram && charen && a15 && a14 && !a13 && a12 && !aec && ba && read && !exrom && !game;
+                p14 = hiram && charen && a15 && a14 && !a13 && a12 && !aec && !read && !exrom && !game;
+                p15 = loram && charen && a15 && a14 && !a13 && a12 && !aec && ba && read && !exrom && !game;
+                p15 = loram && charen && a15 && a14 && !a13 && a12 && !aec && ba && read && !exrom && !game;
+                p16 = loram && charen && a15 && a14 && !a13 && a12 && !aec && !read && !exrom && !game;
+                p17 = a15 && a14 && !a13 && a12 && !aec && ba && read && exrom && !game;
+                p18 = a15 && a14 && !a13 && a12 && !aec && !read && exrom && !game;
+                p19 = loram && hiram && a15 && !a14 && !a13 && !aec && read && !exrom;
+                p20 = a15 && !a14 && !a13 && !aec && exrom && !game;
+                p21 = hiram && a15 && !a14 && a13 && !aec && read && !exrom && !game;
+                p22 = a15 && a14 && a13 && !aec && exrom && !game;
+                p23 = va13 && va12 && aec && exrom && !game;
+                p24 = !a15 && !a14 && a12 && exrom && !game;
+                p25 = !a15 && !a14 && a13 && exrom && !game;
+                p26 = !a15 && a14 && exrom && !game;
+                p27 = a15 && !a14 && a13 && exrom && !game;
+                p28 = a15 && a14 && !a13 && !a12 && exrom && !game;
+                //p29 = !cas;
+                p30 = cas;
+                p31 = !cas && a15 && a14 && !a13 && a12 && !aec && !read;
+
+                casStates[i] = (p0 || p1 || p2 || p3 || p4 || p5 || p6 || p7 || p9 || p10 || p11 || p12 || p13 || p14 || p15 || p16 || p17 || p18 || p19 || p20 || p21 || p22 || p23 || p24 || p25 || p26 || p27 || p28 || p30);
+                basicStates[i] = (!p0);
+                kernalStates[i] = (!(p1 || p2));
+                charStates[i] = (!(p3 || p4 || p5 || p6 || p7));
+                grStates[i] = (!p31);
+                ioStates[i] = (!(p9 || p10 || p11 || p12 || p13 || p14 || p15 || p16 || p17 || p18));
+                romLoStates[i] = (!(p19 || p20));
+                romHiStates[i] = (!(p21 || p22 || p23));
+            }
+        }
+        #endregion
+
+        public Pla()
+        {
+            GenerateLookup();
+        }
+
         public void Precache() 
         {
-            // PLA line information is from the PDF titled "The C64 PLA Dissected"
+            int stateIndex = (
-            // Written by Thomas 'skoe' Giesel.
+                (InputAEC() ? 0x1 : 0) |
+                (InputBA() ? 0x2 : 0) |
+                (InputCAS() ? 0x4 : 0) |
+                (InputCharen() ? 0x8 : 0) |
+                (InputExRom() ? 0x10 : 0) |
+                (InputGame() ? 0x20 : 0) |
+                (InputLoRam() ? 0x40 : 0) |
+                (InputHiRam() ? 0x80 : 0) |
+                (InputRead() ? 0x100 : 0) |
+                ((InputVA() & 0x7000) >> 3) |
+                (InputAddress() & 0xF000)
+                );
 
-            addr = InputAddress();
+            cachedBasic = basicStates[stateIndex];
-            aec = InputAEC();
+            cachedCASRam = casStates[stateIndex];
-            ba = InputBA();
+            cachedCharRom = charStates[stateIndex];
-            cas = InputCAS();
+            cachedGraphicsRead = grStates[stateIndex];
-            charen = InputCharen();
+            cachedIO = ioStates[stateIndex];
-            exrom = InputExRom();
+            cachedKernal = kernalStates[stateIndex];
-            game = InputGame();
+            cachedRomHi = romHiStates[stateIndex];
-            loram = InputLoRam();
+            cachedRomLo = romLoStates[stateIndex];
-            hiram = InputHiRam();
-            read = InputRead();
-            vaddr = InputVA();
-
-            a15 = (addr & 0x08000) != 0;
-            a14 = (addr & 0x04000) != 0;
-            a13 = (addr & 0x02000) != 0;
-            a12 = (addr & 0x01000) != 0;
-            va15 = (vaddr & 0x08000) != 0;
-            va14 = (vaddr & 0x04000) != 0;
-            va13 = (vaddr & 0x02000) != 0;
-            va12 = (vaddr & 0x01000) != 0;
-
-            p0 = loram && hiram && a15 && !a14 && a13 && !aec && read && game;
-            p1 = hiram && a15 && a14 && a13 && !aec && read && game;
-            p2 = hiram && a15 && a14 && a13 && !aec && read && !exrom && !game;
-            p3 = hiram && !charen && a15 && a14 && !a13 && a12 && !aec && read && game;
-            p4 = loram && !charen && a15 && a14 && !a13 && a12 && !aec && read && game;
-            p5 = hiram && !charen && a15 && a14 && !a13 && a12 && !aec && read && !exrom && !game;
-            p6 = va14 && !va13 && va12 && aec && game;
-            p7 = va14 && !va13 && va12 && aec && !exrom && !game;
-            //p8 = cas && a15 && a14 && !a13 && a12 && !aec && !rd;
-            p9 = hiram && charen && a15 && a14 && !a13 && a12 && !aec && ba && read && game;
-            p10 = hiram && charen && a15 && a14 && !a13 && a12 && !aec && !read && game;
-            p11 = loram && charen && a15 && a14 && !a13 && a12 && !aec && ba && read && game;
-            p12 = loram && charen && a15 && a14 && !a13 && a12 && !aec && !read && game;
-            p13 = hiram && charen && a15 && a14 && !a13 && a12 && !aec && ba && read && !exrom && !game;
-            p14 = hiram && charen && a15 && a14 && !a13 && a12 && !aec && !read && !exrom && !game;
-            p15 = loram && charen && a15 && a14 && !a13 && a12 && !aec && ba && read && !exrom && !game;
-            p15 = loram && charen && a15 && a14 && !a13 && a12 && !aec && ba && read && !exrom && !game;
-            p16 = loram && charen && a15 && a14 && !a13 && a12 && !aec && !read && !exrom && !game;
-            p17 = a15 && a14 && !a13 && a12 && !aec && ba && read && exrom && !game;
-            p18 = a15 && a14 && !a13 && a12 && !aec && !read && exrom && !game;
-            p19 = loram && hiram && a15 && !a14 && !a13 && !aec && read && !exrom;
-            p20 = a15 && !a14 && !a13 && !aec && exrom && !game;
-            p21 = hiram && a15 && !a14 && a13 && !aec && read && !exrom && !game;
-            p22 = a15 && a14 && a13 && !aec && exrom && !game;
-            p23 = va13 && va12 && aec && exrom && !game;
-            p24 = !a15 && !a14 && a12 && exrom && !game;
-            p25 = !a15 && !a14 && a13 && exrom && !game;
-            p26 = !a15 && a14 && exrom && !game;
-            p27 = a15 && !a14 && a13 && exrom && !game;
-            p28 = a15 && a14 && !a13 && !a12 && exrom && !game;
-            //p29 = !cas;
-            p30 = cas;
-            p31 = !cas && a15 && a14 && !a13 && a12 && !aec && !read;
-
-            cachedCASRam = p0 || p1 || p2 || p3 || p4 || p5 || p6 || p7 || p9 || p10 || p11 || p12 || p13 || p14 || p15 || p16 || p17 || p18 || p19 || p20 || p21 || p22 || p23 || p24 || p25 || p26 || p27 || p28 || p30;
-            cachedBasic = !p0;
-            cachedKernal = !(p1 || p2);
-            cachedCharRom = !(p3 || p4 || p5 || p6 || p7);
-            cachedGraphicsRead = !p31;
-            cachedIO = !(p9 || p10 || p11 || p12 || p13 || p14 || p15 || p16 || p17 || p18);
-            cachedRomLo = !(p19 || p20);
-            cachedRomHi = !(p21 || p22 || p23);
         }
     }
 }

BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Sid.Internal.cs

@@ -7,5 +7,8 @@ namespace BizHawk.Emulation.Computers.Commodore64.Experimental.Chips.Internals
 {
     public partial class Sid
     {
+        public void Clock()
+        {
+        }
     }
 }

BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Sid.SoundProvider.cs

@@ -7,6 +7,9 @@ namespace BizHawk.Emulation.Computers.Commodore64.Experimental.Chips.Internals
 {
     public partial class Sid
     {
-
+        public ISoundProvider GetSoundProvider()
+        {
+            return new NullSound();
+        }
     }
 }

BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Vic.Interface.cs

@@ -20,51 +20,51 @@ namespace BizHawk.Emulation.Computers.Commodore64.Experimental.Chips.Internals
                 sprites[i] = new Sprite();
         }
 
-        virtual public int Address
+        public int Address
         {
             get
             {
-                return bufferADDR;
+                return cachedADDR;
             }
         }
 
-        virtual public bool AEC
+        public bool AEC
         {
             get
             {
-                return bufferAEC;
+                return cachedAEC;
             }
         }
 
-        virtual public bool BA
+        public bool BA
         {
             get
             {
-                return bufferBA;
+                return cachedBA;
             }
         }
 
-        virtual public bool CAS
+        public bool CAS
         {
             get
             {
-                return bufferCAS;
+                return cachedCAS;
             }
         }
 
-        virtual public int Data
+        public int Data
         {
             get
             {
-                return bufferDATA;
+                return cachedDATA;
             }
         }
 
-        virtual public bool IRQ
+        public bool IRQ
         {
             get
             {
-                return bufferIRQ;
+                return cachedIRQ;
             }
         }
 
@@ -98,46 +98,29 @@ namespace BizHawk.Emulation.Computers.Commodore64.Experimental.Chips.Internals
             return IRQ;
         }
 
-        public bool OutputPHI0()
-        {
-            return PHI0;
-        }
-
-        public bool OutputPixelClock()
-        {
-            return PixelClock;
-        }
-
         public bool OutputRAS()
         {
             return RAS;
         }
 
-        virtual public bool PHI0
+        public bool RAS
         {
             get
             {
-                return bufferPHI0;
+                return cachedRAS;
             }
         }
 
-        virtual public bool PixelClock
+        public void Precache() 
         {
-            get
+            cachedAEC = (pixelTimer >= 4);
-            {
+            cachedBA = ba;
-                return true;
+            cachedCAS = cas;
-            }
+            cachedDATA = data;
+            cachedIRQ = irq;
+            
         }
 
-        virtual public bool RAS
+        public void SyncState(Serializer ser) { }
-        {
-            get
-            {
-                return bufferRAS;
-            }
-        }
-
-        virtual public void Precache() { }
-        virtual public void SyncState(Serializer ser) { }
     }
 }

BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/Internals/Vic.Internal.cs

@@ -7,14 +7,13 @@ namespace BizHawk.Emulation.Computers.Commodore64.Experimental.Chips.Internals
 {
     public partial class Vic
     {
-        int bufferADDR;
+        int cachedADDR;
-        bool bufferAEC;
+        bool cachedAEC;
-        bool bufferBA;
+        bool cachedBA;
-        bool bufferCAS;
+        bool cachedCAS;
-        int bufferDATA;
+        int cachedDATA;
-        bool bufferIRQ;
+        bool cachedIRQ;
-        bool bufferPHI0;
+        bool cachedRAS;
-        bool bufferRAS;
 
         class Sprite
         {
@@ -30,15 +29,19 @@ namespace BizHawk.Emulation.Computers.Commodore64.Experimental.Chips.Internals
             public int Y;
         }
 
+        bool ba;
         int[] backgroundColor;
         bool bitmapMode;
         int borderColor;
+        bool cas;
         int characterBitmap;
         bool columnSelect;
+        int data;
         bool dataCollisionInterrupt;
         bool displayEnable;
         bool extraColorMode;
         byte interruptEnableRegister;
+        bool irq;
         bool lightPenInterrupt;
         int lightPenX;
         int lightPenY;
@@ -64,25 +67,20 @@ namespace BizHawk.Emulation.Computers.Commodore64.Experimental.Chips.Internals
         int videoCounterBase;
         int videoMatrixLineIndex;
 
-        public void Execute()
+        public void Clock()
         {
             if (pixelTimer == 0)
             {
-                bufferPHI0 = !bufferPHI0;
                 pixelTimer = 8;
-
                 badLineEnable |= (rasterY == 0x30 && displayEnable);
-                if (!bufferPHI0)
+                badLineCondition = (
-                {
+                    badLineEnable &&
-                    badLineCondition = (
+                    rasterY >= 0x030 &&
-                        badLineEnable && 
+                    rasterY <= 0x0F7 &&
-                        rasterY >= 0x030 && 
+                    (rasterY & 0x007) == yScroll
-                        rasterY <= 0x0F7 && 
+                    );
-                        (rasterY & 0x007) == yScroll
+                if (!idleState && badLineCondition)
-                        );
+                    idleState = true;
-                    if (!idleState && badLineCondition)
-                        idleState = true;
-                }
             }
             pixelTimer--;
 

BizHawk.Emulation/Computers/Commodore64/Experimental/Chips/MOS6581.cs

@@ -0,0 +1,12 @@
+using BizHawk.Emulation.Computers.Commodore64.Experimental.Chips.Internals;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace BizHawk.Emulation.Computers.Commodore64.Experimental.Chips
+{
+    sealed public class MOS6581 : Sid
+    {
+    }
+}