Xilinx
diff --git a/‎data_compression/L1/include/hw/checksum_wrapper.hpp‎
Lines changed: 12 additions & 3 deletions b/‎data_compression/L1/include/hw/checksum_wrapper.hpp‎
Lines changed: 12 additions & 3 deletions
diff --git a/‎data_compression/L1/include/hw/lz4_specs.hpp‎
Lines changed: 1 addition & 1 deletion b/‎data_compression/L1/include/hw/lz4_specs.hpp‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎data_compression/L1/include/hw/lz_compress.hpp‎
Lines changed: 22 additions & 16 deletions b/‎data_compression/L1/include/hw/lz_compress.hpp‎
Lines changed: 22 additions & 16 deletions
diff --git a/‎data_compression/L1/include/hw/s2mm.hpp‎
Lines changed: 35 additions & 4 deletions b/‎data_compression/L1/include/hw/s2mm.hpp‎
Lines changed: 35 additions & 4 deletions
diff --git a/‎data_compression/L1/include/hw/stream_downsizer.hpp‎
Lines changed: 40 additions & 0 deletions b/‎data_compression/L1/include/hw/stream_downsizer.hpp‎
Lines changed: 40 additions & 0 deletions
@@ -174,12 +174,19 @@ void checksum32(hls::stream<ap_uint<32> >& checksumInitStrm,
 template <int W>
 void checksum32(hls::stream<ap_uint<32> >& checksumInitStrm,
                 hls::stream<ap_uint<8 * W> >& inStrm,
-                hls::stream<ap_uint<32> >& inLenStrm,
-                hls::stream<bool>& endInStrm,
+                hls::stream<ap_uint<5> >& inLenStrm,
                 hls::stream<ap_uint<32> >& outStrm,
-                hls::stream<bool>& endOutStrm,
                 hls::stream<ap_uint<2> >& checksumTypeStrm) {
+    // Internal EOS Streams
+    hls::stream<bool> endInStrm;
+    hls::stream<bool> endOutStrm;
+#pragma HLS STREAM variable = endInStrm depth = 4
+#pragma HLS STREAM variable = endOutStrm depth = 4
+
+checksum_loop:
     for (ap_uint<2> checksumType = checksumTypeStrm.read(); checksumType != 3; checksumType = checksumTypeStrm.read()) {
+        endInStrm << false;
+        endInStrm << true;
         // CRC
         if (checksumType == 1) {
             xf::security::crc32<W>(checksumInitStrm, inStrm, inLenStrm, endInStrm, outStrm, endOutStrm);
@@ -188,6 +195,8 @@ void checksum32(hls::stream<ap_uint<32> >& checksumInitStrm,
         else {
             xf::security::adler32<W>(checksumInitStrm, inStrm, inLenStrm, endInStrm, outStrm, endOutStrm);
         }
+        endOutStrm.read();
+        endOutStrm.read();
     }
 }
 
 
@@ -49,7 +49,7 @@ const auto MAGIC_BYTE_1 = 4;
 const auto MAGIC_BYTE_2 = 34;
 const auto MAGIC_BYTE_3 = 77;
 const auto MAGIC_BYTE_4 = 24;
-const auto FLG_BYTE = 104;
+const auto FLG_BYTE = 100;
 
 /**
  * This value is used to set
 
@@ -177,21 +177,26 @@ template <int MAX_INPUT_SIZE = 64 * 1024,
           int MATCH_LEN,
           int MIN_MATCH,
           int LZ_MAX_OFFSET_LIMIT,
-          int CORE_ID = 0,
+          int NUM_BLOCKS = 8,
           int MATCH_LEVEL = 6,
           int MIN_OFFSET = 1,
           int LZ_DICT_SIZE = 1 << 12,
           int LEFT_BYTES = 64>
-void lzCompress(hls::stream<IntVectorStream_dt<8, 1> >& inStream, hls::stream<IntVectorStream_dt<32, 1> >& outStream) {
+void lzCompress(hls::stream<IntVectorStream_dt<8, 1> >& inStream,
+                hls::stream<IntVectorStream_dt<32, 1> >& outStream,
+                uint8_t ii) {
     const uint16_t c_indxBitCnts = 24;
     const uint16_t c_fifo_depth = LEFT_BYTES + 2;
     const int c_dictEleWidth = (MATCH_LEN * 8 + c_indxBitCnts);
     typedef ap_uint<MATCH_LEVEL * c_dictEleWidth> uintDictV_t;
     typedef ap_uint<c_dictEleWidth> uintDict_t;
     const uint32_t totalDictSize = (1 << (c_indxBitCnts - 1)); // 8MB based on index 3 bytes
-    static uint32_t relativeInSize = 0;
-    static bool resetDictFlag = true;
-    static uint32_t relativeNumBlocks = 0;
+    static uint32_t relativeInSize[NUM_BLOCKS] = {0};
+    static bool resetDictFlag[8] = {true, true, true, true, true, true, true, true};
+    static uint32_t relativeNumBlocks[NUM_BLOCKS] = {0};
+#pragma HLS array_partition variable = relativeInSize
+#pragma HLS array_partition variable = resetDictFlag
+#pragma HLS array_partition variable = relativeNumBlocks
 
     uintDictV_t dict[LZ_DICT_SIZE];
 #pragma HLS RESOURCE variable = dict core = XPM_MEMORY uram
@@ -208,11 +213,12 @@ void lzCompress(hls::stream<IntVectorStream_dt<8, 1> >& inStream, hls::stream<In
     // output register
     IntVectorStream_dt<32, 1> outValue;
     // loop over blocks
+
     while (true) {
         uint32_t iIdx = 0;
         // once 8MB data is processed reset dictionary
         // 8MB based on index 3 bytes
-        if (resetDictFlag) {
+        if (resetDictFlag[ii]) {
             ap_uint<MATCH_LEVEL* c_dictEleWidth> resetValue = 0;
             for (int i = 0; i < MATCH_LEVEL; i++) {
 #pragma HLS UNROLL
@@ -225,11 +231,11 @@ void lzCompress(hls::stream<IntVectorStream_dt<8, 1> >& inStream, hls::stream<In
 #pragma HLS UNROLL FACTOR = 2
                 dict[i] = resetValue;
             }
-            resetDictFlag = false;
-            relativeInSize = 0;
-            relativeNumBlocks = 0;
+            resetDictFlag[ii] = false;
+            relativeInSize[ii] = 0;
+            relativeNumBlocks[ii] = 0;
         } else {
-            relativeNumBlocks++;
+            relativeNumBlocks[ii]++;
         }
         // check if end of data
         auto nextVal = inStream.read();
@@ -245,7 +251,7 @@ void lzCompress(hls::stream<IntVectorStream_dt<8, 1> >& inStream, hls::stream<In
             inVal = nextVal;
             nextVal = inStream.read();
             present_window[++iIdx] = inVal.data[0];
-            ++relativeInSize;
+            relativeInSize[ii]++;
         }
     // assuming that, at least bytes more than LEFT_BYTES will be present at the input
     lz_fill_circular_buf:
@@ -254,7 +260,7 @@ void lzCompress(hls::stream<IntVectorStream_dt<8, 1> >& inStream, hls::stream<In
             inVal = nextVal;
             nextVal = inStream.read();
             lclBufStream << inVal.data[0];
-            ++relativeInSize;
+            relativeInSize[ii]++;
         }
         // lz_compress main
         outValue.strobe = 1;
@@ -265,12 +271,12 @@ void lzCompress(hls::stream<IntVectorStream_dt<8, 1> >& inStream, hls::stream<In
 #ifndef DISABLE_DEPENDENCE
 #pragma HLS dependence variable = dict inter false
 #endif
-            uint32_t currIdx = (iIdx + (relativeNumBlocks * MAX_INPUT_SIZE)) - MATCH_LEN + 1;
+            uint32_t currIdx = (iIdx + (relativeNumBlocks[ii] * MAX_INPUT_SIZE)) - MATCH_LEN + 1;
             // read from input stream into circular buffer
             auto inValue = lclBufStream.read(); // pop latest value from FIFO
             lclBufStream << nextVal.data[0];    // push latest read value to FIFO
             nextVal = inStream.read();          // read next value from input stream
-            ++relativeInSize;
+            relativeInSize[ii]++;
 
             // shift present window and load next value
             for (uint8_t m = 0; m < MATCH_LEN - 1; m++) {
@@ -313,7 +319,7 @@ void lzCompress(hls::stream<IntVectorStream_dt<8, 1> >& inStream, hls::stream<In
                 }
                 if ((len >= MIN_MATCH) && (currIdx > compareIdx) && ((currIdx - compareIdx) < LZ_MAX_OFFSET_LIMIT) &&
                     ((currIdx - compareIdx - 1) >= MIN_OFFSET) &&
-                    (compareIdx >= (relativeNumBlocks * MAX_INPUT_SIZE))) {
+                    (compareIdx >= (relativeNumBlocks[ii] * MAX_INPUT_SIZE))) {
                     len = len;
                 } else {
                     len = 0;
@@ -344,7 +350,7 @@ void lzCompress(hls::stream<IntVectorStream_dt<8, 1> >& inStream, hls::stream<In
         }
 
         // once relativeInSize becomes 8MB set the flag to true
-        resetDictFlag = (relativeInSize >= (totalDictSize)) ? true : false;
+        resetDictFlag[ii] = (relativeInSize[ii] >= (totalDictSize)) ? true : false;
         // end of block
         outValue.strobe = 0;
         outStream << outValue;
 
@@ -67,7 +67,6 @@ template <int DATAWIDTH, int BURST_SIZE, class OUTSIZE_DT = uint32_t>
 void stream2MM(ap_uint<DATAWIDTH>* out,
                uint32_t* checksumData,
                hls::stream<ap_uint<32> >& checksumStream,
-               hls::stream<bool>& checksumEos,
                hls::stream<ap_uint<DATAWIDTH> >& inStream,
                hls::stream<bool>& endOfStream,
                hls::stream<OUTSIZE_DT>& outSize,
@@ -100,9 +99,7 @@ void stream2MM(ap_uint<DATAWIDTH>* out,
     output_size[0] = outSize.read();
 
     // write checksum value to DDR
-    bool eosFlag = checksumEos.read();
-    if (!eosFlag) checksumData[0] = checksumStream.read();
-    eosFlag = checksumEos.read();
+    checksumData[0] = checksumStream.read();
 }
 
 template <int BURST_SIZE, int DATAWIDTH, int NUM_BLOCK>
@@ -549,6 +546,40 @@ void s2mmEosStreamSimple(ap_uint<DATAWIDTH>* out, hls::stream<ap_uint<DATAWIDTH
     }
 }
 
+template <int DATAWIDTH, int BURST_SIZE>
+void s2mmWithSize(ap_uint<DATAWIDTH>* out,
+                  hls::stream<ap_uint<DATAWIDTH + 8> >& inStream,
+                  const uint32_t index,
+                  uint32_t* decSize,
+                  hls::stream<uint32_t>& decSizeStream) {
+    /**
+     * @brief This module reads DATAWIDTH data from stream based on
+     * size stream and writes the data to DDR.
+     *
+     * @tparam DATAWIDTH width of data bus
+     * @tparam BURST_SIZE burst size of the data transfers
+     * @param out output memory address
+     * @param inStream input stream
+     * @param endOfStream stream to indicate end of data stream
+     * @param outSize output data size
+     */
+
+    bool eos = false;
+    ap_uint<DATAWIDTH + 8> dummy = 0;
+s2mmWithSize:
+    for (int j = 0; eos == false; j += BURST_SIZE) {
+        for (int i = 0; i < BURST_SIZE; i++) {
+#pragma HLS PIPELINE II = 1
+            ap_uint<DATAWIDTH + 8> inValue = (eos == true) ? dummy : inStream.read();
+            bool eos_tmp = (eos == true) ? true : inValue.range(DATAWIDTH + 7, DATAWIDTH);
+            ap_uint<DATAWIDTH> outValue = inValue.range(DATAWIDTH - 1, 0);
+            out[j + i] = outValue;
+            eos = eos_tmp;
+        }
+    }
+    decSize[index] = decSizeStream.read();
+}
+
 template <int DATAWIDTH, int BURST_SIZE, class OUTSIZE_DT = uint32_t>
 void s2mmEosSimple(ap_uint<DATAWIDTH>* out,
                    hls::stream<ap_uint<DATAWIDTH> >& inStream,
 
@@ -138,6 +138,46 @@ void bufferDownsizer(hls::stream<ap_uint<IN_DATAWIDTH + SIZE_DWIDTH> >& inStream
     outStream << outVal;
 }
 
+template <int IN_DATAWIDTH, int OUT_DATAWIDTH, int SIZE_DWIDTH = 4>
+void bufferDownsizerVec(hls::stream<ap_uint<IN_DATAWIDTH + SIZE_DWIDTH> >& inStream,
+                        hls::stream<IntVectorStream_dt<8, OUT_DATAWIDTH / 8> >& outStream) {
+    constexpr uint16_t c_factor = IN_DATAWIDTH / OUT_DATAWIDTH;
+    constexpr uint8_t c_outWord = OUT_DATAWIDTH / 8;
+    constexpr uint8_t c_outDataHigh = OUT_DATAWIDTH + SIZE_DWIDTH - 1;
+    IntVectorStream_dt<8, c_outWord> outVal;
+
+downsizer_top:
+    while (1) {
+        auto inVal = inStream.read();
+        // proceed further if valid size
+        ap_uint<SIZE_DWIDTH> inSize = inVal.range(SIZE_DWIDTH - 1, 0);
+        if (inSize == 0) break;
+    downsizer_assign:
+        while (inSize > 0) {
+#pragma HLS PIPELINE II = 1
+            ap_uint<OUT_DATAWIDTH> outReg = inVal.range(c_outDataHigh, SIZE_DWIDTH);
+            inVal >>= OUT_DATAWIDTH;
+            outVal.strobe = ((inSize < c_outWord) ? (uint8_t)inSize : c_outWord);
+            for (uint8_t i = 0; i < c_outWord; ++i) {
+#pragma HLS UNROLL
+                outVal.data[i] = outReg.range((i * 8) + 7, i * 8);
+            }
+            outStream << outVal;
+            inSize -= outVal.strobe;
+            if (inSize == 0) {
+                inVal = inStream.read();
+                inSize = inVal.range(SIZE_DWIDTH - 1, 0);
+            }
+        }
+        // Block end Condition
+        outVal.strobe = 0;
+        outStream << outVal;
+    }
+    // File end Condition
+    outVal.strobe = 0;
+    outStream << outVal;
+}
+
 template <int IN_DATAWIDTH, int OUT_DATAWIDTH>
 void simpleStreamDownSizer(hls::stream<ap_uint<IN_DATAWIDTH> >& inStream,
                            hls::stream<uint16_t>& inSizeStream,