Merge pull request #54 from glguida/sysemu/cleanup_best_effort

 Bulk erbium emulator update

Author: glguida

sw-sysemu/devices/plic.h sw-sysemu/devices/plic_dev.hsw-sysemu/devices/plic.h renamed to sw-sysemu/devices/plic_dev.h

@@ -16,6 +16,7 @@
 #include <vector>
 #include <unistd.h>
 
+#include "emu_defines.h"
 #include "memory/memory_error.h"
 #include "memory/memory_region.h"
 #include "system.h"
@@ -31,6 +32,9 @@ struct PLIC_Interrupt_Target {
     PLIC_Target_Notify notify;
 };
 
+//
+// A generic PLIC device.
+//
 // S = #sources, T = #targets
 template <unsigned long long Base, size_t N, size_t S, size_t T>
 struct PLIC : public MemoryRegion
@@ -205,10 +209,10 @@ struct PLIC : public MemoryRegion
 
         if ((pos % 0x1000) == 0) { // Threshold registers
             *result32 = threshold[name_id];
-        } else if ((pos % 0x1000) == 4) { // MaxID registers
+        } else if ((pos % 0x1000) == 4) { // Claim/Complete registers
             // Read current MaxID
             *result32 = max_id[name_id];
-            // To claim an interrupt, the target reads its MaxID register
+            // To claim an interrupt, the target reads its Claim register
             if (max_id[name_id] > 0) {
                 in_flight[max_id[name_id]] = true;
                 // Save the ID of the Target that claimed the source interrupt
@@ -279,66 +283,6 @@ struct PLIC : public MemoryRegion
     std::array<uint32_t, T>       max_id;    // Interrupt MaxID (per target)
 };
 
-template <unsigned long long Base, size_t N>
-struct PU_PLIC : public PLIC<Base, N, 41, 12>
-{
-    static void Target_Minion_Machine_external_interrupt(System* system, bool raise) {
-        for (int i = 0; i < EMU_NUM_MINION_SHIRES; i++) {
-            if (raise) {
-                system->raise_machine_external_interrupt(i);
-            } else {
-                system->clear_machine_external_interrupt(i);
-            }
-        }
-    }
-
-    static void Target_Minion_Supervisor_external_interrupt(System* system, bool raise) {
-        for (int i = 0; i < EMU_NUM_MINION_SHIRES; i++) {
-            if (raise) {
-                system->raise_supervisor_external_interrupt(i);
-            } else {
-                system->clear_supervisor_external_interrupt(i);
-            }
-        }
-    }
-
-    const std::vector<PLIC_Interrupt_Target> &get_target_list() const {
-        static const std::vector<PLIC_Interrupt_Target> targets = {
-            {10, 0x21, Target_Minion_Machine_external_interrupt},
-            {11, 0x20, Target_Minion_Supervisor_external_interrupt},
-        };
-        return targets;
-    }
-};
-
-template <unsigned long long Base, size_t N>
-struct SP_PLIC : public PLIC<Base, N, 148, 2>
-{
-    static void Target_SP_Machine_external_interrupt(System* system, bool raise) {
-        if (raise) {
-            system->raise_machine_external_interrupt(IO_SHIRE_ID);
-        } else {
-            system->clear_machine_external_interrupt(IO_SHIRE_ID);
-        }
-    }
-
-    static void Target_SP_Supervisor_external_interrupt(System* system, bool raise) {
-        if (raise) {
-            system->raise_supervisor_external_interrupt(IO_SHIRE_ID);
-        } else {
-            system->clear_supervisor_external_interrupt(IO_SHIRE_ID);
-        }
-    }
-
-    const std::vector<PLIC_Interrupt_Target> &get_target_list() const {
-        static const std::vector<PLIC_Interrupt_Target> targets = {
-            {0, 0, Target_SP_Machine_external_interrupt},
-            {1, 1, Target_SP_Supervisor_external_interrupt},
-        };
-        return targets;
-    }
-};
-
 } // namespace bemu
 
 #endif // BEMU_PLIC_H

sw-sysemu/devices/plic_er.h

@@ -0,0 +1,46 @@
+/*-------------------------------------------------------------------------
+* Copyright (c) 2025 Ainekko, Co.
+* SPDX-License-Identifier: Apache-2.0
+*-------------------------------------------------------------------------*/
+
+#ifndef BEMU_PLIC_ER_H
+#define BEMU_PLIC_ER_H
+
+#include "plic_dev.h"
+
+namespace bemu {
+
+//
+// Erbium PLIC Implementation.
+//
+template <unsigned long long Base, size_t N>
+struct ER_PLIC : public PLIC<Base, N, 32, 2>
+{
+    static void Target_Machine_external_interrupt(System* system, bool raise) {
+        if (raise) {
+            system->raise_machine_external_interrupt(0);
+        } else {
+            system->clear_machine_external_interrupt(0);
+        }
+    }
+
+    static void Target_Supervisor_external_interrupt(System* system, bool raise) {
+        if (raise) {
+            system->raise_supervisor_external_interrupt(0);
+        } else {
+            system->clear_supervisor_external_interrupt(0);
+        }
+    }
+
+    const std::vector<PLIC_Interrupt_Target> &get_target_list() const override {
+        static const std::vector<PLIC_Interrupt_Target> targets = {
+            {0, 0, Target_Machine_external_interrupt},
+            {1, 1, Target_Supervisor_external_interrupt},
+        };
+        return targets;
+    }
+};
+
+} // namespace bemu
+
+#endif // BEMU_PLIC_ERBIUM_H

sw-sysemu/devices/plic_pu.h

@@ -0,0 +1,51 @@
+/*-------------------------------------------------------------------------
+* Copyright (c) 2025 Ainekko, Co.
+* SPDX-License-Identifier: Apache-2.0
+*-------------------------------------------------------------------------*/
+
+#ifndef BEMU_PLIC_PU_H
+#define BEMU_PLIC_PU_H
+
+#include "plic_dev.h"
+
+
+namespace bemu {
+
+//
+// Peripheral PLIC Implementation.
+//
+template <unsigned long long Base, size_t N>
+struct PU_PLIC : public PLIC<Base, N, 41, 12>
+{
+    static void Target_Minion_Machine_external_interrupt(System* system, bool raise) {
+        for (int i = 0; i < EMU_NUM_MINION_SHIRES; i++) {
+            if (raise) {
+                system->raise_machine_external_interrupt(i);
+            } else {
+                system->clear_machine_external_interrupt(i);
+            }
+        }
+    }
+
+    static void Target_Minion_Supervisor_external_interrupt(System* system, bool raise) {
+        for (int i = 0; i < EMU_NUM_MINION_SHIRES; i++) {
+            if (raise) {
+                system->raise_supervisor_external_interrupt(i);
+            } else {
+                system->clear_supervisor_external_interrupt(i);
+            }
+        }
+    }
+
+    const std::vector<PLIC_Interrupt_Target> &get_target_list() const {
+        static const std::vector<PLIC_Interrupt_Target> targets = {
+            {10, 0x21, Target_Minion_Machine_external_interrupt},
+            {11, 0x20, Target_Minion_Supervisor_external_interrupt},
+        };
+        return targets;
+    }
+};
+
+} // namespace bemu
+
+#endif // BEMU_PLIC_H

sw-sysemu/devices/plic_sp.h

@@ -0,0 +1,46 @@
+/*-------------------------------------------------------------------------
+* Copyright (c) 2025 Ainekko, Co.
+* SPDX-License-Identifier: Apache-2.0
+*-------------------------------------------------------------------------*/
+
+#ifndef BEMU_PLIC_SP_H
+#define BEMU_PLIC_SP_H
+
+#include "plic_dev.h"
+
+namespace bemu {
+
+//
+// ETSOC-1 Service Processor PLIC
+//
+template <unsigned long long Base, size_t N>
+struct SP_PLIC : public PLIC<Base, N, 148, 2>
+{
+    static void Target_SP_Machine_external_interrupt(System* system, bool raise) {
+        if (raise) {
+            system->raise_machine_external_interrupt(IO_SHIRE_ID);
+        } else {
+            system->clear_machine_external_interrupt(IO_SHIRE_ID);
+        }
+    }
+
+    static void Target_SP_Supervisor_external_interrupt(System* system, bool raise) {
+        if (raise) {
+            system->raise_supervisor_external_interrupt(IO_SHIRE_ID);
+        } else {
+            system->clear_supervisor_external_interrupt(IO_SHIRE_ID);
+        }
+    }
+
+    const std::vector<PLIC_Interrupt_Target> &get_target_list() const {
+        static const std::vector<PLIC_Interrupt_Target> targets = {
+            {0, 0, Target_SP_Machine_external_interrupt},
+            {1, 1, Target_SP_Supervisor_external_interrupt},
+        };
+        return targets;
+    }
+};
+
+} // namespace bemu
+
+#endif // BEMU_PLIC_H

sw-sysemu/emu_defines.h

@@ -20,34 +20,51 @@ namespace bemu {
 #endif
 
 #if EMU_ERBIUM
-#define EMU_NUM_SHIRES		1
+//
+// Erbium
+//
+
+// Basic Topology
+#define EMU_NUM_SHIRES          1
 #define EMU_NUM_MINION_SHIRES   (EMU_NUM_SHIRES)
 #define EMU_NUM_COMPUTE_SHIRES  (EMU_NUM_MINION_SHIRES)
-#define EMU_THREADS_PER_MINION	2
-#define EMU_MINIONS_PER_NEIGH	8
+#define EMU_THREADS_PER_MINION  2
+#define EMU_MINIONS_PER_NEIGH   8
 #define EMU_THREADS_PER_NEIGH   (EMU_THREADS_PER_MINION * EMU_MINIONS_PER_NEIGH)
-#define EMU_NEIGH_PER_SHIRE	1
+#define EMU_NEIGH_PER_SHIRE     1
 #define EMU_MINIONS_PER_SHIRE   (EMU_MINIONS_PER_NEIGH * EMU_NEIGH_PER_SHIRE)
 #define EMU_THREADS_PER_SHIRE   (EMU_THREADS_PER_NEIGH * EMU_NEIGH_PER_SHIRE)
 #define EMU_NUM_NEIGHS          (EMU_NUM_MINION_SHIRES * EMU_NEIGH_PER_SHIRE)
 #define EMU_NUM_MINIONS         (EMU_NUM_MINION_SHIRES * EMU_MINIONS_PER_SHIRE)
 #define EMU_NUM_THREADS         (EMU_NUM_MINION_SHIRES * EMU_THREADS_PER_SHIRE)
 
+// Tensor Reduce Configuartion
+#define EMU_TREDUCE_MAX_MINION  (EMU_NUM_MINIONS - 1)
+#define EMU_TREDUCE_MAX_HEIGHT  2
+
+// System Features
 #define EMU_HAS_WDT 1
+#define EMU_HAS_RVTIMER 1
 #define EMU_HAS_L2 0
 #define EMU_HAS_SVCPROC 0
 #define EMU_HAS_MEMSHIRE 0
 #define EMU_HAS_SPIO 0
 #define EMU_HAS_PU 0
-#define EMU_HAS_PMA 0
 #define EMU_HAS_PTW 0
+#define EMU_HAS_GFX 0
+#define EMU_HAS_MSG_PORTS 0
 
 // Main memory size (16MB of MRAM)
 #define EMU_DRAM_SIZE  (16ULL*1024ULL*1024ULL)
 
+#define PA_SIZE        32
+
 #elif EMU_ETSOC1
+//
+// ETSOC-1
+//
 
-// Maximum number of threads
+// Basic Topology
 #define EMU_NUM_SHIRES          35
 #define EMU_NUM_MINION_SHIRES   (EMU_NUM_SHIRES - 1)
 #define EMU_NUM_COMPUTE_SHIRES  (EMU_NUM_MINION_SHIRES - 2)
@@ -62,6 +79,10 @@ namespace bemu {
 #define EMU_NUM_MINIONS         ((EMU_NUM_MINION_SHIRES * EMU_MINIONS_PER_SHIRE) + 1)
 #define EMU_NUM_THREADS         ((EMU_NUM_MINION_SHIRES * EMU_THREADS_PER_SHIRE) + 1)
 
+// Tensor Reduce configuration.
+#define EMU_TREDUCE_MAX_MINION  (0x1FFF) // ET-SOC1 TENSOR_REDUCE send/recv: up to 8k minions. (!)
+#define EMU_TREDUCE_MAX_HEIGHT  0xF      // ET-SOC1 TENSOR_REDUCE bcast/reduce: up to 64k minions. (!)
+
 //
 // IO-Shire (and Service Processor) Configuration.
 //
@@ -111,24 +132,31 @@ namespace bemu {
 #define SCP_REGION_BASE    0x80000000ULL
 #define SCP_REGION_SIZE    0x80000000ULL
 
-//
-// PMA Configuration
-//
-#define EMU_HAS_PMA 1
-
 //
 // PTW Configuration
 //
 // Note: ET-SOC-1 PTW is presumably broken, but is left
 // enabled in the emulator to support the code that expects it.
 #define EMU_HAS_PTW 1
 
+//
+// Graphics (tex_send CSR)
+//
+#define EMU_HAS_GFX 1
+
+//
+// Message ports (portctrl, porthead CSRs)
+//
+#define EMU_HAS_MSG_PORTS 1
+
 //
 // Main memory size (up to 32GiB)
 //
 #define EMU_DRAM_SIZE  (32ULL*1024ULL*1024ULL*1024ULL)
 #define EMU_HAS_HIGH_MEMORY 1
 
+#define PA_SIZE        40
+
 #else
 #error "Architecture unspecified."
 #endif
@@ -154,8 +182,6 @@ namespace bemu {
 #define EMU_NUM_FCC_COUNTERS_PER_THREAD 2
 
 // VA to PA translation
-// TODO: Different for Erbium.
-#define PA_SIZE        40
 #define PA_M           ((((uint64_t)1) << PA_SIZE) - 1)
 #define VA_SIZE        48
 #define VA_M           ((((uint64_t)1) << VA_SIZE) - 1)

sw-sysemu/esrs_er.cpp

@@ -359,17 +359,12 @@ uint64_t System::esr_read(const Agent& agent, uint64_t addr)
         case ESR_FAST_LOCAL_BARRIER31:
             return shire_other_esrs[shire].fast_local_barrier[(esr - ESR_FAST_LOCAL_BARRIER0)>>3];
         case ESR_MTIME:
-            return 0;
-            // TODO: implement actual timer (restore PU)
-            //return memory.timer_read_mtime();
+            return memory.rvtimer_read_mtime();
         case ESR_MTIMECMP:
-            return 0;
-            // TODO: implement actual timer (restore PU)
-            // return memory.timer_read_mtimecmp();
+            return memory.rvtimer_read_mtimecmp();
         case ESR_TIME_CONFIG:
+            // TODO: undefined
             return 0;
-            // TODO: implement actual timer (restore PU)
-            // return memory.timer_read_mtimecmp();
         case ESR_MTIME_LOCAL_TARGET:
             return shire_other_esrs[shire].mtime_local_target;
         case ESR_THREAD0_DISABLE:
@@ -639,13 +634,13 @@ void System::esr_write(const Agent& agent, uint64_t addr, uint64_t value)
                       shire_other_esrs[shire].fast_local_barrier[(esr - ESR_FAST_LOCAL_BARRIER0)>>3]);
             return;
         case ESR_MTIME:
-            // TODO: implement actual timer (restore PU)
+            memory.rvtimer_write_mtime(agent, value);
             return;
         case ESR_MTIMECMP:
-            // TODO: implement actual timer (restore PU)
+            memory.rvtimer_write_mtimecmp(agent, value);
             return;
         case ESR_TIME_CONFIG:
-            // TODO: implement actual timer
+            // TODO: undefined
             // shire_other_esrs[shire].time_config = uint16_t(value & 0x3ff);
             // LOG_AGENT(DEBUG, agent, "S%u:time_config = 0x%" PRIx16,
             //           shireid(shire), shire_other_esrs[shire].time_config);