msherif4 · petya2164 · Jul 1, 2013 · Jul 1, 2013 · Jul 1, 2013 · Jul 4, 2013
diff --git a/NEWS.rst b/NEWS.rst
@@ -4,7 +4,46 @@ News for Kodo
 This file lists the major changes between versions. For a more detailed list
 of every change, see the Git log.
 
-Latest
+13.0.0
+------
+* Major: Replaced the linear_block_decoder with the
+  bidirectional_linear_block_decoder layer. The bidirectional linear
+  block decoder layer uses a direction policy to determine whether to
+  perform Gaussian elimination from left-to-right or
+  right-to-left. Certain newer network coding algorithms can be
+  implemented efficiently utilizing this flexibility. Based on the
+  bidirectional layer we have added the forward and backwards linear
+  block decoder.
+* Minor: Added support for specifying the number of nonzero symbols in the
+  sparse codes (this extends the API which previously only supported a
+  fraction of nonzero symbols to be specified).
+* Minor: Added generic functions for printing debug information from codec
+  stacks where this functionality is supported.
+
+12.0.0
+------
+* Major: Changed the partial_decoding_tracker to only provide the
+  functionality needed to detect "early" or partial decoding. The
+  monitor functionality has been moved to the largest_nonzero_index_decoder
+  layer.
+* Minor: Added the payload_rank_encoder and payload_rank_decoder layers
+  which will explicitly exchange the rank of the encoder matrix and the
+  decoder matrix to support partial decoding.
+
+11.2.0
+------
+* Minor: Added the partial_decoding_tracker layer which "monitors" the
+  coding vectors being passed to a decoder in order to detect early
+  decoding opportunities. This means that although not all packets have
+  yet been sent from the encoder, it might happen that we can decode
+  anyway. This kind of functionality is useful especially for applications
+  which require low delay.
+* Minor: Added on-the-fly encoding and decoding stacks in
+  src/kodo/rlnc/on_he_fly_codes.hpp the on-the-fly stacks have the advantage
+  that they allow encoding and decoding to proceed even without having all
+  encoding symbols available.
+
+11.1.0
 ------
 * Minor: Added new cached_symbol_decoder layer, this layer does not perform
   any decoding on the incoming symbol, but provides access to the encoded
@@ -13,6 +52,7 @@ Latest
 * Minor: Added new example showing some one way to use some of the debug
   layers in kodo. The example is in the examples folder called
   use_debug_layers
+* Bug: Fix missing return in the payload_recoder recode() function.
 
 11.0.0
 ------

diff --git a/README.rst b/README.rst
@@ -1,3 +1,13 @@
+License
+-------
+
+To obtain a valid Kodo license **you must fil out the license request** form_.
+
+Kodo is available under a research and educational friendly licensee, see the details in the LICENSE.rst file.
+
+.. _form: http://steinwurf.com/license/
+
+
 Introduction
 ------------
 
@@ -10,11 +20,6 @@ a multitude of build blocks and parameters that can be combined in
 order to create codes. To ensure ease of use several codes are
 predefined, and high level API's provided.
 
-License
--------
-Kodo is available under a research and educational friendly licensee,
-see the details in the LICENSE.rst file.
-
 Documentation
 -------------
 To get started see the manual here:

diff --git a/benchmark/count_operations/codes.hpp b/benchmark/count_operations/codes.hpp
@@ -56,7 +56,7 @@ namespace kodo
                plain_symbol_id_reader<
                // Codec API
                aligned_coefficients_decoder<
-               linear_block_decoder<
+               forward_linear_block_decoder<
                // Coefficient Storage API
                coefficient_storage<
                coefficient_info<
@@ -87,7 +87,7 @@ namespace kodo
                // Codec API
                aligned_coefficients_decoder<
                linear_block_decoder_delayed<
-               linear_block_decoder<
+               forward_linear_block_decoder<
                // Coefficient Storage API
                coefficient_storage<
                coefficient_info<

diff --git a/benchmark/count_operations/wscript_build b/benchmark/count_operations/wscript_build
@@ -2,7 +2,7 @@
 # encoding: utf-8
 
 bld.program(
-    features = 'cxx',
+    features = 'cxx benchmark',
     source   = ['main.cpp'],
     target   = 'kodo_count_operations',
     use = ['kodo_includes', 'fifi_includes', 'sak_includes',

diff --git a/benchmark/decoding_probability/codes.hpp b/benchmark/decoding_probability/codes.hpp
@@ -26,7 +26,7 @@ namespace kodo
                  // Codec API
                  aligned_coefficients_decoder<
                  linear_block_decoder_delayed<
-                 linear_block_decoder<
+                 forward_linear_block_decoder<
                  // Coefficient Storage API
                  coefficient_storage<
                  coefficient_info<
@@ -56,7 +56,7 @@ namespace kodo
             // Codec API
             aligned_coefficients_decoder<
             linear_block_decoder_delayed<
-            linear_block_decoder<
+            forward_linear_block_decoder<
             // Coefficient Storage API
             coefficient_storage<
             coefficient_info<

diff --git a/benchmark/decoding_probability/wscript_build b/benchmark/decoding_probability/wscript_build
@@ -2,7 +2,7 @@
 # encoding: utf-8
 
 bld.program(
-    features = 'cxx',
+    features = 'cxx benchmark',
     source   = ['main.cpp'],
     target   = 'kodo_decoding_probability',
     use = ['kodo_includes', 'fifi_includes', 'sak_includes',

diff --git a/benchmark/overhead/codes.hpp b/benchmark/overhead/codes.hpp
@@ -26,7 +26,7 @@ namespace kodo
                  // Codec API
                  aligned_coefficients_decoder<
                  linear_block_decoder_delayed<
-                 linear_block_decoder<
+                 forward_linear_block_decoder<
                  // Coefficient Storage API
                  coefficient_storage<
                  coefficient_info<
@@ -56,7 +56,7 @@ namespace kodo
             // Codec API
             aligned_coefficients_decoder<
             linear_block_decoder_delayed<
-            linear_block_decoder<
+            forward_linear_block_decoder<
             // Coefficient Storage API
             coefficient_storage<
             coefficient_info<

diff --git a/benchmark/overhead/wscript_build b/benchmark/overhead/wscript_build
@@ -2,7 +2,7 @@
 # encoding: utf-8
 
 bld.program(
-    features = 'cxx',
+    features = 'cxx benchmark',
     source   = ['main.cpp'],
     target   = 'kodo_overhead',
     use = ['kodo_includes', 'fifi_includes', 'sak_includes',

diff --git a/benchmark/throughput/codes.hpp b/benchmark/throughput/codes.hpp
@@ -9,6 +9,7 @@
 #include <kodo/rlnc/full_vector_codes.hpp>
 #include <kodo/linear_block_decoder_delayed.hpp>
 #include <kodo/sparse_uniform_generator.hpp>
+#include <kodo/backward_linear_block_decoder.hpp>
 
 
 namespace kodo
@@ -30,7 +31,7 @@ namespace kodo
                  // Codec API
                  aligned_coefficients_decoder<
                  linear_block_decoder_delayed<
-                 linear_block_decoder<
+                 forward_linear_block_decoder<
                  // Coefficient Storage API
                  coefficient_storage<
                  coefficient_info<
@@ -83,6 +84,37 @@ namespace kodo
                    > > > > > > > > > > > > > > > > >
     { };
 
+    /// RLNC decoder which uses the policy based linear block decoder
+    template<class Field>
+    class backward_full_rlnc_decoder
+        : public // Payload API
+                 payload_recoder<recoding_stack,
+                 payload_decoder<
+                 // Codec Header API
+                 systematic_decoder<
+                 symbol_id_decoder<
+                 // Symbol ID API
+                 plain_symbol_id_reader<
+                 // Codec API
+                 aligned_coefficients_decoder<
+                 backward_linear_block_decoder<
+                 // Coefficient Storage API
+                 coefficient_storage<
+                 coefficient_info<
+                 // Storage API
+                 deep_symbol_storage<
+                 storage_bytes_used<
+                 storage_block_info<
+                 // Finite Field API
+                 finite_field_math<typename fifi::default_field<Field>::type,
+                 finite_field_info<Field,
+                 // Factory API
+                 final_coder_factory_pool<
+                 // Final type
+                 backward_full_rlnc_decoder<Field>
+                     > > > > > > > > > > > > > > >
+    { };
+
 
 }
 
diff --git a/benchmark/throughput/main.cpp b/benchmark/throughput/main.cpp
@@ -340,7 +340,8 @@ struct sparse_throughput_benchmark :
     /// The type of the base benchmark
     typedef throughput_benchmark<Encoder,Decoder> Super;
 
-    /// We need access to the encoder built to adjust the density
+    /// We need access to the encoder built to adjust the number of
+    /// nonzero symbols
     using Super::m_encoder;
 
 public:
@@ -350,26 +351,27 @@ struct sparse_throughput_benchmark :
         auto symbols = options["symbols"].as<std::vector<uint32_t> >();
         auto symbol_size = options["symbol_size"].as<std::vector<uint32_t> >();
         auto types = options["type"].as<std::vector<std::string> >();
-        auto density = options["density"].as<std::vector<double> >();
+        auto nonzero_symbols = 
+            options["nonzero_symbols"].as<std::vector<uint32_t> >();
 
         assert(symbols.size() > 0);
         assert(symbol_size.size() > 0);
         assert(types.size() > 0);
-        assert(density.size() > 0);
+        assert(nonzero_symbols.size() > 0);
 
         for(const auto& s : symbols)
         {
             for(const auto& p : symbol_size)
             {
                 for(const auto& t : types)
                 {
-                    for(const auto& d: density)
+                    for(const auto& n: nonzero_symbols)
                     {
                         gauge::config_set cs;
                         cs.set_value<uint32_t>("symbols", s);
                         cs.set_value<uint32_t>("symbol_size", p);
                         cs.set_value<std::string>("type", t);
-                        cs.set_value<double>("density", d);
+                        cs.set_value<uint32_t>("nonzero_symbols", n);
 
                         Super::add_configuration(cs);
                     }
@@ -384,8 +386,8 @@ struct sparse_throughput_benchmark :
 
         gauge::config_set cs = Super::get_current_configuration();
 
-        double density = cs.get_value<double>("density");
-        m_encoder->set_density(density);
+        uint32_t symbols = cs.get_value<uint32_t>("nonzero_symbols");
+        m_encoder->set_nonzero_symbols(symbols);
     }
 
 };
@@ -436,27 +438,32 @@ BENCHMARK_OPTION(throughput_options)
     gauge::runner::instance().register_options(options);
 }
 
-BENCHMARK_OPTION(throughput_density_options)
+BENCHMARK_OPTION(throughput_nonzero_symbols_options)
 {
     gauge::po::options_description options;
 
-    std::vector<double> density;
-    density.push_back(0.1);
-    density.push_back(0.2);
-    density.push_back(0.3);
-    density.push_back(0.4);
-    density.push_back(0.5);
+    std::vector<uint32_t> nonzero_symbols;
+    nonzero_symbols.push_back(1);
+    nonzero_symbols.push_back(2);
+    nonzero_symbols.push_back(3);
+    nonzero_symbols.push_back(4);
+    nonzero_symbols.push_back(5);
 
-    auto default_density =
-        gauge::po::value<std::vector<double> >()->default_value(
-            density, "")->multitoken();
+    auto default_nonzero_symbols =
+        gauge::po::value<std::vector<uint32_t> >()->default_value(
+            nonzero_symbols, "")->multitoken();
 
     options.add_options()
-        ("density", default_density, "Set the density of the sparse codes");
+        ("nonzero_symbols",
+         default_nonzero_symbols,
+         "Set the number of nonzero symbols of the sparse codes");
 
     gauge::runner::instance().register_options(options);
 }
 
+//------------------------------------------------------------------
+// FullRLNC
+//------------------------------------------------------------------
 
 typedef throughput_benchmark<
     kodo::full_rlnc_encoder<fifi::binary>,
@@ -494,6 +501,55 @@ BENCHMARK_F(setup_rlnc_throughput2325, FullRLNC, Prime2325, 5)
     run_benchmark();
 }
 
+//------------------------------------------------------------------
+// BackwardFullRLNC
+//------------------------------------------------------------------
+
+typedef throughput_benchmark<
+    kodo::full_rlnc_encoder<fifi::binary>,
+    kodo::backward_full_rlnc_decoder<fifi::binary> >
+    setup_backward_rlnc_throughput;
+
+BENCHMARK_F(setup_backward_rlnc_throughput, BackwardFullRLNC, Binary, 5)
+{
+    run_benchmark();
+}
+
+typedef throughput_benchmark<
+    kodo::full_rlnc_encoder<fifi::binary8>,
+    kodo::backward_full_rlnc_decoder<fifi::binary8> >
+    setup_backward_rlnc_throughput8;
+
+BENCHMARK_F(setup_backward_rlnc_throughput8, BackwardFullRLNC, Binary8, 5)
+{
+    run_benchmark();
+}
+
+typedef throughput_benchmark<
+    kodo::full_rlnc_encoder<fifi::binary16>,
+    kodo::backward_full_rlnc_decoder<fifi::binary16> >
+    setup_backward_rlnc_throughput16;
+
+BENCHMARK_F(setup_backward_rlnc_throughput16, BackwardFullRLNC, Binary16, 5)
+{
+    run_benchmark();
+}
+
+typedef throughput_benchmark<
+    kodo::full_rlnc_encoder<fifi::prime2325>,
+    kodo::backward_full_rlnc_decoder<fifi::prime2325> >
+    setup_backward_rlnc_throughput2325;
+
+BENCHMARK_F(setup_backward_rlnc_throughput2325, BackwardFullRLNC, Prime2325, 5)
+{
+    run_benchmark();
+}
+
+
+//------------------------------------------------------------------
+// FullDelayedRLNC
+//------------------------------------------------------------------
+
 typedef throughput_benchmark<
    kodo::full_rlnc_encoder<fifi::binary>,
    kodo::full_delayed_rlnc_decoder<fifi::binary> >