[luci] Introduce Compress weights pass

compiler/circle2circle/src/Circle2Circle.cpp

@@ -193,6 +193,8 @@ int entry(int argc, char **argv)
              "This will convert single input Transpose to Reshape");
   add_switch(arser, "--expand_broadcast_const", "This will expand broadcastable constant inputs");
   add_switch(arser, "--unroll_unidirseqlstm", "Unroll UnidirectionalSequenceLSTM operator.");
+  add_switch(arser, "--compress_weights_huffman",
+             "Loseless weights compression with Huffman encoding.");
   add_switch(arser, "--convert_nchw_to_nhwc",
              "Experimental: This will convert NCHW operators to NHWC under the assumption that "
              "input model is NCHW.");
@@ -343,6 +345,7 @@ int entry(int argc, char **argv)
   option_str_to_enum["decompose_softmax"] = Algorithms::DecomposeSoftmaxPass;
   option_str_to_enum["expand_broadcast_const"] = Algorithms::ExpandBroadcastConst;
   option_str_to_enum["unroll_unidirseqlstm"] = Algorithms::UnrollUnidirSeqLSTM;
+  option_str_to_enum["compress_weights_huffman"] = Algorithms::CompressWeightsHuffman;
   // clang-format on
 
   if (arser.get<bool>("--verbose"))

compiler/luci-interpreter/include/luci_interpreter/core/Tensor.h

@@ -18,6 +18,7 @@
 #define LUCI_INTERPRETER_CORE_TENSOR_H
 
 #include "luci_interpreter/core/DataType.h"
+#include <luci/IR/AttrWeightCompression.h>
 
 #include <cassert>
 #include <cstddef>
@@ -146,6 +147,8 @@ class Tensor
 
   void resize(const Shape &new_shape);
 
+  void resize(const Shape &new_shape, size_t raw_size);
+
   void set_data_buffer(uint8_t *buffer)
   {
     if (buffer == nullptr)
@@ -173,11 +176,21 @@ class Tensor
 
   void set_offset(int32_t offset) { _offset = offset; }
 
+  luci::CompressionType get_compression() const { return _compression; }
+
+  void set_compression(luci::CompressionType compression) { _compression = compression; }
+
+  size_t get_raw_size(void) const { return _raw_size; }
+  void set_raw_size(size_t size) { _raw_size = size; }
+
 private:
   DataType _element_type;
   Shape _shape;
   AffineQuantization _quantization;
   uint8_t *_data = nullptr;
+  // Used for compressed/sparsed tensors when size != WxHxLxD
+  size_t _raw_size{0};
+
   std::string _name;
   bool _data_allocated = false;
   // Write of tensor is reported to registered Observers only if this tensor is observable
@@ -190,6 +203,8 @@ class Tensor
   // Used by static memory manager.
   // Stores the offset from the beginning of the allocated memory buffer.
   int32_t _offset = -1;
+
+  luci::CompressionType _compression{luci::CompressionType::NONE};
 };
 
 } // namespace luci_interpreter

compiler/luci-interpreter/pal/linux/HuffmanCommon.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2024 Samsung Electronics Co., Ltd. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef LUCI_INTERPRETER_PAL_HUFFMAN_COMMON_H
+#define LUCI_INTERPRETER_PAL_HUFFMAN_COMMON_H
+
+#include <memory>
+
+namespace luci_interpreter_pal
+{
+namespace huffman
+{
+
+// Node of prefix tree
+template <typename T> struct Node
+{
+  std::shared_ptr<Node<T>> p_left;
+  std::shared_ptr<Node<T>> p_right;
+  T data;
+  unsigned int freq;
+};
+
+// Compare functor for priority queue
+template <typename T> struct CompareNodes
+{
+  bool operator()(std::shared_ptr<Node<T>> l, std::shared_ptr<Node<T>> r)
+  {
+    return l->freq > r->freq;
+  }
+};
+
+template <typename T>
+std::shared_ptr<Node<T>> createNode(T data, unsigned int freq, std::shared_ptr<Node<T>> p_left,
+                                    std::shared_ptr<Node<T>> p_right)
+{
+  std::shared_ptr<Node<T>> node = std::make_unique<Node<T>>();
+  node->data = data;
+  node->freq = freq;
+  node->p_left = p_left;
+  node->p_right = p_right;
+  return node;
+}
+
+} // namespace huffman
+} // namespace luci_interpreter_pal
+
+#endif // LUCI_INTERPRETER_PAL_HUFFMAN_COMMON_H