buffered ram simulation and reduce cycle buffer to use 2 bit per cycle

Author: jeanlego

ODIN_II/SRC/include/AtomicBuffer.hpp

@@ -0,0 +1,177 @@
+#ifndef SIMULATION_BUFFER_H
+#define SIMULATION_BUFFER_H
+
+#include <atomic>
+#include <bitset>
+#include <mutex>
+
+/**
+ * DO NOT CHANGE THESE
+ * we use a single 64 bit integer to store al the value and we bit mask into it
+ * 2 bits per value gives us a buffer of 32
+ * 
+ */
+#define BUFFER_SIZE         16
+#define CONCURENCY_LIMIT    (BUFFER_SIZE-2) // access to cycle -1 with an extra pdding cell
+#define DATA_TYPE_BIT_SIZE  2
+#define BUFFER_BIT_SIZE     (BUFFER_SIZE*DATA_TYPE_BIT_SIZE)
+
+
+/**
+ * we only need 2 bits to store the 4 possible values
+ */
+#define INT_0   0x0
+#define INT_1   0x1
+#define INT_X   0x2
+
+/**
+ * Odin use -1 internally, so we need to go back on forth
+ * TODO: change the default odin value to match both the Blif value and this buffer
+ */
+typedef signed char data_t;
+
+typedef std::bitset<DATA_TYPE_BIT_SIZE> return_t;
+
+class AtomicBuffer
+{
+private:
+    std::mutex bitlock;
+    std::bitset<BUFFER_BIT_SIZE> buffer;
+    std::atomic<int64_t> cycle;
+
+    uint64_t mod_cycle(int64_t cycle_in)
+    {
+        // buffer is length of 32 and each internal 'bits' need 2 bit
+        return ((cycle_in & (BUFFER_SIZE-1)) *DATA_TYPE_BIT_SIZE); 
+    }
+
+    void set_bits(return_t value, uint8_t bit_index, bool lock_it)
+    {
+        if(lock_it)
+            std::lock_guard<std::mutex> lock(this->bitlock);
+
+        for(size_t i=0; i<DATA_TYPE_BIT_SIZE; i++)
+            this->buffer[bit_index+i] = value[i];
+    }
+
+    return_t get_bits(uint8_t bit_index, bool lock_it)
+    {
+        if(lock_it)
+            std::lock_guard<std::mutex> lock(this->bitlock);
+
+        return_t to_return = 0;
+        for(size_t i=0; i<DATA_TYPE_BIT_SIZE; i++)
+            to_return[i] = this->buffer[bit_index+i];
+
+        return to_return;
+    }
+
+    void copy_foward(uint8_t bit_index, bool lock_it)
+    {
+        if(lock_it)
+            std::lock_guard<std::mutex> lock(this->bitlock);
+
+        for(size_t i=0; i<DATA_TYPE_BIT_SIZE; i++)
+            this->buffer[bit_index+DATA_TYPE_BIT_SIZE+i] = this->buffer[bit_index+i];
+    }
+
+    return_t to_bit(data_t value_in)
+    {
+        if(value_in == 0)         return INT_0;
+        else if(value_in == 1)    return INT_1;
+        else                      return INT_X;
+    }
+
+    data_t to_value(return_t bit_in)
+    {
+        if(bit_in == 0)         return 0;
+        else if(bit_in == 1)    return 1;
+        else                    return -1;
+    }
+
+public:
+
+    void init_all_values(data_t value)
+    {
+        return_t value_to_set = to_bit(value);
+        for(int i=0; i<BUFFER_SIZE; i++)
+            this->set_bits(value_to_set, this->mod_cycle(i),false);
+    }
+
+    AtomicBuffer()
+    {
+        this->update_cycle(-1);
+    }
+
+    AtomicBuffer(data_t value_in)
+    {
+        this->update_cycle(-1);
+        this->init_all_values(value_in);
+    }
+
+    int64_t get_cycle()
+    {
+        return this->cycle;
+    }
+
+    void update_cycle(int64_t cycle_in)
+    {
+        this->cycle = cycle_in;
+    }
+
+    void print()
+    {
+        printf("\t");
+        for(int i=0; i<BUFFER_SIZE; i++)
+        {
+            if(!(i%4))
+                printf(" ");
+
+            data_t value = this->get_value(i);
+            if(value == -1)
+                printf("x");
+            else
+                printf("%d", value);
+            
+
+        }
+        
+        printf("\n");
+    }
+
+    data_t lock_free_get_value(int64_t cycle_in)
+    {
+        return this->to_value(this->get_bits(mod_cycle(cycle_in),false));
+    }
+
+    data_t get_value(int64_t cycle_in)
+    {
+        return this->to_value(this->get_bits(mod_cycle(cycle_in),true));
+    }
+
+    void lock_free_update_value(data_t value_in, int64_t cycle_in)
+    {
+        this->set_bits(this->to_bit(value_in), mod_cycle(cycle_in),false);
+        this->update_cycle(cycle_in);
+    }
+
+    void update_value(data_t value_in, int64_t cycle_in)
+    {
+        this->set_bits(this->to_bit(value_in), mod_cycle(cycle_in), true);
+        this->update_cycle(cycle_in);
+    }
+
+    void lock_free_copy_foward_one_cycle(int64_t cycle_in)
+    {
+        this->copy_foward(mod_cycle(cycle_in), false);
+        this->update_cycle(cycle_in);
+    }
+
+    void copy_foward_one_cycle(int64_t cycle_in)
+    {
+        this->copy_foward(mod_cycle(cycle_in), true);
+        this->update_cycle(cycle_in);
+    }
+};
+
+#endif

ODIN_II/SRC/include/AtomicRam.hpp

@@ -0,0 +1,84 @@
+#ifndef SIMULATION_RAM_H
+#define SIMULATION_RAM_H
+
+#include <mutex>
+#include <memory>
+#include <vector>
+#include "AtomicRow.hpp"
+
+class AtomicRam
+{
+private:
+    std::mutex ramlock;
+    std::vector<AtomicRow *> data_cells;
+
+
+public:
+    AtomicRam(size_t address_size, size_t word_size, int8_t init_value)
+    {
+        // compute the real depth from the adress space
+        long long max_address = 1 << address_size;
+
+        for(size_t address=0; address< max_address; address++)
+        {
+            data_cells.push_back(new AtomicRow(word_size, init_value));
+        }
+    }
+
+    ~AtomicRam()
+    {
+        for(size_t address=0; address< data_cells.size(); address++)
+        {
+            delete data_cells[address];
+        }
+    }
+
+    bool empty()
+    {
+        return this->data_cells.empty();
+    }
+
+    std::vector<int8_t> get_word_line(long long address, int64_t cycle)
+    {
+        if(address < 0 || address > data_cells.size())
+            return std::vector<int8_t>(data_cells.size(), -1);
+
+        std::lock_guard<std::mutex> lock(this->ramlock);
+        return data_cells[address]->lock_free_get_data_row(cycle);
+    }
+
+    void set_word_line(long long address, std::vector<int8_t> values, int64_t cycle)
+    {
+        if(address < 0 || address > data_cells.size())
+            return;
+
+        std::lock_guard<std::mutex> lock(this->ramlock);
+        data_cells[address]->lock_free_set_data_row(values, cycle);
+    }   
+
+    void init_word_line(long long address, char *values_in, int width)
+    {
+        if(address < 0 || address > data_cells.size())
+            return;
+
+        std::vector<int8_t> values;
+        for(size_t i =0; i<data_cells[address]->size(); i++)
+        {
+            if(i< width)
+                values.push_back(values_in[i]);
+            else
+                values.push_back(-1);
+        }
+        std::lock_guard<std::mutex> lock(this->ramlock);
+        data_cells[address]->init_line_values(values);
+    }   
+
+    void copy_ram_foward_one_cycle(int64_t cycle)
+    {
+        std::lock_guard<std::mutex> lock(this->ramlock);
+        for(size_t address=0; address< data_cells.size(); address++)
+            data_cells[address]->lock_free_copy_row_foward_one_cycle(cycle);
+    }
+};
+
+#endif

ODIN_II/SRC/include/AtomicRow.hpp

@@ -0,0 +1,97 @@
+#ifndef SIMULATION_RAM_Hs
+#define SIMULATION_RAM_H
+
+#include <mutex>
+#include <memory>
+#include <vector>
+#include "AtomicBuffer.hpp"
+
+class AtomicRow
+{
+private:
+    std::mutex word_lock;
+    std::vector<AtomicBuffer*> data_row;
+
+public:
+    AtomicRow(size_t word_size, int8_t init_value)
+    {
+        for(size_t cell=0; cell< word_size; cell++)
+            data_row.push_back(new AtomicBuffer(init_value));
+    }
+
+    AtomicRow(std::vector<AtomicBuffer*> prebuilt_row)
+    {
+        data_row = std::vector<AtomicBuffer*>(prebuilt_row.begin(), prebuilt_row.end());
+    }
+
+    ~AtomicRow()
+    {
+        for(size_t cell=0; cell< data_row.size(); cell++)
+        {
+            delete data_row[cell];
+        }
+    }
+
+    bool empty()
+    {
+        return this->data_row.empty();
+    }
+
+    size_t size()
+    {
+        return this->data_row.size();
+    }
+
+    std::vector<int8_t> get_data_row(int64_t cycle)
+    {
+        std::vector<int8_t> word_line;
+
+        for(size_t i=0; i< data_row.size(); i++)
+            word_line.push_back(data_row[i]->get_value(cycle));
+
+        return word_line;
+    }
+
+    void set_data_row(std::vector<int8_t> values, int64_t cycle)
+    {
+        for(size_t i=0; i< data_row.size(); i++)
+            data_row[i]->update_value(values[i], cycle);
+    }    
+
+    void copy_row_foward_one_cycle(int64_t cycle)
+    {
+        for(size_t i=0; i< data_row.size(); i++)
+            data_row[i]->copy_foward_one_cycle(cycle);
+    }
+
+
+    std::vector<int8_t> lock_free_get_data_row(int64_t cycle)
+    {
+        std::vector<int8_t> word_line;
+
+        for(size_t i=0; i< data_row.size(); i++)
+            word_line.push_back(data_row[i]->lock_free_get_value(cycle));
+
+        return word_line;
+    }
+
+    void lock_free_set_data_row(std::vector<int8_t> values, int64_t cycle)
+    {
+        for(size_t i=0; i< data_row.size(); i++)
+            data_row[i]->lock_free_update_value(values[i], cycle);
+    }    
+
+    void lock_free_copy_row_foward_one_cycle(int64_t cycle)
+    {
+        for(size_t i=0; i< data_row.size(); i++)
+            data_row[i]->lock_free_copy_foward_one_cycle(cycle);
+    }
+
+    void init_line_values(std::vector<int8_t> values)
+    {
+        for(size_t i=0; i< data_row.size(); i++)
+            data_row[i]->init_all_values(values[i]);
+    }    
+};
+
+#endif

ODIN_II/SRC/include/simulate_blif.h

@@ -28,9 +28,6 @@ OTHER DEALINGS IN THE SOFTWARE.
 #include <stdarg.h>
 #include <unordered_map>
 
-
-
-#define SIM_WAVE_LENGTH 16
 #define BUFFER_MAX_SIZE 1024
 
 #include <queue>
@@ -56,8 +53,6 @@ OTHER DEALINGS IN THE SOFTWARE.
 #define OUTPUT_ACTIVITY_FILE_NAME "output_activity"
 #define MODEL_SIM_FILE_NAME "test.do"
 
-#define CONCURENT_SIMULATION_LIMIT 32
-
 #define SINGLE_PORT_MEMORY_NAME "single_port_ram"
 #define DUAL_PORT_MEMORY_NAME "dual_port_ram"