Seems working

core-buffer/include/formats.hpp

@@ -43,10 +43,10 @@ struct BufferBinaryFormat {
 
 struct ImageBinaryFormat {
     ImageMetadata meta;
-    std::vector<char> data;
-    ImageBinaryFormat(size_t H, size_t W, size_t D): data(H*W*D, 0) {};
-    size_t size(){ return data.size(); }
-    char* data(){ return data.data(); }
+    char* data = nullptr;
+    size_t size;
+    ImageBinaryFormat(size_t H, size_t W, size_t D): size(H*W*D) { data = (char*) malloc(H*W*D); };
+    ~ImageBinaryFormat(){ free(data); std::cout << "ImageBinaryFormat destructor called!" << std::endl; }
 };
 
 

jfj-combined/include/JfjFrameCache.hpp

@@ -23,10 +23,10 @@
 	**/
 class FrameCache{
 public:
-    FrameCache(uint64_t _C, uint64_t _MX, uint64_t _MY, uint64_t _D, std::function<void(ImageBinaryFormat&)> callback):
-            m_CAP(_C), m_MX(_MX), m_MY(_MY), m_M(_MX*_MY), m_PX(1024*_MX), m_PY(512*_MY), m_D(_D),
-            m_buffer(_C, ImageBinaryFormat(512*_MY, 1024*_MX, 2)),
-            f_send(callback), m_vlock(_C), m_valid(_C), m_fill(_C, 0) {
+    FrameCache(uint64_t _C, uint64_t _MX, uint64_t _MY, std::function<void(ImageBinaryFormat&)> callback):
+            m_CAP(_C), m_MX(_MX), m_MY(_MY), m_M(_MX*_MY), m_PX(1024*_MX), m_PY(512*_MY),
+            m_buffer(_C, ImageBinaryFormat(512*_MY, 1024*_MX, sizeof(uint16_t))),
+            f_send(callback), m_vlock(_C), m_valid(_C), m_fill(_C) {
     };
 
 
@@ -36,25 +36,37 @@ public:
     This simultaneously handles buffering and assembly. **/
     void emplace(uint64_t pulseID, uint64_t moduleIDX, BufferBinaryFormat& ref_frame){
         uint64_t idx = pulseID % m_CAP;
+        std::cout << "  Emplace: " << idx << std::endl;
+
 
         // Wait for unlocking block
-        while(m_vlock[idx]){ std::this_thread::yield(); }
+        // while(m_vlock[idx]){ std::this_thread::yield(); }
 
         // Invalid cache line: Just start a new line
-        if(m_valid[idx]){ start_line(idx, ref_frame.meta); }
+        //if(m_valid[idx]){ start_line(idx, ref_frame.meta); }
 
         // A new frame is starting
-        if(ref_frame.meta.frame_index != m_buffer[idx].meta.frame_index){
-            std::cout << "  New frame " << std::endl;
+        std::cout << "  Pulse_ids: " << ref_frame.meta.pulse_id << "\t" << m_buffer[idx].meta.pulse_id << std::endl;
+
+        if(ref_frame.meta.pulse_id != m_buffer[idx].meta.pulse_id){
+            std::cout << "NOT EQUAL" << std::endl;
             flush_line(idx);
             start_line(idx, ref_frame.meta);
         }
 
         std::cout << "    fill/cpy" << std::endl;
         m_fill[idx]++;
-        char* ptr_dest = m_buffer[idx].data() + moduleIDX * m_blocksize;
-        std::memcpy(ptr_dest, (void*)&ref_frame.data, m_blocksize);
-        std::memcpy(&m_buffer[idx].meta, (void*)&ref_frame.meta, sizeof(ModuleFrame));
+        char* ptr_dest = m_buffer[idx].data + moduleIDX * m_blocksize;
+                std::cout << "    target:" << (void*)ptr_dest << "\tsize: " << m_blocksize << std::endl;
+
+        m_buffer[idx].meta.pulse_id = ref_frame.meta.pulse_id;
+        m_buffer[idx].meta.frame_index = ref_frame.meta.frame_index;
+        m_buffer[idx].meta.daq_rec = ref_frame.meta.daq_rec;
+        std::cout << "NI " << std::endl;
+        std::memcpy((void*)ptr_dest, (void*)&ref_frame.data, m_blocksize);
+        
+        std::cout << "    Fill ctr: " <<  m_fill[idx]  << std::endl;
+
     }
 
     void flush_all(){
@@ -65,10 +77,9 @@ public:
 
     void flush_line(uint64_t idx){
         if(m_valid[idx]){
+            std::cout << "Flushing line: " << idx << std::endl;
             m_vlock[idx] = 1;
-            std::cout << "Send action" << std::endl;
-            f_send(&m_meta[idx], &m_data[idx]);
-
+            f_send(m_buffer[idx]);
             m_valid[idx] = 0;
             m_fill[idx] = 0;
             m_vlock[idx] = 0;
@@ -77,24 +88,24 @@ public:
 
     void start_line(uint64_t idx, ModuleFrame& ref_meta){
         m_vlock[idx] = 1;
-        m_meta[idx].pulse_id = ref_meta.pulse_id;
-        m_meta[idx].frame_index = ref_meta.frame_index;
-        m_meta[idx].daq_rec = ref_meta.daq_rec;
-        m_meta[idx].is_good_image = true;
-        m_valid[idx] = 1;
+        m_buffer[idx].meta.pulse_id = ref_meta.pulse_id;
+        m_buffer[idx].meta.frame_index = ref_meta.frame_index;
+        m_buffer[idx].meta.daq_rec = ref_meta.daq_rec;
+        m_buffer[idx].meta.is_good_image = true;
+        m_valid[idx].exchange(1);
         m_fill[idx] = 0;
         m_vlock[idx] = 0;
     }
 
 private:
     const uint64_t m_CAP;
+    const uint64_t m_PX;
+    const uint64_t m_PY;
     const uint64_t m_MX;
     const uint64_t m_MY;
     const uint64_t m_M;
-    const uint64_t m_H;
-    const uint64_t m_W;
-    const uint64_t m_D;
-    std::function<void(ImageMetadata*, std::vector<char>*)> f_send;
+    const uint64_t m_blocksize = 1024*512*sizeof(uint16_t);
+    std::function<void(ImageBinaryFormat&)> f_send;
 
     /** Main container and mutex guard **/
     std::vector<std::atomic<uint32_t>> m_vlock;

jfj-combined/src/main.cpp

@@ -15,7 +15,7 @@ void dummy_sender(ImageBinaryFormat& image){
 
 int main (int argc, char *argv[]) {
     std::cout << "Creating frame cache..." << std::endl;
-    FrameCache cache(32, 3, JFJOCH_DATA_BYTES_PER_MODULE, &dummy_sender);
+    FrameCache cache(32, 1, 3, &dummy_sender);
 
     std::function<void(uint64_t, uint64_t, BufferBinaryFormat&)> push_cb =
         std::bind(&FrameCache::emplace, &cache, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);