Implementiral clock, dodal machine.h in popravu pol vsa shit v machine.cpp, naredu ukaze za f1, f2

ass2/cpu.cpp

@@ -0,0 +1,46 @@
+#include "cpu.h"
+
+void cpu::start() {
+    if (running) return;        
+    running = true;
+    nitUre = std::thread(&cpu::zankaUre, this);
+}
+
+void cpu::stop() {
+    running = false;
+    if (nitUre.joinable())
+        nitUre.join();
+}
+
+bool cpu::isRunning() {
+    return running.load();
+}
+
+int cpu::getSpeed() {
+    return hitrostKhz;
+}
+
+void cpu::setSpeed(int speedKhz) {
+    if (speedKhz < 1) speedKhz = 1;
+    hitrostKhz = speedKhz;
+}
+
+void cpu::zankaUre() {
+    while (running) {
+        // 1. Izvedemo določeno št. ukazov na tick
+        for (int i = 0; i < operacijeNaTick; i++) {
+            cpu::m->execute();
+        }
+
+        // 2. Izračunamo kolikokrat mora "tikati" na sekundo
+        // speed_kHz = n tisoč ukazov / sekundo
+        // operacijeNaTick = koliko ukazov na en tik
+        // ticksPerSecond = (hitrostKhz * 1000) / operacijeNaTick
+
+        double ticksPerSecond = (hitrostKhz * 1000.0) / operacijeNaTick;
+        double sleepTimeSec = 1.0 / ticksPerSecond;
+
+        // 3. Ustavimo nit za izračunani čas
+        std::this_thread::sleep_for(std::chrono::duration<double>(sleepTimeSec));
+    }
+}

ass2/cpu.h

@@ -0,0 +1,24 @@
+#pragma once
+#include "machine.h"
+#include <atomic>
+#include <thread>
+#include <chrono>
+
+class cpu {
+    private:
+        std::atomic<bool> running;
+        std::thread nitUre;
+        int hitrostKhz;
+        int operacijeNaTick;
+        machine *m;
+        
+    public:
+        cpu(machine *m) : running(false), hitrostKhz(1), operacijeNaTick(10), m(m) {}
+        void start();
+        void stop();
+        bool isRunning();
+        void setSpeed(int kHz);
+        int getSpeed();
+    private:
+        void zankaUre();
+};

ass2/machine.cpp

@@ -1,5 +1,6 @@
 #include <array>
 #include <stdexcept>
+#include "machine.h"
 #include "device.h"
 #include "inputDevice.h"
 #include "outputDevice.h"
@@ -7,77 +8,77 @@
 #include "opcode.h"
 #include <memory>
 #include <iostream>
+#include <functional>
+#include <sstream>
 using namespace std;
 
-class machine {
-public:
-    //zaporedne stevilke registrov, ne njihove vrednosti
-    static const int A = 0;                    
-    static const int X = 1;      
-    static const int L = 2;      
-    static const int B = 3;       
-    static const int S = 4;      
-    static const int T = 5;      
-    static const double F = 6;   
-    static const int PC = 8;     
-    static const int SW = 9;
-    static const int CC_LT = 0x00;  //manjse
-    static const int CC_EQ = 0x40;  //enako
-    static const int CC_GT = 0x80;  //vecje
-    static const int MAX_ADRESS = 1048575;
-private:
-    array<int, 10> registri{};          //tukaj so shranjene pa vrednosti registrov
-    double F_val = 0.0;
-    array<uint8_t, MAX_ADRESS> pomnilnik{};
-    array<unique_ptr<Device>, 256> naprave{}; //treba s pointerji zaradi dedovanja 
-    
 
-public:
+machine::machine() {
-    machine() {
+    registri.fill(0); //konstruktor -> vsi registri so 0 na zacetku
-        registri.fill(0); //konstruktor -> vsi registri so 0 na zacetku
         
-        naprave[0] = make_unique<InputDevice>(cin); //0 = std vhod
+    naprave[0] = make_unique<InputDevice>(cin); //0 = std vhod
-        naprave[1] = make_unique<InputDevice>(cout); //1 = std izhod
+    naprave[1] = make_unique<InputDevice>(cout); //1 = std izhod
-        naprave[2] = make_unique<InputDevice>(cerr); //2 = std izhod za napake
+    naprave[2] = make_unique<InputDevice>(cerr); //2 = std izhod za napake
         
-        for (int i = 3; i < 256; i++) { //inicializacija ostalih naprav
+    for (int i = 3; i < 256; i++) { //inicializacija ostalih naprav
-            string fname = "file" + to_string(i) + ".dat";
+        string fname = "file" + to_string(i) + ".dat";
-            naprave[i] = make_unique<fileDevice>(fname);
+        naprave[i] = make_unique<fileDevice>(fname);
-        }
+    }
-    }       
-    
-    //getterji, setterji
-    int getA() {return registri[A];}
-    void setA(int a) {registri[A] = a;}
-    
-    int getX() {return registri[X];}
-    void setX(int x) {registri[X] = x;}
-    
-    int getL() {return registri[L];}
-    void setL(int l) {registri[L] = l;}
-    
-    int getB() {return registri[B];}
-    void setB(int b) {registri[B] = b;}
-    
-    int getS() {return registri[S];}
-    void setS(int s) {registri[S] = s;}
-    
-    int getT() {return registri[T];}
-    void setT(int t) {registri[T] = t;}
 
-    double getF() {return F_val;}
+    ukaziF2 = {
-    void setF(double f) {F_val = f;}
+        {"ADDR", [&](int r1, int r2){setReg(r2, getReg(r1)+getReg(r2)); return true;}}, 
-
+        {"SUBR", [&](int r1, int r2){setReg(r2, getReg(r2)-getReg(r1)); return true;}},
-    int getPC() {return registri[PC];}
+        {"MULR", [&](int r1, int r2){setReg(r2, getReg(r2)*getReg(r1)); return true;}},
-    void setPC(int pc) {registri[PC] = pc;}
+        {"DIVR", [&](int r1, int r2){setReg(r2, getReg(r2)/getReg(r1)); return true;}},
-
+        {"CLEAR", [&](int r1, int){setReg(r1, 0); return true; }},
-    int getSW() {return registri[SW];}
+        {"COMPR", [&](int r1, int r2){int v1 = getReg(r1), v2 = getReg(r2);
-    void setSW(int sw) {registri[SW] = sw;}
+                                    if (v1 < v2) setSW(CC_LT);
+                                    else if (v1 == v2) setSW(CC_EQ);
+                                    else setSW(CC_GT);
+                                    return true;}},
+        {"RMO", [&](int r1, int r2){setReg(r2, getReg(r1)); return true;}},
+        {"SHIFTR", [&](int r1, int n){int val = getReg(r1);setReg(r1, val >> n);return true;}},
+        {"SHIFTL", [&](int r1, int n){int val = getReg(r1);setReg(r1, val << n);return true;}},
+        {"TIXR", [&](int r1, int){int x = getX()+1; setX(x); int v2 = getReg(r1);
+                                    if (x < v2) setSW(CC_LT);
+                                    else if (x == v2) setSW(CC_EQ);
+                                    else setSW(CC_GT);
+                                    return true;}},
+    };
+}       
     
-    int getReg(int r) {
+    //machine::getterji, setterji
+    int machine::getA() {return registri[A];}
+    void machine::setA(int a) {registri[A] = a;}
+    
+    int machine::getX() {return registri[X];}
+    void machine::setX(int x) {registri[X] = x;}
+    
+    int machine::getL() {return registri[L];}
+    void machine::setL(int l) {registri[L] = l;}
+    
+    int machine::getB() {return registri[B];}
+    void machine::setB(int b) {registri[B] = b;}
+    
+    int machine::getS() {return registri[S];}
+    void machine::setS(int s) {registri[S] = s;}
+    
+    int machine::getT() {return registri[T];}
+    void machine::setT(int t) {registri[T] = t;}
+
+    double machine::getF() {return F_val;}
+    void machine::setF(double f) {F_val = f;}
+
+    int machine::getPC() {return registri[PC];}
+    void machine::setPC(int pc) {registri[PC] = pc;}
+
+    int machine::getSW() {return registri[SW];}
+    void machine::setSW(int sw) {registri[SW] = sw;}
+    
+    int machine::getReg(int r) {
         return r!=6 ? registri[r] : F_val;
     }
-    void setReg(int r, int val) {
+    void machine::setReg(int r, int val) {
         if (r == 6) {
             F_val = val; 
         } else {
@@ -85,18 +86,18 @@ public:
         }
     }
 
-    int getByte(int adr) {
+    int machine::getByte(int adr) {
         return  (adr <= MAX_ADRESS && adr >= 0) ? pomnilnik[adr] : throw out_of_range("Naslov je izven pomnilniškega obmocja: " + to_string(adr)); 
     }
-    void setByte(int adr, int val) {
+    void machine::setByte(int adr, int val) {
-        if (adr < 0 || adr > MAX_ADRESS) throw out_of_range("Naslov je izven pomnilniškega obmocja: " + to_string(adr));
+        if (adr < 0 || adr > MAX_ADRESS) outOfMemoryRange(adr);
         if (val < 0 || val > 255) throw invalid_argument("Byte ima vrednost med 0 in 255.");
         pomnilnik[adr] = static_cast<uint8_t>(val);
 
     }
 
-    int getWord(int adr) {
+    int machine::getWord(int adr) {
-        if (adr < 0 || adr + 2 > MAX_ADRESS) throw out_of_range("Beseda je izven pomnilniškega območja: " + to_string(adr+2));
+        if (adr < 0 || adr + 2 > MAX_ADRESS) outOfMemoryRange(adr+2);
         
         int byte1 = pomnilnik[adr];
         int byte2 = pomnilnik[adr+1];
@@ -105,8 +106,8 @@ public:
         return (byte1 << 16) | (byte2 << 8) | byte3;
     }
 
-    void setWord(int adr, int val) {
+    void machine::setWord(int adr, int val) {
-        if (adr < 0 || adr + 2 > MAX_ADRESS) throw out_of_range("Beseda je izven pomnilniškega območja: " + to_string(adr+2));
+        if (adr < 0 || adr + 2 > MAX_ADRESS) outOfMemoryRange(adr+2);
         if (val < 0 || val > 0xFFFFFF) throw invalid_argument("Beseda mora imeti vrednost med 0 in 0xFFFFFF.");
         
         pomnilnik[adr] = (val >> 16) & 0xFF;  //val = 0x00123456 -> hočemo 12, val >> 16 -> 0x00000012 & 0x000000ff = 0x12
@@ -114,7 +115,7 @@ public:
         pomnilnik[adr+2] = (val) & 0xFF;  
     }
 
-    Device& getDevice(uint8_t dev) {
+    Device& machine::getDevice(uint8_t dev) {
         if (dev > 255) 
             throw out_of_range("Naprava ne obstaja, izberite napravo med 0 in 255");
 
@@ -125,37 +126,57 @@ public:
     }
 
 
-    void setDevice(uint8_t num, unique_ptr<Device> dev) {
+    void machine::setDevice(uint8_t num, unique_ptr<Device> dev) {
         if (num > 255)
             throw out_of_range("Naprava ne obstaja, izberite napravo med 0 in 255");
 
         naprave[num] = move(dev);
     }
 
-    void setFileDevice(uint8_t num, string filename) {
+    void machine::setFileDevice(uint8_t num, const string& filename) {
         if (num <= 2 || num > 255) {
             throw out_of_range("Samo naprave med 3 in 255 imajo lahko poljubno ime");
         }
         naprave[num] = make_unique<fileDevice>(filename);
     }
 
-    void notImplemented(string mnemonic) {
+    int getUN(int n, int x, int b, int p, int e, int operand) {
+        //NEED TO IMPLEMENT
+        return 1;
+    }
+
+
+    /*void incompatibleArgument(const type_info& t1, const type_info& t2) {
+        stringstream ss;
+        ss << "Tipa vrednosti se razlikujeta: " << t1.name() << " vs " << t2.name();
+        throw invalid_argument(ss.str());
+    }*/
+
+    void machine::outOfMemoryRange(int memory) {
+        throw out_of_range("Naslov je izven pomnilniškega obmocja: " + to_string(memory));
+    }
+
+    void machine::notImplemented(const string& mnemonic) {
         throw runtime_error("Mnemonic ni implementiran: " + mnemonic);
     }
 
-    void invalidOpcode (int opcode) {
+    void machine::invalidOpcode (int opcode) {
         throw invalid_argument("Opcode ne obstaja: " + to_string(opcode) + ".");
     }
 
-    void invalidAdressing() {
+    void machine::invalidAdressing() {
         throw invalid_argument("Ta način naslavljanja ni podprt.");
     }
 
-    uint8_t fetch() {
+    void machine::invalidRegister(const string& mnemonic, int r1, int r2) {
-        return getByte(registri[PC]++);
+        throw invalid_argument("Neveljaven register v ukazu" + mnemonic + " r1 = " + to_string(r1) + " r2 = " + to_string(r2));
     }
 
-    void execute() {
+    uint8_t machine::fetch() {
+        return machine::getByte(registri[PC]++);
+    }
+
+    void machine::execute() {
         uint8_t opcode8 = fetch();          
         uint8_t opcode6 = opcode8 & 0xFC;   
 
@@ -190,23 +211,54 @@ public:
         }
 
         if (uspesno) return;
-        else {}
+        else {
+            throw runtime_error("Izvajanje ukaza je bilo neuspešno");
+        }
     }
 
 
-
+    //////////////////////////////////////////////////////////////////////////////////
-    bool execF1(uint8_t opcode, string mnemonic){
+    //TO DO, racunanje uporabnih naslovov!!!!
-
+    bool machine::execF1(uint8_t opcode, const string& mnemonic){
+        //FIX, FLOAT, HIO, TIO, SIO, NORM
+        auto it = Opcode::OPCODES.find(opcode);
+        InstructionInfo ii = it->second;
+        string name = ii.mnemonic;
+        
+        if (name == "FIX") {
+            setA(static_cast<int>(getF()));
+            return true;
+        } else if (name == "FLOAT") {
+            setF(static_cast<double>(getA()));
+            return true;
+        } else if (name == "HIO") {
+            //halt I/0 na kanalu (A)
+            return true;
+        } else if (name == "TIO") {
+            //test I/O na kanalu (A)
+            return true;  
+        } else if (name == "SIO") {
+            //start I/O na kanalu (A), adress kanala je dan na (S)
+            return true;
+        } else if (name == "NORM") {
+            //normalizirej (F), v c++ so ze vsa double stevila normalizirana
+            return true;
+        }
     }
-    
+
-    bool execF2(uint8_t opcode, uint8_t operand, string mnemonic){
+
+    bool machine::execF2(uint8_t opcode, uint8_t operand, const string& mnemonic){
         uint8_t r1 = (operand & 0xF0) >> 4;   
         uint8_t r2 = (operand & 0x0F);
-
+        auto it = ukaziF2.find(mnemonic);
-
+        
+        if (it == ukaziF2.end()) notImplemented(mnemonic); return false;
+        if (r1 > 9 || r2 > 9 || r1 < 0 || r2 < 0) invalidRegister(mnemonic, r1, r2); return false;
+        
+        return it->second(r1, r2);
     }
 
-    bool execSIC_F3_F4(uint8_t byte1, uint8_t byte2, uint8_t byte3, string mnemonic) {
+    bool machine::execSIC_F3_F4(uint8_t byte1, uint8_t byte2, uint8_t byte3, const string& mnemonic) {
         uint8_t n = (byte1 >> 7) & 1;
         uint8_t i = (byte1 >> 6) & 1;
         uint8_t x = (byte2 >> 7) & 1;
@@ -216,14 +268,17 @@ public:
 
         if (n == 0 && i == 0) {
             //imamo format SIC
+
         } else if (e == 1) {
             //imamo format 4
         } else {
             //imamo format 3
         }
     }
+    //TO DO
+    /////////////////////////////////////////////////////////////////////////////////////
+
 
-};
 
 
 

ass2/machine.h

@@ -0,0 +1,83 @@
+#pragma once
+
+#include <array>
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <cstdint>
+#include <unordered_map>
+#include <functional>
+
+class Device;
+
+class machine {
+public:
+    // Register indices
+    static const int A  = 0;
+    static const int X  = 1;
+    static const int L  = 2;
+    static const int B  = 3;
+    static const int S  = 4;
+    static const int T  = 5;
+    static const int F  = 6;
+    static const int PC = 8;
+    static const int SW = 9;
+
+    // Condition codes
+    static const int CC_LT = 0x00;
+    static const int CC_EQ = 0x40;
+    static const int CC_GT = 0x80;
+
+    static const int MAX_ADRESS = 1048575;
+
+private:
+    std::array<int, 10> registri{};
+    double F_val = 0.0;
+
+    std::array<uint8_t, MAX_ADRESS> pomnilnik{};
+    std::array<std::unique_ptr<Device>, 256> naprave{};
+    std::unordered_map<std::string, std::function<bool(int,int)>> ukaziF2;
+
+public:
+    machine();
+
+    // getters-setters
+    int getA(); void setA(int a);
+    int getX(); void setX(int x);
+    int getL(); void setL(int l);
+    int getB(); void setB(int b);
+    int getS(); void setS(int s);
+    int getT(); void setT(int t);
+
+    double getF(); void setF(double f);
+    int getPC(); void setPC(int pc);
+    int getSW(); void setSW(int sw);
+
+    int getReg(int r);
+    void setReg(int r, int val);
+
+    // memory
+    int getByte(int adr);
+    void setByte(int adr, int val);
+    int getWord(int adr);
+    void setWord(int adr, int val);
+
+    // devices
+    Device& getDevice(uint8_t dev);
+    void setDevice(uint8_t num, std::unique_ptr<Device> dev);
+    void setFileDevice(uint8_t num, const std::string& filename);
+
+    // error helpers
+    void notImplemented(const std::string& mnemonic);
+    void invalidOpcode(int opcode);
+    void invalidAdressing();
+    void invalidRegister(const std::string& mnemonic, int r1, int r2);
+    void outOfMemoryRange(int mem);
+
+    // execution
+    uint8_t fetch();
+    void execute();
+    bool execF1(uint8_t opcode, const std::string& mnemonic);
+    bool execF2(uint8_t opcode, uint8_t operand, const std::string& mnemonic);
+    bool execSIC_F3_F4(uint8_t b1, uint8_t b2, uint8_t b3, const std::string& mnemonic);
+};

ass2/main.cpp

@@ -0,0 +1,12 @@
+#include "machine.h"
+#include "cpu.h"
+
+int main(int argc, char const *argv[]){
+    machine m;
+    cpu procesor(&m);
+    procesor.setSpeed(100);
+    procesor.start();
+    //stuff
+    procesor.stop();   
+    return 0;
+}