remove memory buffer as it crashes due to high memory use

Author: jeanlego

ODIN_II/SRC/include/AtomicBuffer.hpp

@@ -5,25 +5,12 @@
 #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_SIZE         2
+#define CONCURENCY_LIMIT    (BUFFER_SIZE-1) // access to cycle -1 with an extra pdding cell
+#define DATA_TYPE_BIT_SIZE  2               // we only need 2 bits to store all the possible values
 #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
@@ -77,9 +64,7 @@ class AtomicBuffer
 
     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;
+        return value_in; // cast to 11 a -1
     }
 
     data_t to_value(return_t bit_in)
@@ -98,11 +83,6 @@ class AtomicBuffer
             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);

ODIN_II/SRC/include/AtomicRam.hpp

@@ -29,7 +29,6 @@ OTHER DEALINGS IN THE SOFTWARE.
 #include "AtomicBuffer.hpp"
 #include <mutex>
 #include <atomic>
-#include "AtomicRam.hpp"
 
 #include <stdlib.h>
 
@@ -494,7 +493,7 @@ struct nnode_t_t
 
 	netlist_t* internal_netlist; // this is a point of having a subgraph in a node
 
-	std::unique_ptr<AtomicRam> memory_data;
+	std::vector<std::vector<signed char>> memory_data;
 
 	//(int cycle, int num_input_pins, npin_t *inputs, int num_output_pins, npin_t *outputs);
 	void (*simulate_block_cycle)(int, int, int*, int, int*);

ODIN_II/SRC/include/AtomicRow.hpp

@@ -549,7 +549,7 @@ void get_options(int argc, char** argv) {
 	int thread_requested = global_args.parralelized_simulation;
 	int max_thread = std::thread::hardware_concurrency();
 	global_args.parralelized_simulation.set(
-			std::min( 	std::min( CONCURENCY_LIMIT, max_thread ), 
+			std::min( 	std::min(CONCURENCY_LIMIT, max_thread) , 
 						std::max(1, thread_requested))
 		,argparse::Provenance::SPECIFIED);
 

ODIN_II/SRC/include/types.h

@@ -327,9 +327,9 @@ sim_data_t *init_simulation(netlist_t *netlist)
 {
 	//for multithreading
 	used_time = std::numeric_limits<double>::max();
-	number_of_workers = std::min(CONCURENCY_LIMIT, std::max(1, global_args.parralelized_simulation.value()));
-	if(global_args.parralelized_simulation.value() >1 )
-		warning_message(SIMULATION_ERROR,-1,-1,"Executing simulation with maximum of %d threads", global_args.parralelized_simulation.value());
+	number_of_workers = global_args.parralelized_simulation.value();
+	if(number_of_workers >1 )
+		warning_message(SIMULATION_ERROR,-1,-1,"Executing simulation with maximum of %d threads", number_of_workers);
 
 
 	found_best_time = false;
@@ -2118,18 +2118,20 @@ static void read_write_to_memory(nnode_t *node , signal_list_t *input_address, s
 	 * make a single trigger out of write_enable pin and if it was a positive edge
 	 */
 	bool write = (trigger && 1 == get_pin_value(write_enabled, cycle));
+	bool address_is_valid = (address >= 0 && address < node->memory_data.size());
 
-	std::vector<signed char> previous_values = node->memory_data->get_word_line(address, cycle-1);
-	std::vector<signed char> new_values;
 	for (size_t i = 0; i < data_out->count; i++)
 	{
-		// we hook onto the ff function to both read and update since memories are flip flops
-		new_values.push_back(compute_ff(write, data_in->pins[i], previous_values[i], cycle));
+		signed char new_value = -1;
+		if(address_is_valid)
+		{
+			// we hook onto the ff function to both read and update since memories are flip flops
+			new_value = compute_ff(write, data_in->pins[i], node->memory_data[address][i], cycle);
+			node->memory_data[address][i] = new_value;
+		}
 		// output is combinational so it always grabs latest value
-		update_pin_value(data_out->pins[i], new_values.back(), cycle);
+		update_pin_value(data_out->pins[i], new_value, cycle);
 	}
-
-	node->memory_data->set_word_line(address, new_values, cycle);
 }
 
 /*
@@ -2141,10 +2143,9 @@ static void compute_single_port_memory(nnode_t *node, int cycle)
 
 	bool trigger = ff_trigger(RISING_EDGE_SENSITIVITY, signals->clk, cycle);
 
-	if (node->memory_data == nullptr || node->memory_data->empty())
+	if (node->memory_data.empty())
 		instantiate_memory(node, signals->data->count, signals->addr->count);
 
-	node->memory_data->copy_ram_foward_one_cycle(cycle);
 
 	read_write_to_memory(node, signals->addr, signals->out, signals->data, trigger, signals->we, cycle);
 
@@ -2159,13 +2160,12 @@ static void compute_dual_port_memory(nnode_t *node, int cycle)
 	dp_ram_signals *signals = get_dp_ram_signals(node);
 	bool trigger = ff_trigger(RISING_EDGE_SENSITIVITY, signals->clk, cycle);
 
-	if (node->memory_data == nullptr || node->memory_data->empty())
+	if (node->memory_data.empty())
 		instantiate_memory(node, 
 			std::max(signals->data1->count, signals->data2->count), 
 			std::max(signals->addr1->count,signals->addr2->count)
 		);
 
-	node->memory_data->copy_ram_foward_one_cycle(cycle);
 
 	read_write_to_memory(node, signals->addr1, signals->out1, signals->data1, trigger, signals->we1, cycle);
 	read_write_to_memory(node, signals->addr2, signals->out2, signals->data2, trigger, signals->we2, cycle);
@@ -2179,7 +2179,8 @@ static void compute_dual_port_memory(nnode_t *node, int cycle)
  */
 static void instantiate_memory(nnode_t *node, int data_width, int addr_width)
 {
-	node->memory_data = std::make_unique<AtomicRam>(addr_width, data_width, init_value(node));
+	long max_address = 1 << addr_width;
+	node->memory_data = std::vector<std::vector<signed char>>(max_address, std::vector<signed char>(data_width, init_value(node)));
 	char *filename = get_mif_filename(node);
 
 	FILE *mif = fopen(filename, "r");
@@ -2305,7 +2306,8 @@ static void assign_memory_from_mif_file(nnode_t *node, FILE *mif, char *filename
 							error_message(SIMULATION_ERROR, line_number, -1, "%s: address %s is out of range.", filename, address_string);
 
 						// Write the parsed value string to the memory location.
-						node->memory_data->init_word_line(address, binary_data, width);
+						for(int i=0; i<width; i++)
+							node->memory_data[address][i] = binary_data[i] - '0';
 					}
 					else
 					{