weaving-pattern-builder.hpp

Go to the documentation of this file.

/*
  WEAVING-PATTERN-BUILDER.hpp  -  build an invocation pattern for media calculations

   Copyright (C)
     2024,            Hermann Vosseler <Ichthyostega@web.de>

  **Lumiera** is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License as published by the
  Free Software Foundation; either version 2 of the License, or (at your
  option) any later version. See the file COPYING for further details.

*/


#ifndef STEAM_ENGINE_WEAVING_PATTERN_BUILDER_H
#define STEAM_ENGINE_WEAVING_PATTERN_BUILDER_H

//#include "steam/common.hpp"
#include "lib/error.hpp"
#include "lib/symbol.hpp"
//#include "steam/engine/channel-descriptor.hpp"
//#include "vault/gear/job.h"
#include "lib/several-builder.hpp"
#include "steam/engine/proc-id.hpp"
#include "steam/engine/turnout.hpp"
#include "steam/engine/engine-ctx.hpp"
#include "steam/engine/buffer-provider.hpp"
#include "steam/engine/buffhandle-attach.hpp"  
#include "lib/test/test-helper.hpp" 
#include "lib/format-string.hpp"
//#include "lib/util-foreach.hpp"
//#include "lib/iter-adapter.hpp"
//#include "lib/meta/function.hpp"
//#include "lib/itertools.hpp"
#include "lib/util.hpp"

//#include <utility>
#include <functional>
//#include <array>
#include <vector>
#include <string>


namespace steam {
namespace engine {
  namespace err = lumiera::error;
  
  using StrView = std::string_view;
  using std::forward;
  using lib::Literal;
  using lib::Several;
  using lib::Depend;
  using util::_Fmt;
  using util::max;
  
  
  namespace {// Introspection helpers....
    
    using lib::meta::_Fun;
    using lib::meta::is_BinaryFun;
    using std::remove_reference_t;
    
    template<class FUN>
    struct _ProcFun
      {
        static_assert(_Fun<FUN>()         , "something funktion-like required");
        static_assert(is_BinaryFun<FUN>() , "function with two arguments expected");
        
        using ArgI = remove_reference_t<typename _Fun<FUN>::Args::List::Head>;
        using ArgO = remove_reference_t<typename _Fun<FUN>::Args::List::Tail::Head>;
        
        template<class ARG>
        struct MatchBuffArray
          {
            static_assert(not sizeof(ARG), "processing function expected to take array-of-buffer-pointers");
          };
        template<class BUF, size_t N>
        struct MatchBuffArray<std::array<BUF*,N>>
          {
            using Buff = BUF;
            enum{ SIZ = N };
          };
        
        using BuffI = typename MatchBuffArray<ArgI>::Buff;
        using BuffO = typename MatchBuffArray<ArgO>::Buff;
        
        enum{ FAN_I = MatchBuffArray<ArgI>::SIZ
            , FAN_O = MatchBuffArray<ArgO>::SIZ
            };
      };
    
    
    template<class FUN>
    inline constexpr uint
    manifoldSiz()
    {
      using _F = _ProcFun<FUN>;
      auto constexpr bound = std::max (_F::FAN_I, _F::FAN_O);
      static_assert (bound <= 10,
           "Limitation of template instances exceeded");
      return bound < 3? bound
           : bound < 6? 5
                      : 10;
    }
  }//(End)Introspection helpers.
  
  
  template<class MAN, class FUN>
  struct SimpleFunctionInvocationAdapter
    : MAN
    {
      using BuffI = typename _ProcFun<FUN>::BuffI;
      using BuffO = typename _ProcFun<FUN>::BuffO;
      
      enum{ N = MAN::STORAGE_SIZ
          , FAN_I = _ProcFun<FUN>::FAN_I
          , FAN_O = _ProcFun<FUN>::FAN_O
      };
      
      static_assert(FAN_I <= N and FAN_O <= N);
      
      using ArrayI = std::array<BuffI*, FAN_I>;
      using ArrayO = std::array<BuffO*, FAN_O>;
      
      
      FUN process;
      
      ArrayI inParam;
      ArrayO outParam;
      
      template<typename...INIT>
      SimpleFunctionInvocationAdapter (INIT&& ...funSetup)
        : process{forward<INIT> (funSetup)...}
        { }
      
      
      void
      connect (uint fanIn, uint fanOut)
        {
          REQUIRE (fanIn >= FAN_I and fanOut >= FAN_O);
          for (uint i=0; i<FAN_I; ++i)
            inParam[i] = & MAN::inBuff[i].template accessAs<BuffI>();
          for (uint i=0; i<FAN_O; ++i)
            outParam[i] = & MAN::outBuff[i].template accessAs<BuffO>();
        }
      
      void
      invoke()
        {
          process (inParam, outParam);
        }
    };
  
  template<uint N, class FUN>
  struct DirectFunctionInvocation
    : util::MoveOnly
    {
      using Manifold = FeedManifold<N>;
      using Feed = SimpleFunctionInvocationAdapter<Manifold, FUN>;
      enum{ MAX_SIZ = N };
      
      std::function<Feed()> buildFeed;
      
      DirectFunctionInvocation(FUN fun)
        : buildFeed{[=]{ return Feed{fun}; }}
        { }
    };
  
  
  
  
  template<class POL, class I, class E=I>
  using DataBuilder = lib::SeveralBuilder<I,E, POL::template Policy>;
  
  template<uint siz>
  using SizMark = std::integral_constant<uint,siz>;
  

  
  template<class PAR, class BUILD, uint siz>
  struct PatternData
    : PAR
    {
      BUILD buildEntry;
      
      uint size() { return 1 + PAR::size(); }
      
      template<class DAB>
      void
      collectEntries (DAB& dataBuilder, uint cntElm =0, uint maxSiz =0)
        {
          PAR::collectEntries (dataBuilder, cntElm+1, max (siz,maxSiz));
          buildEntry (dataBuilder);
        }
      
      
      PatternData(PAR&& predecessor, BUILD&& entryBuilder)
        : PAR{move (predecessor)}
        , buildEntry{move (entryBuilder)}
        { }
    };
  
  struct PatternDataAnchor
    {
      uint size() { return 0; }
      
      template<class DAB>
      void
      collectEntries (DAB& dataBuilder, uint cntElm, uint maxSiz)
        {
          dataBuilder.reserve (cntElm, maxSiz);
        }
    };
  
  
  
  
  template<uint N, class FUN>
  using SimpleDirectInvoke = SimpleWeavingPattern<DirectFunctionInvocation<N,FUN>>;
  
  
  template<class POL, uint N, class FUN>
  struct WeavingBuilder
    : util::MoveOnly
    {
      using FunSpec = _ProcFun<FUN>;
      using TurnoutWeaving = Turnout<SimpleDirectInvoke<N,FUN>>;
      static constexpr SizMark<sizeof(TurnoutWeaving)> sizMark{};
      static constexpr uint FAN_I = FunSpec::FAN_I;
      static constexpr uint FAN_O = FunSpec::FAN_O;

      
      using TypeMarker = std::function<BuffDescr(BufferProvider&)>;
      using ProviderRef = std::reference_wrapper<BufferProvider>;
      
      DataBuilder<POL, PortRef> leadPorts;
      std::vector<TypeMarker>   buffTypes;
      std::vector<ProviderRef>  providers;
      
      uint resultSlot{0};
      
      Depend<EngineCtx> ctx;
      
      StrView nodeSymb_;
      StrView portSpec_;
      FUN fun_;
      
      template<typename...INIT>
      WeavingBuilder(FUN&& init, StrView nodeSymb, StrView portSpec, INIT&& ...alloInit)
        : leadPorts{forward<INIT> (alloInit)...}
        , nodeSymb_{nodeSymb}
        , portSpec_{portSpec}
        , fun_{move(init)}
        { }
      
      WeavingBuilder&&
      attachToLeadPort (ProcNode& lead, uint portNr)
        {
          if (leadPorts.size() >= FAN_I)
            throw err::Logic{_Fmt{"Builder: attempt to add further input, "
                                  "but all %d »input slots« of the processing function are already connected."}
                                 % FAN_I
                            };
          PortRef portRef{lead.getPort (portNr)};
          leadPorts.append (portRef);
          return move(*this);
        }
      
      template<class BU>
      WeavingBuilder&&
      appendBufferTypes (uint cnt)
        {
          if (buffTypes.size()+cnt > FAN_O)
            throw err::Logic{_Fmt{"Builder: attempt add %d further output buffers, "
                                  "while %d of %d possible outputs are already connected."}
                                 % cnt % buffTypes.size() % FAN_O
                            };
          while (cnt--)
            buffTypes.emplace_back([](BufferProvider& provider)
                                    { return provider.getDescriptor<BU>(); });
          ENSURE (buffTypes.size() <= N);
          return move(*this);
        }
      
      WeavingBuilder&&
      fillRemainingBufferTypes()
        {
          using BuffO = typename FunSpec::BuffO;
          uint cnt = FAN_O - buffTypes.size();
          return appendBufferTypes<BuffO>(cnt);
        }
      
      WeavingBuilder&&
      connectRemainingInputs (DataBuilder<POL, ProcNodeRef>& knownLeads, uint defaultPort)
        {
          REQUIRE (leadPorts.size() <= FAN_I);
          uint cnt = FAN_I - leadPorts.size();
          if (FAN_I > knownLeads.size())
            throw err::Logic{_Fmt{"Builder: attempt to auto-connect %d further »input slots«, "
                                  "but this ProcNode has only %d predecessor nodes, while the "
                                  "given processing function expects %d inputs."}
                                 % cnt % knownLeads.size() % FAN_I
                            };
          while (cnt--)
            attachToLeadPort (knownLeads[leadPorts.size()], defaultPort);
          return move(*this);
        }
      
      WeavingBuilder&&
      selectResultSlot (uint idx)
        {
          this->resultSlot = idx;
          return move(*this);
        }
      
      
      auto
      build()
        {
          // discard excess storage prior to allocating the output types sequence
          leadPorts.shrinkFit();
          
          maybeFillDefaultProviders (buffTypes.size());
          REQUIRE (providers.size() == buffTypes.size());
          auto outTypes = DataBuilder<POL, BuffDescr>{leadPorts.policyConnect()}
                                     .reserve (buffTypes.size());
          uint i=0;
          for (auto& typeConstructor : buffTypes)
            outTypes.append (
              typeConstructor (providers[i++]));
          
          ENSURE (leadPorts.size() <= N);
          ENSURE (leadPorts.size() == FunSpec::FAN_I);
          ENSURE (outTypes.size()  <= N);
          ENSURE (outTypes.size()  == FunSpec::FAN_O);
          
          using PortDataBuilder = DataBuilder<POL, Port>;
          // provide a free-standing functor to build a suitable Port impl (≙Turnout)
          return [leads = move(leadPorts.build())
                 ,types = move(outTypes.build())
                 ,procFun = move(fun_)
                 ,resultIdx = resultSlot
                 ,procID = ProcID::describe (nodeSymb_,portSpec_)
                 ]
                 (PortDataBuilder& portData) mutable -> void
                   {
                     portData.template emplace<TurnoutWeaving> (procID
                                                               ,move(leads)
                                                               ,move(types)
                                                               ,resultIdx
                                                               ,move(procFun)
                                                               );
                   };
        }
      
      private:
        void
        maybeFillDefaultProviders (size_t maxSlots)
          {
            for (uint i=providers.size(); i < maxSlots; ++i)
              providers.emplace_back (ctx().mem);
          }
    };
  
  
  
}}// namespace steam::engine
#endif /*STEAM_ENGINE_WEAVING_PATTERN_BUILDER_H*/