fix the atomic buffer
diff --git a/ODIN_II/SRC/include/AtomicBuffer.hpp b/ODIN_II/SRC/include/AtomicBuffer.hpp
index 9c42c62..5692e1d 100644
--- a/ODIN_II/SRC/include/AtomicBuffer.hpp
+++ b/ODIN_II/SRC/include/AtomicBuffer.hpp
@@ -3,31 +3,64 @@
#include <atomic>
#include <thread>
+
/**
* 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;
-#define BUFFER_SIZE 12 //use something divisible by 4 since the compact buffer can contain 4 value
+#define BUFFER_SIZE 4 //use something divisible by 4 since the compact buffer can contain 4 value
#define CONCURENCY_LIMIT (BUFFER_SIZE-1) // access to cycle -1 with an extra pdding cell
-
-typedef struct
-{
- uint8_t i0:2;
- uint8_t i1:2;
- uint8_t i2:2;
- uint8_t i3:2;
-}BitFields;
-
class AtomicBuffer
{
private:
- BitFields bits[BUFFER_SIZE/4];
+ struct BitFields
+ {
+ uint8_t i0:2;
+ uint8_t i1:2;
+ uint8_t i2:2;
+ uint8_t i3:2;
+ } bits[BUFFER_SIZE/4];
+
std::atomic<bool> lock;
int32_t cycle;
-
+
+ uint8_t to_val(data_t val_in)
+ {
+ return (val_in == 0)? 0: (val_in == 1)? 1 : 2;
+ }
+
+ template<typename T>
+ data_t val(T val_in)
+ {
+ switch(val_in)
+ {
+ case 0: //fallthrough
+ case '0': return 0;
+
+ case 1: //fallthrough
+ case '1': return 1;
+
+ default: return -1;
+ }
+ }
+
+ template<typename T>
+ char val_c(T val_in)
+ {
+ switch(val_in)
+ {
+ case 0: //fallthrough
+ case '0': return '0';
+
+ case 1: //fallthrough
+ case '1': return '1';
+
+ default: return 'x';
+ }
+ }
void lock_it()
{
@@ -43,32 +76,25 @@
lock.exchange(false, std::memory_order_relaxed);
std::atomic_thread_fence(std::memory_order_relaxed);
}
-
- ///////////////////////////
- // 2 bits are used per value
- data_t val(uint8_t val_in)
+
+ uint8_t get_bits(int64_t index)
{
- return ((val_in != 0 && val_in != 1)? -1 : val_in);
- }
-
- uint8_t get_bits(uint8_t index)
- {
- uint8_t modindex = index%(BUFFER_SIZE);
+ uint8_t modindex = (uint8_t)(index%(BUFFER_SIZE));
uint8_t address = modindex/4;
uint8_t bit_index = modindex%4;
switch(bit_index)
{
- case 0: return (this->bits[address].i0);
- case 1: return (this->bits[address].i1);
- case 2: return (this->bits[address].i2);
- case 3: return (this->bits[address].i3);
- default: return 0x3;
+ case 0: return (uint8_t)(this->bits[address].i0);
+ case 1: return (uint8_t)(this->bits[address].i1);
+ case 2: return (uint8_t)(this->bits[address].i2);
+ case 3: return (uint8_t)(this->bits[address].i3);
+ default: return (uint8_t)0x3;
}
}
- void set_bits(uint8_t index, uint8_t value)
+ void set_bits(int64_t index, uint8_t value)
{
- uint8_t modindex = index%(BUFFER_SIZE);
+ uint8_t modindex = (uint8_t)(index%(BUFFER_SIZE));
uint8_t address = modindex/4;
uint8_t bit_index = modindex%4;
@@ -76,10 +102,10 @@
switch(bit_index)
{
- case 0: this->bits[address].i0 = value; break;
- case 1: this->bits[address].i1 = value; break;
- case 2: this->bits[address].i2 = value; break;
- case 3: this->bits[address].i3 = value; break;
+ case 0: this->bits[address].i0 = (uint8_t)(value&0x3); break;
+ case 1: this->bits[address].i1 = (uint8_t)(value&0x3); break;
+ case 2: this->bits[address].i2 = (uint8_t)(value&0x3); break;
+ case 3: this->bits[address].i3 = (uint8_t)(value&0x3); break;
default: break;
}
}
@@ -95,10 +121,8 @@
void print()
{
for(int i=0; i<BUFFER_SIZE; i++)
- {
- uint8_t value = get_bits( i);
- printf("%s",(value == 0)? "0": (value == 1)? "1": "x");
- }
+ printf("%c",val_c(get_bits(i)));
+
printf("\n");
}
@@ -106,18 +130,18 @@
{
this->lock = false;
for(int i=0; i<BUFFER_SIZE; i++)
- set_bits( i, value);
+ set_bits( i, to_val(value));
}
- int32_t lock_free_get_cycle()
+ int64_t lock_free_get_cycle()
{
- return this->cycle;
+ return (int64_t)this->cycle;
}
void lock_free_update_cycle( int64_t cycle_in)
{
//if (cycle_in > this->cycle)
- this->cycle = cycle_in;
+ this->cycle = (int32_t)cycle_in;
}
data_t lock_free_get_value( int64_t cycle_in)
@@ -129,21 +153,24 @@
{
if (cycle_in > this->cycle)
{
- set_bits( cycle_in,value_in);
+ set_bits( cycle_in, to_val(value_in) );
lock_free_update_cycle( cycle_in);
}
}
void lock_free_copy_foward_one_cycle( int64_t cycle_in)
{
- set_bits( cycle_in+1,get_bits(cycle_in));
- lock_free_update_cycle( cycle_in);
+ if (cycle_in > this->cycle)
+ {
+ set_bits( cycle_in+1, get_bits(cycle_in) );
+ lock_free_update_cycle( cycle_in );
+ }
}
- int32_t get_cycle()
+ int64_t get_cycle()
{
lock_it();
- int32_t value = lock_free_get_cycle();
+ int64_t value = lock_free_get_cycle();
unlock_it();
return value;
}
