diff --git a/cmake/ManageCompilationFlags.cmake b/cmake/ManageCompilationFlags.cmake
index dca53533..937fafe1 100644
--- a/cmake/ManageCompilationFlags.cmake
+++ b/cmake/ManageCompilationFlags.cmake
@@ -35,12 +35,13 @@ set(NeonCXXFlags
 
         #Add GCC specific compiler flags here
 		#-Wno-class-memaccess for "writing to an object of type XXX with no trivial copy-assignment; use copy-assignment or copy-initialization instead"
-        $<$<CXX_COMPILER_ID:GNU>:-m64 -Wall -Wextra -Werror -Wno-unused-function -Wno-deprecated-declarations -Wno-class-memaccess>
+        $<$<CXX_COMPILER_ID:GNU>:-m64 -Wall -Wextra -Werror -Wno-unused-function -Wno-deprecated-declarations -Wno-class-memaccess -Wno-deprecated-declarations>
 
         #Add Clang specific compiler flags here
-        $<$<CXX_COMPILER_ID:Clang>:-m64 -Wall -Wextra -Werror -Wno-unused-function -Wno-deprecated-declarations>
+        $<$<CXX_COMPILER_ID:Clang>:-m64 -Wall -Wextra -Werror -Wno-unused-function -Wno-deprecated-declarations -Wno-deprecated-copy -Wno-unused-parameter -Wno-unused-private-field -Wno-braced-scalar-init -Wno-unused-variable -Wno-unused-but-set-variable -Wno-deprecated-declarations >
         )
 
+set(MSVC_XCOMPILER_FLAGS "/openmp /std:c++17")
 set(NeonCUDAFlags
         # Optimization flags for Release
         $<$<CXX_COMPILER_ID:GNU>: $<$<CONFIG:Release>:-O3> >
@@ -51,7 +52,7 @@ set(NeonCUDAFlags
         # Host compiler
         $<$<CXX_COMPILER_ID:GNU>:-Xcompiler -fopenmp -std=c++17 $<$<CONFIG:Release>:-O3> $<$<CONFIG:Debug>:-O0> >
         $<$<CXX_COMPILER_ID:Clang>:-Xcompiler -fopenmp -std=c++17 $<$<CONFIG:Release>:-O3> $<$<CONFIG:Debug>:-O0>>
-        $<$<CXX_COMPILER_ID:MSVC>:-Xcompiler /std:c++17>
+        $<$<CXX_COMPILER_ID:MSVC>:-Xcompiler ${MSVC_XCOMPILER_FLAGS}>
         #Disables warning
         #177-D "function XXX was declared but never referenced"
         -Xcudafe "--display_error_number --diag_suppress=177"
diff --git a/cmake/Nvtx.cmake b/cmake/Nvtx.cmake
index 50ad7242..d7ff6df2 100644
--- a/cmake/Nvtx.cmake
+++ b/cmake/Nvtx.cmake
@@ -9,4 +9,4 @@ if (${NEON_USE_NVTX})
 	message(STATUS "NVTX Ranges is enabled")
 else ()
 	message(STATUS "NVTX Ranges is disabled")
-endif ()
\ No newline at end of file
+endif ()
diff --git a/libNeonCore/include/Neon/core/tools/Logger.h b/libNeonCore/include/Neon/core/tools/Logger.h
index 913a738c..3fa791e3 100644
--- a/libNeonCore/include/Neon/core/tools/Logger.h
+++ b/libNeonCore/include/Neon/core/tools/Logger.h
@@ -53,7 +53,12 @@ LIBNEONCORE_EXPORT extern Logger LoggerObj;
 
 }  // namespace Neon
 
+#if defined( NEON_ACTIVETE_TRACING)
 #define NEON_TRACE(...) ::Neon::globalSpace::LoggerObj.getLogger()->trace(__VA_ARGS__)
+#else
+#define NEON_TRACE(...)
+#endif
+
 #define NEON_INFO(...) ::Neon::globalSpace::LoggerObj.getLogger()->info(__VA_ARGS__)
 #define NEON_WARNING(...)                                                                         \
     ::Neon::globalSpace::LoggerObj.getLogger()->warn("Line {} File {}", __LINE__, __FILE__); \
diff --git a/libNeonDomain/include/Neon/domain/interface/FieldBase.h b/libNeonDomain/include/Neon/domain/interface/FieldBase.h
index b1f197af..4e9006fc 100644
--- a/libNeonDomain/include/Neon/domain/interface/FieldBase.h
+++ b/libNeonDomain/include/Neon/domain/interface/FieldBase.h
@@ -4,6 +4,7 @@
 #include "Neon/core/tools/io/IODense.h"
 #include "Neon/core/types/Macros.h"
 
+#include "Neon/set/Containter.h"
 #include "Neon/set/DataConfig.h"
 #include "Neon/set/DevSet.h"
 #include "Neon/set/HuOptions.h"
@@ -12,7 +13,6 @@
 #include "GridBase.h"
 #include "Neon/domain/interface/common.h"
 
-
 namespace Neon::domain::interface {
 
 template <typename T, int C>
@@ -25,8 +25,8 @@ class FieldBase
 
     FieldBase();
 
-    FieldBase(const std::string              fieldUserName,
-              const std::string              fieldClassName,
+    FieldBase(const std::string&             fieldUserName,
+              const std::string&             fieldClassName,
               const Neon::index_3d&          dimension,
               int                            cardinality,
               T                              outsideVal,
@@ -57,6 +57,10 @@ class FieldBase
     virtual auto haloUpdate(Neon::set::HuOptions& opt)
         -> void = 0;
 
+    virtual auto haloUpdateContainer(Neon::set::TransferMode    transferMode,
+                                     Neon::set::StencilSemantic stencilSemantic) const
+        -> Neon::set::Container;
+
     auto getDimension() const
         -> const Neon::index_3d&;
 
diff --git a/libNeonDomain/include/Neon/domain/interface/FieldBaseTemplate.h b/libNeonDomain/include/Neon/domain/interface/FieldBaseTemplate.h
index 2ba43eca..fa913e2e 100644
--- a/libNeonDomain/include/Neon/domain/interface/FieldBaseTemplate.h
+++ b/libNeonDomain/include/Neon/domain/interface/FieldBaseTemplate.h
@@ -6,7 +6,7 @@
 
 #include "Neon/set/DataConfig.h"
 #include "Neon/set/DevSet.h"
-#include "Neon/set/MultiDeviceObjectInterface.h"
+#include "Neon/set/MultiXpuDataInterface.h"
 #include "Neon/set/memory/memSet.h"
 
 #include "Neon/domain/interface/FieldBase.h"
@@ -21,7 +21,7 @@ template <typename T /** Field's cell metadata type */,
           typename P /** Type of a Partition */,
           typename S /** Storage type */>
 class FieldBaseTemplate : public FieldBase<T, C>,
-                          public Neon::set::interface::MultiDeviceObjectInterface<P, S>
+                          public Neon::set::interface::MultiXpuDataInterface<P, S>
 {
    public:
     using Partition = P;
diff --git a/libNeonDomain/include/Neon/domain/interface/FieldBaseTemplate_imp.h b/libNeonDomain/include/Neon/domain/interface/FieldBaseTemplate_imp.h
index 7156200d..870f859e 100644
--- a/libNeonDomain/include/Neon/domain/interface/FieldBaseTemplate_imp.h
+++ b/libNeonDomain/include/Neon/domain/interface/FieldBaseTemplate_imp.h
@@ -157,7 +157,7 @@ auto FieldBaseTemplate<T, C, G, P, S>::swapUIDBeforeFullSwap(FieldBaseTemplate::
         NEON_THROW(exp);
 
     }
-    Neon::set::interface::MultiDeviceObjectInterface<P, S>::swapUIDs(A,B);
+    Neon::set::interface::MultiXpuDataInterface<P, S>::swapUIDs(A,B);
 }
 
 
diff --git a/libNeonDomain/include/Neon/domain/interface/FieldBase_imp.h b/libNeonDomain/include/Neon/domain/interface/FieldBase_imp.h
index 098c325d..326759c7 100644
--- a/libNeonDomain/include/Neon/domain/interface/FieldBase_imp.h
+++ b/libNeonDomain/include/Neon/domain/interface/FieldBase_imp.h
@@ -13,8 +13,8 @@ FieldBase<T, C>::FieldBase()
 }
 
 template <typename T, int C>
-FieldBase<T, C>::FieldBase(const std::string              FieldBaseUserName,
-                           const std::string              fieldClassName,
+FieldBase<T, C>::FieldBase(const std::string&             FieldBaseUserName,
+                           const std::string&             fieldClassName,
                            const Neon::index_3d&          dimension,
                            int                            cardinality,
                            T                              outsideVal,
@@ -274,6 +274,13 @@ auto FieldBase<T, C>::getClassName() const -> const std::string&
     return mStorage->className;
 }
 
+template <typename T, int C>
+auto FieldBase<T, C>::haloUpdateContainer(Neon::set::TransferMode,
+                                          Neon::set::StencilSemantic) const -> Neon::set::Container
+{
+    NEON_THROW_UNSUPPORTED_OPERATION("");
+}
+
 template <typename T, int C>
 FieldBase<T, C>::Storage::Storage(const std::string              FieldBaseUserName,
                                   const std::string              fieldClassName,
diff --git a/libNeonDomain/include/Neon/domain/internal/bGrid/bGrid_imp.h b/libNeonDomain/include/Neon/domain/internal/bGrid/bGrid_imp.h
index 3bdef78c..ee36e209 100644
--- a/libNeonDomain/include/Neon/domain/internal/bGrid/bGrid_imp.h
+++ b/libNeonDomain/include/Neon/domain/internal/bGrid/bGrid_imp.h
@@ -309,6 +309,7 @@ auto bGrid::dot(const std::string&               name,
     return Neon::set::Container::factoryOldManaged(
         name,
         Neon::set::internal::ContainerAPI::DataViewSupport::on,
+        Neon::set::ContainerPatternType::reduction,
         *this, [&](Neon::set::Loader& loader) {
             loader.load(input1);
             if (input1.getUid() != input2.getUid()) {
@@ -372,6 +373,7 @@ auto bGrid::norm2(const std::string&               name,
     return Neon::set::Container::factoryOldManaged(
         name,
         Neon::set::internal::ContainerAPI::DataViewSupport::on,
+        Neon::set::ContainerPatternType::reduction,
         *this, [&](Neon::set::Loader& loader) {
             loader.load(input);
 
diff --git a/libNeonDomain/include/Neon/domain/internal/dGrid/dField.h b/libNeonDomain/include/Neon/domain/internal/dGrid/dField.h
index e9f1632b..ff70f7a8 100644
--- a/libNeonDomain/include/Neon/domain/internal/dGrid/dField.h
+++ b/libNeonDomain/include/Neon/domain/internal/dGrid/dField.h
@@ -43,7 +43,7 @@ class dField : public Neon::domain::interface::FieldBaseTemplate<T,
 
     dField() = default;
 
-    ~dField() = default;
+    virtual ~dField() = default;
 
     auto self() -> Self&;
 
@@ -61,14 +61,18 @@ class dField : public Neon::domain::interface::FieldBaseTemplate<T,
     auto haloUpdate(Neon::set::HuOptions& opt) const
         -> void final;
 
+    auto haloUpdateContainer(Neon::set::TransferMode,
+                             Neon::set::StencilSemantic)
+        const -> Neon::set::Container final;
+
     auto haloUpdate(SetIdx setIdx, Neon::set::HuOptions& opt) const
-        -> void;  //TODO add this function to the API if performance boost is reasonable -> void final;
+        -> void;  // TODO add this function to the API if performance boost is reasonable -> void final;
 
     auto haloUpdate(Neon::set::HuOptions& opt)
         -> void final;
 
     auto haloUpdate(SetIdx setIdx, Neon::set::HuOptions& opt)
-        -> void;  //TODO add this function to the API if performance boost is reasonable -> void final;
+        -> void;  // TODO add this function to the API if performance boost is reasonable -> void final;
 
     virtual auto getReference(const Neon::index_3d& idx,
                               const int&            cardinality)
@@ -188,4 +192,6 @@ class dField : public Neon::domain::interface::FieldBaseTemplate<T,
     Neon::MemoryOptions mMemoryOptions;
 };
 
+
+
 }  // namespace Neon::domain::internal::dGrid
diff --git a/libNeonDomain/include/Neon/domain/internal/dGrid/dFieldDev.h b/libNeonDomain/include/Neon/domain/internal/dGrid/dFieldDev.h
index 9c4d8c9b..ad43f36a 100644
--- a/libNeonDomain/include/Neon/domain/internal/dGrid/dFieldDev.h
+++ b/libNeonDomain/include/Neon/domain/internal/dGrid/dFieldDev.h
@@ -87,7 +87,7 @@ class dFieldDev
 
     ~dFieldDev() = default;
 
-    auto uid() const -> Neon::set::MultiDeviceObjectUid;
+    auto uid() const -> Neon::set::dataDependency::MultiXpuDataUid;
 
     auto grid() -> grid_t&;
 
diff --git a/libNeonDomain/include/Neon/domain/internal/dGrid/dFieldDev_imp.h b/libNeonDomain/include/Neon/domain/internal/dGrid/dFieldDev_imp.h
index 04449e69..c9bfd809 100644
--- a/libNeonDomain/include/Neon/domain/internal/dGrid/dFieldDev_imp.h
+++ b/libNeonDomain/include/Neon/domain/internal/dGrid/dFieldDev_imp.h
@@ -74,10 +74,10 @@ auto dFieldDev<T, C>::operator=(dFieldDev&& other) -> dFieldDev&
 }
 
 template <typename T, int C>
-auto dFieldDev<T, C>::uid() const -> Neon::set::MultiDeviceObjectUid
+auto dFieldDev<T, C>::uid() const -> Neon::set::dataDependency::MultiXpuDataUid
 {
     void*                           addr = static_cast<void*>(m_data.get());
-    Neon::set::MultiDeviceObjectUid uidRes = (size_t)addr;
+    Neon::set::dataDependency::MultiXpuDataUid uidRes = (size_t)addr;
     return uidRes;
 }
 
diff --git a/libNeonDomain/include/Neon/domain/internal/dGrid/dField_imp.h b/libNeonDomain/include/Neon/domain/internal/dGrid/dField_imp.h
index a5ecb9cd..9902675f 100644
--- a/libNeonDomain/include/Neon/domain/internal/dGrid/dField_imp.h
+++ b/libNeonDomain/include/Neon/domain/internal/dGrid/dField_imp.h
@@ -351,7 +351,7 @@ auto dField<T, C>::getPartition(Neon::Execution       execution,
     -> const Partition&
 {
     const Neon::DataUse dataUse = this->getDataUse();
-    bool       isOk = Neon::ExecutionUtils::checkCompatibility(dataUse, execution);
+    bool                isOk = Neon::ExecutionUtils::checkCompatibility(dataUse, execution);
     if (isOk) {
         if (execution == Neon::Execution::device) {
             return m_gpu.getPartition(Neon::DeviceType::CUDA, setIdx, dataView);
@@ -438,6 +438,7 @@ template <typename T, int C>
 auto dField<T, C>::haloUpdate(Neon::set::HuOptions& opt) const
     -> void
 {
+    NEON_TRACE("haloUpdate stream {} transferMode {} ", opt.streamSetIdx(), Neon::set::TransferModeUtils::toString(opt.transferMode()));
     auto& bk = self().getBackend();
     auto  fieldDev = field(bk.devType());
     switch (opt.transferMode()) {
@@ -458,13 +459,19 @@ auto dField<T, C>::haloUpdate(Neon::SetIdx          setIdx,
                               Neon::set::HuOptions& opt) const
     -> void
 {
+
+
     auto& bk = self().getBackend();
     auto  fieldDev = field(bk.devType());
     switch (opt.transferMode()) {
         case Neon::set::TransferMode::put:
+            NEON_TRACE("TRACE haloUpdate PUT setIdx {} stream {} transferMode {} ", setIdx.idx(), opt.streamSetIdx(), Neon::set::TransferModeUtils::toString(opt.transferMode()));
+
             fieldDev.template haloUpdate<Neon::set::TransferMode::put>(setIdx, bk, -1, opt.startWithBarrier(), opt.streamSetIdx());
             break;
         case Neon::set::TransferMode::get:
+            NEON_TRACE("TRACE haloUpdate GET setIdx {} stream {} transferMode {} ", setIdx.idx(), opt.streamSetIdx(), Neon::set::TransferModeUtils::toString(opt.transferMode()));
+
             fieldDev.template haloUpdate<Neon::set::TransferMode::get>(setIdx, bk, -1, opt.startWithBarrier(), opt.streamSetIdx());
             break;
         default:
@@ -477,6 +484,8 @@ template <typename T, int C>
 auto dField<T, C>::haloUpdate(Neon::set::HuOptions& opt)
     -> void
 {
+    NEON_TRACE("haloUpdate stream {} transferMode {} ", opt.streamSetIdx(), Neon::set::TransferModeUtils::toString(opt.transferMode()));
+
     auto& bk = self().getBackend();
     auto  fieldDev = field(bk.devType());
     switch (opt.transferMode()) {
@@ -501,9 +510,17 @@ auto dField<T, C>::haloUpdate(Neon::SetIdx          setIdx,
     auto  fieldDev = field(bk.devType());
     switch (opt.transferMode()) {
         case Neon::set::TransferMode::put:
+#pragma omp critical
+        {
+            NEON_TRACE("TRACE haloUpdate PUT setIdx {} stream {} transferMode {} ", setIdx.idx(), opt.streamSetIdx(), Neon::set::TransferModeUtils::toString(opt.transferMode()));
+        }
             fieldDev.template haloUpdate<Neon::set::TransferMode::put>(setIdx, bk, -1, opt.startWithBarrier(), opt.streamSetIdx());
             break;
         case Neon::set::TransferMode::get:
+#pragma omp critical
+        {
+            NEON_TRACE("TRACE haloUpdate GET setIdx {} stream {} transferMode {} ", setIdx.idx(), opt.streamSetIdx(), Neon::set::TransferModeUtils::toString(opt.transferMode()));
+        }
             fieldDev.template haloUpdate<Neon::set::TransferMode::get>(setIdx, bk, -1, opt.startWithBarrier(), opt.streamSetIdx());
             break;
         default:
@@ -512,6 +529,46 @@ auto dField<T, C>::haloUpdate(Neon::SetIdx          setIdx,
     }
 }
 
+
+template <typename T, int C>
+auto dField<T, C>::
+    haloUpdateContainer(Neon::set::TransferMode    transferMode,
+                        Neon::set::StencilSemantic stencilSemantic)
+        const -> Neon::set::Container
+{
+    Neon::set::Container dataTransferContainer =
+        Neon::set::Container::factoryDataTransfer(*this,
+                                                  transferMode,
+                                                  stencilSemantic);
+
+    Neon::set::Container SyncContainer =
+        Neon::set::Container::factorySynchronization(*this,
+                                                     Neon::set::SynchronizationContainerType::hostOmpBarrier);
+    Neon::set::container::Graph graph(this->getBackend());
+    const auto&                 dataTransferNode = graph.addNode(dataTransferContainer);
+    const auto&                 syncNode = graph.addNode(SyncContainer);
+
+    switch (transferMode) {
+        case Neon::set::TransferMode::put:
+            graph.addDependency(dataTransferNode, syncNode, Neon::GraphDependencyType::data);
+            break;
+        case Neon::set::TransferMode::get:
+            graph.addDependency(syncNode, dataTransferNode, Neon::GraphDependencyType::data);
+            break;
+        default:
+            NEON_THROW_UNSUPPORTED_OPTION();
+            break;
+    }
+
+    graph.removeRedundantDependencies();
+
+    Neon::set::Container output =
+        Neon::set::Container::factoryGraph("dGrid-Halo-Update",
+                                           graph,
+                                           [](Neon::SetIdx, Neon::set::Loader&) {});
+    return output;
+}
+
 template <typename T, int C>
 auto dField<T, C>::dot(Neon::set::patterns::BlasSet<T>& blasSet,
                        const dField<T>&                 input,
@@ -584,4 +641,5 @@ auto dField<T, C>::swap(dField::Field& A, dField::Field& B) -> void
     std::swap(A, B);
 }
 
+
 }  // namespace Neon::domain::internal::dGrid
diff --git a/libNeonDomain/include/Neon/domain/internal/dGrid/dGrid.h b/libNeonDomain/include/Neon/domain/internal/dGrid/dGrid.h
index c58212ac..c4c40120 100644
--- a/libNeonDomain/include/Neon/domain/internal/dGrid/dGrid.h
+++ b/libNeonDomain/include/Neon/domain/internal/dGrid/dGrid.h
@@ -58,7 +58,7 @@ class dGrid : public Neon::domain::interface::GridBaseTemplate<dGrid, dCell>
 
     dGrid(const dGrid& rhs) = default;
 
-    ~dGrid() = default;
+    virtual ~dGrid() = default;
 
     /**
      * Constructor compatible with the general grid API
@@ -88,7 +88,7 @@ class dGrid : public Neon::domain::interface::GridBaseTemplate<dGrid, dCell>
      * Creates a new Field
      */
     template <typename T, int C = 0>
-    auto newField(const std::string   fieldUserName,
+    auto newField(const std::string&  fieldUserName,
                   int                 cardinality,
                   T                   inactiveValue,
                   Neon::DataUse       dataUse = Neon::DataUse::IO_COMPUTE,
@@ -183,7 +183,7 @@ class dGrid : public Neon::domain::interface::GridBaseTemplate<dGrid, dCell>
 
         Neon::index_3d                                       halo;
         std::vector<Neon::set::DataSet<PartitionIndexSpace>> partitionIndexSpaceVec;
-        Neon::sys::patterns::Engine                          reduceEngine;        
+        Neon::sys::patterns::Engine                          reduceEngine;
     };
     std::shared_ptr<data_t> m_data;
 };
diff --git a/libNeonDomain/include/Neon/domain/internal/dGrid/dGrid_imp.h b/libNeonDomain/include/Neon/domain/internal/dGrid/dGrid_imp.h
index f40e51f5..2270e533 100644
--- a/libNeonDomain/include/Neon/domain/internal/dGrid/dGrid_imp.h
+++ b/libNeonDomain/include/Neon/domain/internal/dGrid/dGrid_imp.h
@@ -110,7 +110,7 @@ dGrid::dGrid(const Neon::Backend&                    backend,
 
 
 template <typename T, int C>
-auto dGrid::newField(const std::string   fieldUserName,
+auto dGrid::newField(const std::string&  fieldUserName,
                      int                 cardinality,
                      [[maybe_unused]] T  inactiveValue,
                      Neon::DataUse       dataUse,
@@ -162,11 +162,11 @@ auto dGrid::getContainer(const std::string& name,
 {
     const Neon::index_3d& defaultBlockSize = getDefaultBlock();
     Neon::set::Container  kContainer = Neon::set::Container::factory(name,
-                                                                    Neon::set::internal::ContainerAPI::DataViewSupport::on,
-                                                                    *this,
-                                                                    lambda,
-                                                                    defaultBlockSize,
-                                                                    [](const Neon::index_3d&) { return size_t(0); });
+                                                                     Neon::set::internal::ContainerAPI::DataViewSupport::on,
+                                                                     *this,
+                                                                     lambda,
+                                                                     defaultBlockSize,
+                                                                     [](const Neon::index_3d&) { return size_t(0); });
     return kContainer;
 }
 
@@ -180,11 +180,11 @@ auto dGrid::getContainer(const std::string& name,
 {
     const Neon::index_3d& defaultBlockSize = getDefaultBlock();
     Neon::set::Container  kContainer = Neon::set::Container::factory(name,
-                                                                    Neon::set::internal::ContainerAPI::DataViewSupport::on,
-                                                                    *this,
-                                                                    lambda,
-                                                                    blockSize,
-                                                                    [sharedMem](const Neon::index_3d&) { return sharedMem; });
+                                                                     Neon::set::internal::ContainerAPI::DataViewSupport::on,
+                                                                     *this,
+                                                                     lambda,
+                                                                     blockSize,
+                                                                     [sharedMem](const Neon::index_3d&) { return sharedMem; });
     return kContainer;
 }
 
@@ -219,6 +219,7 @@ auto dGrid::dot(const std::string&               name,
         return Neon::set::Container::factoryOldManaged(
             name,
             Neon::set::internal::ContainerAPI::DataViewSupport::on,
+            Neon::set::ContainerPatternType::reduction,
             *this, [&](Neon::set::Loader& loader) {
                 loader.load(input1);
                 if (input1.getUid() != input2.getUid()) {
@@ -245,6 +246,7 @@ auto dGrid::dot(const std::string&               name,
         return Neon::set::Container::factoryOldManaged(
             name,
             Neon::set::internal::ContainerAPI::DataViewSupport::on,
+            Neon::set::ContainerPatternType::reduction,
             *this, [&](Neon::set::Loader& loader) {
                 loader.load(input1);
                 if (input1.getUid() != input2.getUid()) {
@@ -307,6 +309,7 @@ auto dGrid::norm2(const std::string&               name,
         return Neon::set::Container::factoryOldManaged(
             name,
             Neon::set::internal::ContainerAPI::DataViewSupport::on,
+            Neon::set::ContainerPatternType::reduction,
             *this, [&](Neon::set::Loader& loader) {
                 loader.load(input);
 
@@ -330,6 +333,7 @@ auto dGrid::norm2(const std::string&               name,
         return Neon::set::Container::factoryOldManaged(
             name,
             Neon::set::internal::ContainerAPI::DataViewSupport::on,
+            Neon::set::ContainerPatternType::reduction,
             *this, [&](Neon::set::Loader& loader) {
                 loader.load(input);
 
diff --git a/libNeonDomain/include/Neon/domain/internal/eGrid/eField.h b/libNeonDomain/include/Neon/domain/internal/eGrid/eField.h
index 36936198..7ee651f5 100644
--- a/libNeonDomain/include/Neon/domain/internal/eGrid/eField.h
+++ b/libNeonDomain/include/Neon/domain/internal/eGrid/eField.h
@@ -142,6 +142,14 @@ class eField : public Neon::domain::interface::FieldBaseTemplate<T,
     auto haloUpdate(Neon::set::HuOptions& opt)
         -> void final;
 
+    auto haloUpdate(Neon::SetIdx          setIdx,
+                    Neon::set::HuOptions& opt)
+        -> void;
+
+    auto haloUpdateContainer(Neon::set::TransferMode    transferMode,
+                             Neon::set::StencilSemantic stencilSemantic)
+        const -> Neon::set::Container final;
+
     static auto swap(Field& A, Field& B) -> void;
 
    private:
@@ -201,6 +209,7 @@ class eField : public Neon::domain::interface::FieldBaseTemplate<T,
     auto helpUpdate(const Neon::set::StreamSet& streamSet,
                     const Neon::DeviceType&     devEt)
         -> void;
+
     /**
      *
      * @param streamSet
@@ -223,4 +232,5 @@ class eField : public Neon::domain::interface::FieldBaseTemplate<T,
     Neon::set::DataConfig m_dataConfig;
 };
 
+
 }  // namespace Neon::domain::internal::eGrid
diff --git a/libNeonDomain/include/Neon/domain/internal/eGrid/eFieldDev.h b/libNeonDomain/include/Neon/domain/internal/eGrid/eFieldDev.h
index 2c9d8330..29bb5520 100644
--- a/libNeonDomain/include/Neon/domain/internal/eGrid/eFieldDev.h
+++ b/libNeonDomain/include/Neon/domain/internal/eGrid/eFieldDev.h
@@ -67,7 +67,7 @@ class eFieldDevice_t
         std::array<
             std::array<
                 std::vector<Neon::set::Transfer>,
-                Neon::set::TransferSemanticUtils::nOptions>,
+                Neon::set::StencilSemanticUtils::nOptions>,
             Neon::set::TransferModeUtils::nOptions>
             m_haloUpdateInfo;
     };
@@ -125,7 +125,7 @@ class eFieldDevice_t
                     for (auto mode : {Neon::set::TransferMode::get, Neon::set::TransferMode::put}) {
 
                         {  // (GET,PUT), FORWARD, GRID
-                            const auto           structure = Neon::set::TransferSemantic::grid;
+                            const auto           structure = Neon::set::StencilSemantic::standard;
                             auto&                transfers = h_haloUpdateInfo(mode, structure);
                             Neon::set::HuOptions huOptions(mode, transfers, structure);
                             this->haloUpdate__(m_data->grid->getBackend(), huOptions);
@@ -142,8 +142,8 @@ class eFieldDevice_t
         }
     }
 
-    auto h_haloUpdateInfo(Neon::set::TransferMode     mode,
-                          Neon::set::TransferSemantic structure)
+    auto h_haloUpdateInfo(Neon::set::TransferMode    mode,
+                          Neon::set::StencilSemantic structure)
         -> std::vector<Neon::set::Transfer>&
     {
         return m_data->m_haloUpdateInfo[static_cast<int>(mode)]
@@ -200,10 +200,10 @@ class eFieldDevice_t
      * Returns a unique identifier for this type of DataSet
      * @return
      */
-    auto uid() const -> Neon::set::MultiDeviceObjectUid
+    auto uid() const -> Neon::set::dataDependency::MultiXpuDataUid
     {
-        void*                           addr = static_cast<void*>(m_data.get());
-        Neon::set::MultiDeviceObjectUid uidRes = (size_t)addr;
+        void*                                      addr = static_cast<void*>(m_data.get());
+        Neon::set::dataDependency::MultiXpuDataUid uidRes = (size_t)addr;
         return uidRes;
     }
 
@@ -491,7 +491,7 @@ class eFieldDevice_t
 #pragma omp parallel for num_threads(ompNDevs) default(shared)
                 for (int setIdx = 0; setIdx < nDevs; setIdx++) {
                     for (int cardIdx = 0; cardIdx < self().cardinality(); cardIdx++) {
-                        constexpr auto structure = Neon::set::TransferSemantic::grid;
+                        constexpr auto structure = Neon::set::StencilSemantic::standard;
 
                         auto& peerTransferOpt = opt.getPeerTransferOpt(bk);
                         h_huSoAByCardSingleDevFwd(peerTransferOpt,
@@ -562,6 +562,106 @@ class eFieldDevice_t
         }  //------------------------------------------------
     }
 
+    auto haloUpdate__(const Neon::Backend&  bk,
+                      Neon::SetIdx          setIdx,
+                      Neon::set::HuOptions& opt) const
+        -> void
+    {
+
+        // No halo update operation can be performed on a filed where halo was not activated.
+        if (m_data->haloStatus != Neon::domain::haloStatus_et::ON) {
+            NEON_THROW_UNSUPPORTED_OPERATION("Halo support was not activated for this field.");
+        }
+
+        // We don't need any update if the number of devices is one.
+        if (m_data->devSet.setCardinality() == 1) {
+            return;
+        }
+
+        // If we are in execution mode, then we use on omp thread per device
+        // If we are in storeInfo mode, then we use only one thread, which will
+        // insert information on the transfer vectors sequentially
+
+        // This sync goes before the following loop.
+        // This is a complete barrier over the stream and
+        // it can not be put inside the loop
+        // The sync is done only if opt.isExecuteMode() == true
+        if (opt.startWithBarrier() && opt.isExecuteMode()) {
+            bk.sync(opt.streamSetIdx());
+        }
+
+        // Different behaviour base on the data layout
+        switch (m_data->memOrder) {
+            case Neon::memLayout_et::order_e::structOfArrays: {
+                    for (int cardIdx = 0; cardIdx < self().cardinality(); cardIdx++) {
+                        constexpr auto structure = Neon::set::StencilSemantic::standard;
+
+                        auto& peerTransferOpt = opt.getPeerTransferOpt(bk);
+                        h_huSoAByCardSingleDevFwd(peerTransferOpt,
+                                                  setIdx,
+                                                  cardIdx,
+                                                  structure);
+                    }
+
+                break;
+            }
+            //------------------------------------------------
+            case Neon::memLayout_et::order_e::arrayOfStructs: {
+
+                    // ARRAYS OF STRUCTURES
+                    // -> for each voxel the components are stored contiguously
+                    // -> We follow the same configuration either for Lattice or Standard
+                    // -> We use the Standard as reference
+
+                    const int            dstIdx = setIdx.idx();
+                    LocalIndexingInfo_t& dst = m_data->frame_shp->template localIndexingInfo<Neon::Access::readWrite>(dstIdx);
+
+                    const std::array<internals::partition_idx, ComDirection_e::COM_NUM>
+                        srcIdx = {dst.nghIdx(ComDirection_e::COM_DW),
+                                  dst.nghIdx(ComDirection_e::COM_UP)};
+
+                    for (const auto& comDirection : {ComDirection_e::COM_DW,
+                                                     ComDirection_e::COM_UP}) {
+
+                        // In terms of elements we need to a number of values
+                        // equivalent to the number of elements (voxels)
+                        // by the number of values per element (=cardinality)
+                        count_t      transferEl = dst.remoteBdrCount(comDirection) * self().cardinality();
+                        Cell::Offset remoteOffset = dst.remoteBdrOff(comDirection);
+                        Cell::Offset localOffset = dst.ghostOff(comDirection);
+
+                        T_ta*       dstMem = m_data->memoryStorage.mem(dstIdx);
+                        const T_ta* srcMem = m_data->memoryStorage.mem(srcIdx[comDirection]);
+
+                        T_ta*       dstBuf = dstMem + localOffset;
+                        const T_ta* srcBuf = srcMem + remoteOffset;
+
+                        // For partition 0, communication are only in the UP direction
+                        if (setIdx.idx() == 0 && comDirection == ComDirection_e::COM_DW)
+                            continue;
+
+                        // For the last, communication are only in the DW direction
+                        if (setIdx.idx() == (bk.devSet().setCardinality() - 1) && comDirection == ComDirection_e::COM_UP)
+                            continue;
+
+                        assert(transferEl > -1);
+                        if (transferEl > 0) {
+                            // auto&                             streamSet = bk.streamSet(opt.streamSetIdx());
+                            Neon::set::Transfer::Endpoint_t srcEndPoint(srcIdx[comDirection], (void*)srcBuf);
+                            Neon::set::Transfer::Endpoint_t dstEndPoint(dstIdx, (void*)dstBuf);
+
+                            Neon::set::Transfer transfer(opt.transferMode(),
+                                                         dstEndPoint,
+                                                         srcEndPoint,
+                                                         transferEl * sizeof(T_ta));
+
+                            m_data->devSet.peerTransfer(opt.getPeerTransferOpt(bk), transfer);
+                        }
+                    }
+
+            }
+        }  //------------------------------------------------
+    }
     /**
      * Do Update by cardinality
      * @param bk
@@ -656,7 +756,7 @@ class eFieldDevice_t
 
                         Neon::set::PeerTransferOption& peerTransferOpt = huOptions.getPeerTransferOpt(bk);
                         // LATTICE + FORWARD
-                        constexpr auto structure = Neon::set::TransferSemantic::lattice;
+                        constexpr auto structure = Neon::set::StencilSemantic::streaming;
 
                         h_huSoAByCardSingleDevFwd(peerTransferOpt,
                                                   gpuIdx, cardIdx,
@@ -808,7 +908,7 @@ class eFieldDevice_t
     auto h_huSoAByCardSingleDevFwd(Neon::set::PeerTransferOption opt,
                                    int                           devIdx,
                                    const int                     cardIdx,
-                                   Neon::set::TransferSemantic   structure) const
+                                   Neon::set::StencilSemantic    structure) const
         -> void
     {
         const Neon::Backend& bk = m_data->grid->getBackend();
@@ -846,7 +946,7 @@ class eFieldDevice_t
                 }
             }
 
-            if (structure == Neon::set::TransferSemantic::lattice) {
+            if (structure == Neon::set::StencilSemantic::streaming) {
                 index_3d dir = grid().getStencil().neighbours().at(cardIdx);
                 switch (comDirection) {
                     case ComDirection_e::COM_DW: {
diff --git a/libNeonDomain/include/Neon/domain/internal/eGrid/eField_imp.h b/libNeonDomain/include/Neon/domain/internal/eGrid/eField_imp.h
index cc7be9bf..f0eda664 100644
--- a/libNeonDomain/include/Neon/domain/internal/eGrid/eField_imp.h
+++ b/libNeonDomain/include/Neon/domain/internal/eGrid/eField_imp.h
@@ -372,6 +372,32 @@ auto eField<T, C>::haloUpdate(Neon::set::HuOptions& opt) const
     fieldDev.haloUpdate__(bk, opt);
 }
 
+template <typename T, int C>
+auto eField<T, C>::haloUpdate(Neon::SetIdx          setIdx,
+                              Neon::set::HuOptions& opt)
+    -> void
+{
+    auto field = [this](const Neon::DeviceType& devType) {
+        switch (devType) {
+            case Neon::DeviceType::CPU:
+            case Neon::DeviceType::OMP: {
+                return mCpu;
+            }
+            case Neon::DeviceType::CUDA: {
+                return mGpu;
+            }
+            default: {
+                NeonException exp("eField_t");
+                exp << "Incompatible device parameter.";
+                NEON_THROW(exp);
+            }
+        }
+    };
+    auto& bk = self().getBackend();
+    auto  fieldDev = field(bk.devType());
+    fieldDev.haloUpdate__(bk, setIdx, opt);
+}
+
 template <typename T, int C>
 auto eField<T, C>::haloUpdate(Neon::set::HuOptions& opt)
     -> void
@@ -397,10 +423,51 @@ auto eField<T, C>::haloUpdate(Neon::set::HuOptions& opt)
     fieldDev.haloUpdate__(bk, opt);
 }
 
+
+template <typename T, int C>
+auto eField<T, C>::
+    haloUpdateContainer(Neon::set::TransferMode    transferMode,
+                        Neon::set::StencilSemantic stencilSemantic)
+        const -> Neon::set::Container
+{
+    Neon::set::Container dataTransferContainer =
+        Neon::set::Container::factoryDataTransfer(*this,
+                                                  transferMode,
+                                                  stencilSemantic);
+
+    Neon::set::Container SyncContainer =
+        Neon::set::Container::factorySynchronization(*this,
+                                                     Neon::set::SynchronizationContainerType::hostOmpBarrier);
+
+    Neon::set::container::Graph graph(this->getBackend());
+    const auto&                 dataTransferNode = graph.addNode(dataTransferContainer);
+    const auto&                 syncNode = graph.addNode(SyncContainer);
+
+    switch (transferMode) {
+        case Neon::set::TransferMode::put:
+            graph.addDependency(dataTransferNode, syncNode, Neon::GraphDependencyType::data);
+            break;
+        case Neon::set::TransferMode::get:
+            graph.addDependency(syncNode, dataTransferNode, Neon::GraphDependencyType::data);
+            break;
+        default:
+            NEON_THROW_UNSUPPORTED_OPTION();
+            break;
+    }
+
+    graph.removeRedundantDependencies();
+
+    Neon::set::Container output =
+        Neon::set::Container::factoryGraph("dGrid-Halo-Update",
+                                           graph,
+                                           [](Neon::SetIdx, Neon::set::Loader&) {});
+    return output;
+}
+
 template <typename T, int C>
 auto eField<T, C>::swap(Field& A, Field& B) -> void
 {
-    Neon::domain::interface::FieldBaseTemplate<T, C, typename Self::Grid, typename Self::Partition, int>::swapUIDBeforeFullSwap(A,B);
+    Neon::domain::interface::FieldBaseTemplate<T, C, typename Self::Grid, typename Self::Partition, int>::swapUIDBeforeFullSwap(A, B);
     std::swap(A, B);
 }
 
diff --git a/libNeonDomain/include/Neon/domain/patterns/PatternScalar.h b/libNeonDomain/include/Neon/domain/patterns/PatternScalar.h
index a4fdff78..1653f202 100644
--- a/libNeonDomain/include/Neon/domain/patterns/PatternScalar.h
+++ b/libNeonDomain/include/Neon/domain/patterns/PatternScalar.h
@@ -1,13 +1,13 @@
 #pragma once
 #include "Neon/set/Backend.h"
-#include "Neon/set/MultiDeviceObjectInterface.h"
+#include "Neon/set/MultiXpuDataInterface.h"
 #include "Neon/set/patterns/BlasSet.h"
 
 namespace Neon {
 
 template <typename T>
 class PatternScalar
-    : public set::interface::MultiDeviceObjectInterface<PatternScalar<T>, int>
+    : public set::interface::MultiXpuDataInterface<PatternScalar<T>, int>
 {
 
    public:
@@ -37,7 +37,7 @@ class PatternScalar
     /**
      * Returns a unique identifier to be used for the loading process
      */
-    auto uid() const -> Neon::set::MultiDeviceObjectUid;
+    auto uid() const -> Neon::set::dataDependency::MultiXpuDataUid;
 
     auto getPartition(const Neon::DeviceType& devType,
                       const Neon::SetIdx&     idx,
@@ -81,6 +81,8 @@ class PatternScalar
      */
     auto operator()(const Neon::DataView& dataView) -> T&;
 
+    auto getName() const -> std::string;
+
    private:
     auto updateIO(int streamId = 0)
         -> void final;
@@ -110,6 +112,8 @@ class PatternScalar
     T standardResult;
 };
 
+
+
 }  // namespace Neon
 
 #include "Neon/domain/patterns/PatternScalar_imp.h"
\ No newline at end of file
diff --git a/libNeonDomain/include/Neon/domain/patterns/PatternScalar_imp.h b/libNeonDomain/include/Neon/domain/patterns/PatternScalar_imp.h
index 06d516b8..23215dc4 100644
--- a/libNeonDomain/include/Neon/domain/patterns/PatternScalar_imp.h
+++ b/libNeonDomain/include/Neon/domain/patterns/PatternScalar_imp.h
@@ -45,10 +45,10 @@ auto PatternScalar<T>::operator()() const -> const T&
 }
 
 template <typename T>
-auto PatternScalar<T>::uid() const -> Neon::set::MultiDeviceObjectUid
+auto PatternScalar<T>::uid() const -> Neon::set::dataDependency::MultiXpuDataUid
 {
     void*                           addr = static_cast<void*>(mData.get());
-    Neon::set::MultiDeviceObjectUid uidRes = (size_t)addr;
+    Neon::set::dataDependency::MultiXpuDataUid uidRes = (size_t)addr;
     return uidRes;
 }
 
@@ -189,6 +189,11 @@ auto PatternScalar<T>::getBlasSet(const Neon::DataView& dataView) -> Neon::set::
     }
 }
 
+template <typename T>
+auto PatternScalar<T>::getName() const -> std::string
+{
+    return "PatternScalar";
+}
 
 extern template class PatternScalar<float>;
 extern template class PatternScalar<double>;
diff --git a/libNeonDomain/include/Neon/domain/tools/TestData.h b/libNeonDomain/include/Neon/domain/tools/TestData.h
index 97c1b9c7..6cafe8c2 100644
--- a/libNeonDomain/include/Neon/domain/tools/TestData.h
+++ b/libNeonDomain/include/Neon/domain/tools/TestData.h
@@ -4,6 +4,7 @@
 #include "Neon/set/Backend.h"
 #include "Neon/set/MemoryOptions.h"
 
+#include "Neon/Neon.h"
 #include "Neon/domain/interface/Stencil.h"
 #include "Neon/domain/tools/Geometries.h"
 #include "Neon/domain/tools/IODomain.h"
@@ -131,6 +132,8 @@ TestData<G, T, C>::TestData(const Neon::Backend&         backend,
                             const domain::Stencil&       stencil,
                             Type                         outsideValue)
 {
+    Neon::init();
+
     mGeometry = geometry;
     Neon::domain::tool::GeometryMask geometryMask(geometry,
                                                   dimension,
diff --git a/libNeonDomain/src/domain/internal/dGrid/dGrid.cpp b/libNeonDomain/src/domain/internal/dGrid/dGrid.cpp
index 94e2e007..3d837b8e 100644
--- a/libNeonDomain/src/domain/internal/dGrid/dGrid.cpp
+++ b/libNeonDomain/src/domain/internal/dGrid/dGrid.cpp
@@ -104,7 +104,8 @@ auto dGrid::getLaunchParameters(const Neon::DataView  dataView,
                 dims[i].z = dims[i].z - m_zBoundaryRadius * 2;
                 if (dims[i].z <= 0 && dims.size() > 1) {
                     NeonException exp("dGrid");
-                    exp << "The grid size is too small to support the data view model correctly";
+                    exp << "The grid size is too small to support the data view model correctly \n";
+                    exp << dims[i] << " for setIdx "<< i << " and device " << getDevSet().devId(i);
                     NEON_THROW(exp);
                 }
             }
diff --git a/libNeonDomain/tests/unit/domain-unit-test-staggered-grid/src/RunHelper.h b/libNeonDomain/tests/unit/domain-unit-test-staggered-grid/src/RunHelper.h
index bcb34847..d8008953 100644
--- a/libNeonDomain/tests/unit/domain-unit-test-staggered-grid/src/RunHelper.h
+++ b/libNeonDomain/tests/unit/domain-unit-test-staggered-grid/src/RunHelper.h
@@ -35,7 +35,7 @@ void runAllTestConfiguration(const std::string&,
         std::vector<int> cardinalityTest{1};
         // nGpuTest = std::vector<int>(1,1);
 
-        std::vector<Neon::index_3d> dimTest{{60, 10, 250}, {10, 50, 80}};
+        std::vector<Neon::index_3d> dimTest{{60, 40, 250}, {10, 50, 80}};
         std::vector<Neon::Runtime>  runtimeE{Neon::Runtime::openmp, Neon::Runtime::stream};
         // std::vector<Neon::index_3d> dimTest{{3}};
         // std::vector<Neon::Runtime>  runtimeE{Neon::Runtime::stream};
diff --git a/libNeonDomain/tests/unit/domain-unit-test-staggered-grid/src/staggeredGrid.cpp b/libNeonDomain/tests/unit/domain-unit-test-staggered-grid/src/staggeredGrid.cpp
index 3f28187c..9c506bce 100644
--- a/libNeonDomain/tests/unit/domain-unit-test-staggered-grid/src/staggeredGrid.cpp
+++ b/libNeonDomain/tests/unit/domain-unit-test-staggered-grid/src/staggeredGrid.cpp
@@ -235,7 +235,7 @@ int getNGpus()
 }
 }  // namespace
 
-TEST(Map, dGrid)
+TEST(DISABLED_Map, dGrid)
 {
     Neon::init();
     int nGpus = getNGpus();
@@ -244,7 +244,7 @@ TEST(Map, dGrid)
     runAllTestConfiguration<Grid, Type, 0>("staggeredGrid", StaggeredGrid_Map<Grid, Type, 0>, nGpus, 1);
 }
 
-TEST(VoxToNodes, dGrid)
+TEST(DISABLED_CodeVoxToNodes, dGrid)
 {
     Neon::init();
     int nGpus = getNGpus();
@@ -253,7 +253,7 @@ TEST(VoxToNodes, dGrid)
     runAllTestConfiguration<Grid, Type, 0>("staggeredGrid", StaggeredGrid_VoxToNodes<Grid, Type, 0>, nGpus, 1);
 }
 
-TEST(NodeToVoxels, dGrid)
+TEST(DISABLED_NodeToVoxels, dGrid)
 {
     Neon::init();
     int nGpus = getNGpus();
diff --git a/libNeonDomain/tests/unit/domainUt_sGrid/src/sGrid.cu b/libNeonDomain/tests/unit/domainUt_sGrid/src/sGrid.cu
index 6cc1d031..98856f54 100644
--- a/libNeonDomain/tests/unit/domainUt_sGrid/src/sGrid.cu
+++ b/libNeonDomain/tests/unit/domainUt_sGrid/src/sGrid.cu
@@ -6,7 +6,7 @@
 #include "Neon/domain/aGrid.h"
 #include "Neon/domain/dGrid.h"
 #include "Neon/domain/eGrid.h"
-//#include "Neon/domain/sGrid.h"
+// #include "Neon/domain/sGrid.h"
 #include "Neon/skeleton/Options.h"
 #include "Neon/skeleton/Skeleton.h"
 
@@ -114,16 +114,16 @@ void sGridTestContainerRun(TestData<G, T, C>& data)
         auto& X = data.getField(FieldNames::X);
         auto& Y = data.getField(FieldNames::Y);
 
-        dim.forEach([&](int x, int y, int z) {
-#pragma omp critial
-            {
-                index_3d newE(x, y, z);
-                if (X.isInsideDomain(newE)) {
-                    if (X(newE, 0) % 2 == 0) {
-                        elements.push_back(newE);
-                    }
+        dim.forEach<Neon::computeMode_t::seq>([&](int x, int y, int z) {
+            // #pragma omp critial
+            //             {
+            index_3d newE(x, y, z);
+            if (X.isInsideDomain(newE)) {
+                if (X(newE, 0) % 2 == 0) {
+                    elements.push_back(newE);
                 }
             }
+            //            }
         });
 
         Neon::domain::sGrid<G> sGrid(grid, elements);
@@ -223,15 +223,15 @@ void sGridTestSkeleton(TestData<G, T, C>& data)
         auto& Y = data.getField(FieldNames::Y);
 
         dim.template forEach<Neon::computeMode_t::seq>([&](int x, int y, int z) {
-#pragma omp critial
-            {
-                index_3d newE(x, y, z);
-                if (X.isInsideDomain(newE)) {
-                    if (X(newE, 0) % 2 == 0) {
-                        elements.push_back(newE);
-                    }
+            // #pragma omp critial
+            //             {
+            index_3d newE(x, y, z);
+            if (X.isInsideDomain(newE)) {
+                if (X(newE, 0) % 2 == 0) {
+                    elements.push_back(newE);
                 }
             }
+            //            }
         });
 
         Neon::domain::sGrid<G> sGrid(grid, elements);
diff --git a/libNeonSet/CMakeLists.txt b/libNeonSet/CMakeLists.txt
index 3a867537..98d5d5fc 100644
--- a/libNeonSet/CMakeLists.txt
+++ b/libNeonSet/CMakeLists.txt
@@ -27,6 +27,10 @@ target_include_directories(libNeonSet PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/includ
 
 source_group(TREE ${CMAKE_CURRENT_LIST_DIR} PREFIX "libNeonSet" FILES ${libNeonSetFiles})
 
+if(${NEON_USE_NVTX})
+	target_link_libraries(libNeonSet PUBLIC ${CUDA_nvToolsExt_LIBRARY})
+endif()
+
 if (${BUILD_NEON_TESTING})
 	add_subdirectory("tests")
 endif()
diff --git a/libNeonSet/include/Neon/set/Backend.h b/libNeonSet/include/Neon/set/Backend.h
index 22f40fcc..bdfa34b7 100644
--- a/libNeonSet/include/Neon/set/Backend.h
+++ b/libNeonSet/include/Neon/set/Backend.h
@@ -139,34 +139,34 @@ class Backend
 
     auto eventSet(Neon::EventIdx eventdx)
         -> Neon::set::GpuEventSet&;
-    /**
-     * Extract a stream base in the provided streamIds.
-     * The method uses a circular policy to select the stream.
-     * The parameter rotateIdx is the index used to store the
-     * state of the circular polity in between calls.
-     *
-     * @param rotateIdx
-     * @param streamIdxVec
-     * @return
-     */
-    auto streamSetRotate(int&                    rotateIdx,
-                         const std::vector<int>& streamIdxVec)
-        const
-        -> const Neon::set::StreamSet&;
-
-    /**
-     * Extract a stream base in the provided streamIds.
-     * The method uses a circular policy to select the stream.
-     * The parameter rotateIdx is the index used to store the
-     * state of the circular polity in between calls.
-     *
-     * @param rotateIdx
-     * @param streamIdxVec
-     * @return
-     */
-    static auto streamSetIdxRotate(int&                    rotateIdx,
-                                   const std::vector<int>& streamIdxVec)
-        -> int;
+//    /**
+//     * Extract a stream base in the provided streamIds.
+//     * The method uses a circular policy to select the stream.
+//     * The parameter rotateIdx is the index used to store the
+//     * state of the circular polity in between calls.
+//     *
+//     * @param rotateIdx
+//     * @param streamIdxVec
+//     * @return
+//     */
+//    auto streamSetRotate(int&                    rotateIdx,
+//                         const std::vector<int>& streamIdxVec)
+//        const
+//        -> const Neon::set::StreamSet&;
+//
+//    /**
+//     * Extract a stream base in the provided streamIds.
+//     * The method uses a circular policy to select the stream.
+//     * The parameter rotateIdx is the index used to store the
+//     * state of the circular polity in between calls.
+//     *
+//     * @param rotateIdx
+//     * @param streamIdxVec
+//     * @return
+//     */
+//    static auto streamSetIdxRotate(int&                    rotateIdx,
+//                                   const std::vector<int>& streamIdxVec)
+//        -> int;
 
     /**
      *
@@ -213,14 +213,14 @@ class Backend
 
     auto waitEventOnStream(Neon::SetIdx setIdx, int eventId, int streamId)
         -> void;
-    /**
-     * Create a set of cuda events to create an exit barrier.
-     * I.e. one streams sync with all the others
-     * The stream holding the barrier is the first in the streamIdxVec vector.
-     *
-     * @param streamIdxVec
-     */
-    auto streamEventBarrier(const std::vector<int>& streamIdxVec) -> void;
+//    /**
+//     * Create a set of cuda events to create an exit barrier.
+//     * I.e. one streams sync with all the others
+//     * The stream holding the barrier is the first in the streamIdxVec vector.
+//     *
+//     * @param streamIdxVec
+//     */
+//    auto streamEventBarrier(const std::vector<int>& streamIdxVec) -> void;
 
     auto getMemoryOptions(Neon::MemoryLayout order) const
         -> Neon::MemoryOptions;
@@ -242,6 +242,7 @@ class Backend
     std::string toString() const;
 
     auto toReport(Neon::Report& report, Report::SubBlock* subdocAPI = nullptr) const -> void;
+    void syncEvent(SetIdx setIdx, int eventIdx) const;
 };
 
 }  // namespace Neon
diff --git a/libNeonSet/include/Neon/set/Containter.h b/libNeonSet/include/Neon/set/Containter.h
index b9114e14..2d4cc22a 100644
--- a/libNeonSet/include/Neon/set/Containter.h
+++ b/libNeonSet/include/Neon/set/Containter.h
@@ -1,21 +1,22 @@
 #pragma once
 
 #include "Neon/set/DevSet.h"
-#include "Neon/set/dependencyTools/DataParsing.h"
 #include "functional"
 #include "type_traits"
 
 #include "Neon/set/container/ContainerAPI.h"
-#include "Neon/set/container/HostManagedSyncType.h"
-#include "Neon/set/container/Loader.h"
+#include "Neon/set/container/types/HostManagedSyncType.h"
+#include "Neon/set/container/types/SynchronizationContainerType.h"
 
 namespace Neon::set {
 
+struct Loader;
 
 struct Container
 {
    public:
     Container() = default;
+    virtual ~Container() = default;
 
     /**
      * Run a Neon Container on a given stream and with a given data view
@@ -74,6 +75,7 @@ struct Container
               typename UserLoadingLambdaT>
     static auto factoryOldManaged(const std::string&                                 name,
                                   Neon::set::internal::ContainerAPI::DataViewSupport dataViewSupport,
+                                  Neon::set::ContainerPatternType                    patternType,
                                   DataContainerT                                     a,
                                   const UserLoadingLambdaT&                          f)
         -> Container;
@@ -105,6 +107,17 @@ struct Container
                                              Container&         host)
         -> Container;
 
+    template <typename MultiXpuDataT>
+    static auto factoryDataTransfer(const MultiXpuDataT&        multiXpuData,
+                                    Neon::set::TransferMode     transferMode,
+                                    Neon::set::StencilSemantic transferSemantic)
+        -> Neon::set::Container;
+
+    template <typename MxpuDataT>
+    static auto factorySynchronization(const MxpuDataT&             multiXpuData,
+                                       SynchronizationContainerType syncType)
+        -> Container;
+
     static auto factoryAnchor(const std::string& name /**< A user's string to identify the computation done by the Container. */)
         -> Container;
 
diff --git a/libNeonSet/include/Neon/set/Containter_imp.h b/libNeonSet/include/Neon/set/Containter_imp.h
index 3c401836..a8cbd7da 100644
--- a/libNeonSet/include/Neon/set/Containter_imp.h
+++ b/libNeonSet/include/Neon/set/Containter_imp.h
@@ -1,17 +1,21 @@
 #pragma once
 
 #include "Neon/set/DevSet.h"
-#include "Neon/set/dependencyTools/DataParsing.h"
+
 #include "functional"
 #include "type_traits"
 
+#include "Neon/set/container/Loader.h"
+
+#include "Neon/set/container/DataTransferContainer.h"
 #include "Neon/set/container/DeviceContainer.h"
 #include "Neon/set/container/DeviceManagedContainer.h"
 #include "Neon/set/container/DeviceThenHostManagedContainer.h"
+#include "Neon/set/container/GraphContainer.h"
 #include "Neon/set/container/HostManagedContainer.h"
 #include "Neon/set/container/OldDeviceManagedContainer.h"
+#include "Neon/set/container/SynchronizationContainer.h"
 
-#include "Neon/set/container/GraphContainer.h"
 
 namespace Neon::set {
 
@@ -30,23 +34,27 @@ auto Container::factory(const std::string&                                 name,
                                                                                      blockSize, shMemSizeFun);
 
     std::shared_ptr<Neon::set::internal::ContainerAPI> tmp(k);
-    return Container(tmp);
+    return {tmp};
 }
 
 template <typename DataContainerT,
           typename UserLoadingLambdaT>
 auto Container::factoryOldManaged(const std::string&                                 name,
                                   Neon::set::internal::ContainerAPI::DataViewSupport dataViewSupport,
+                                  Neon::set::ContainerPatternType                    patternType,
                                   DataContainerT                                     a,
                                   const UserLoadingLambdaT&                          f)
     -> Container
 {
     using ManagedLaunch = typename std::invoke_result<decltype(f), Neon::set::Loader&>::type;
-    auto k = new Neon::set::internal::OldDeviceManagedContainer<DataContainerT, ManagedLaunch>(name, dataViewSupport,
-                                                                                               a, f);
+    auto k = new Neon::set::internal::OldDeviceManagedContainer<DataContainerT, ManagedLaunch>(name,
+                                                                                               dataViewSupport,
+                                                                                               patternType,
+                                                                                               a,
+                                                                                               f);
 
     std::shared_ptr<Neon::set::internal::ContainerAPI> tmp(k);
-    return Container(tmp);
+    return {tmp};
 }
 
 template <typename DataContainerT,
@@ -66,7 +74,7 @@ auto Container::factoryHostManaged(const std::string&
                                                                                           presSyncType);
 
     std::shared_ptr<Neon::set::internal::ContainerAPI> tmp(k);
-    return Container(tmp);
+    return {tmp};
 }
 
 template <typename DataContainerT,
@@ -82,8 +90,34 @@ auto Container::factoryDeviceManaged(const std::string&
                                                                                             a, f);
 
     std::shared_ptr<Neon::set::internal::ContainerAPI> tmp(k);
-    return Container(tmp);
+    return {tmp};
 }
 
+template <typename MultiXpuDataT>
+auto Container::
+    factoryDataTransfer(const MultiXpuDataT&       multiXpuData,
+                        Neon::set::TransferMode    transferMode,
+                        Neon::set::StencilSemantic transferSemantic)
+        -> Neon::set::Container
+{
+    auto k = new Neon::set::internal::DataTransferContainer(multiXpuData,
+                                                            transferMode,
+                                                            transferSemantic);
+
+    std::shared_ptr<Neon::set::internal::ContainerAPI> tmp(k);
+    return {tmp};
+}
+
+template <typename MxpuDataT>
+auto Container::
+    factorySynchronization(const MxpuDataT&             multiXpuData,
+                           SynchronizationContainerType syncType) -> Container
+{
+    auto k = new Neon::set::internal::SynchronizationContainer(multiXpuData,
+                                                               syncType);
+
+    std::shared_ptr<Neon::set::internal::ContainerAPI> tmp(k);
+    return {tmp};
+}
 
 }  // namespace Neon::set
diff --git a/libNeonSet/include/Neon/set/DataSet.h b/libNeonSet/include/Neon/set/DataSet.h
index b729db7b..782b2d77 100644
--- a/libNeonSet/include/Neon/set/DataSet.h
+++ b/libNeonSet/include/Neon/set/DataSet.h
@@ -2,7 +2,7 @@
 #include <vector>
 
 #include "Neon/core/types/DataView.h"
-#include "Neon/set/MultiDeviceObjectUid.h"
+#include "Neon/set/MultiXpuDataUid.h"
 #include "Neon/sys/devices/DevInterface.h"
 
 namespace Neon {
@@ -103,10 +103,11 @@ struct DataSet
      * Returns a unique identifier for the data set.
      * @return
      */
-    auto uid() -> MultiDeviceObjectUid
+    auto uid()
+        const -> Neon::set::dataDependency::MultiXpuDataUid
     {
-        T_ta*                addr = m_data.get();
-        MultiDeviceObjectUid uidRes = (size_t)addr;
+        T_ta* addr = m_data.get();
+        auto  uidRes = (Neon::set::dataDependency::MultiXpuDataUid)addr;
         return uidRes;
     }
 
@@ -114,7 +115,8 @@ struct DataSet
      *
      * @return
      */
-    auto local(Neon::DeviceType, SetIdx setIdx, const Neon::DataView& dataView = Neon::DataView::STANDARD)
+    auto local(Neon::DeviceType, SetIdx setIdx,
+               const Neon::DataView& dataView = Neon::DataView::STANDARD)
         -> T_ta&
     {
         (void)dataView;
diff --git a/libNeonSet/include/Neon/set/DevSet.h b/libNeonSet/include/Neon/set/DevSet.h
index c5d76092..6ade26ee 100644
--- a/libNeonSet/include/Neon/set/DevSet.h
+++ b/libNeonSet/include/Neon/set/DevSet.h
@@ -12,6 +12,7 @@
 #include <tuple>
 #include <type_traits>
 #include <vector>
+#include <omp.h>
 
 //#include "Neon/set/backend.h"
 #include "Neon/set/DataSet.h"
@@ -311,8 +312,9 @@ class DevSet
         const LaunchParameters& launchInfoSet = kernelConfig.launchInfoSet();
         const int               nGpus = int(m_devIds.size());
         {
-#pragma omp parallel for num_threads(nGpus) default(shared) firstprivate(lambdaHolder)
-            for (int idx = 0; idx < nGpus; idx++) {
+#pragma omp parallel num_threads(nGpus) default(shared) firstprivate(lambdaHolder)
+            {
+                int idx = omp_get_thread_num();
                 const Neon::sys::GpuDevice& dev = Neon::sys::globalSpace::gpuSysObj().dev(m_devIds[idx]);
                 // std::tuple<funParametersType_ta& ...>argsForIthGpuFunction(parametersVec.at(i) ...);
 
diff --git a/libNeonSet/include/Neon/set/GpuStreamSet.h b/libNeonSet/include/Neon/set/GpuStreamSet.h
index 23910675..03ea2200 100644
--- a/libNeonSet/include/Neon/set/GpuStreamSet.h
+++ b/libNeonSet/include/Neon/set/GpuStreamSet.h
@@ -2,6 +2,7 @@
 
 #include "Neon/set/GpuEventSet.h"
 #include "Neon/sys/devices/gpu/GpuStream.h"
+#include <omp.h>
 
 namespace Neon {
 namespace set {
@@ -143,8 +144,9 @@ class StreamSet
         // Without nDev>0, VS on debug mode displays this annoying message
         //"User Error 1001: argument to num_threads clause must be positive"
         if (run_et::et::sync == runMode && nDev > 0) {
-#pragma omp parallel for num_threads(nDev)
-            for (int idx = 0; idx < nDev; idx++) {
+#pragma omp parallel num_threads(nDev)
+            {
+                const int idx = omp_get_thread_num();
                 m_streamVec[idx].sync<runMode>();
             }
             return;
@@ -192,7 +194,7 @@ class StreamSet
      */
     auto validateId(SetIdx id) const
         -> void;
-};
+};  // namespace set
 
 }  // namespace set
 }  // End of namespace Neon
diff --git a/libNeonSet/include/Neon/set/HuOptions.h b/libNeonSet/include/Neon/set/HuOptions.h
index 779b79b8..5aff1a52 100644
--- a/libNeonSet/include/Neon/set/HuOptions.h
+++ b/libNeonSet/include/Neon/set/HuOptions.h
@@ -11,17 +11,17 @@ struct HuOptions
     bool                          m_startWithBarrier = true;
     int                           m_streamSetIdx = 0;
     Neon::set::PeerTransferOption m_peerTransferOpt;
-    Neon::set::TransferSemantic   m_structure;
+    Neon::set::StencilSemantic    m_structure;
 
    public:
     HuOptions(Neon::set::TransferMode     transferMode /*<                                          Mode of the transfer: put or get                                 */,
               bool                        startWithBarrier /*<                                      If true a barrier is executed before initiating the halo update */,
               int                         streamSetIdx = Neon::Backend::mainStreamIdx /*<                                      Target stream for the halo update                               */,
-              Neon::set::TransferSemantic structure = Neon::set::TransferSemantic::grid /*<    Structure on top of which the transfer is one: grid or lattice  */);
+              Neon::set::StencilSemantic structure = Neon::set::StencilSemantic::standard /*<    Structure on top of which the transfer is one: grid or lattice  */);
 
     HuOptions(Neon::set::TransferMode transferMode,
               NEON_OUT std::vector<Neon::set::Transfer>& transfers,
-              Neon::set::TransferSemantic                structure = Neon::set::TransferSemantic::grid);
+              Neon::set::StencilSemantic                 structure = Neon::set::StencilSemantic::standard);
 
     auto getPeerTransferOpt(const Neon::Backend& bk) -> Neon::set::PeerTransferOption&;
     auto startWithBarrier() const -> bool;
@@ -30,7 +30,7 @@ struct HuOptions
     auto operationMode() const -> Neon::set::PeerTransferOption::operationMode_e;
     auto transferMode() const -> Neon::set::TransferMode;
     auto isExecuteMode() const -> bool;
-    auto structure() -> Neon::set::TransferSemantic;
+    auto getSemantic() const -> Neon::set::StencilSemantic;
 };
 }  // namespace set
 }  // namespace Neon
diff --git a/libNeonSet/include/Neon/set/MultiDeviceObjectUid.h b/libNeonSet/include/Neon/set/MultiDeviceObjectUid.h
deleted file mode 100644
index d15fe9bc..00000000
--- a/libNeonSet/include/Neon/set/MultiDeviceObjectUid.h
+++ /dev/null
@@ -1,7 +0,0 @@
-#pragma once
-
-namespace Neon::set {
-
-using MultiDeviceObjectUid = size_t;
-
-}  // namespace Neon::set
diff --git a/libNeonSet/include/Neon/set/MultiDeviceObjectInterface.h b/libNeonSet/include/Neon/set/MultiXpuDataInterface.h
similarity index 69%
rename from libNeonSet/include/Neon/set/MultiDeviceObjectInterface.h
rename to libNeonSet/include/Neon/set/MultiXpuDataInterface.h
index f745f961..2eb64549 100644
--- a/libNeonSet/include/Neon/set/MultiDeviceObjectInterface.h
+++ b/libNeonSet/include/Neon/set/MultiXpuDataInterface.h
@@ -4,22 +4,22 @@
 
 #include "Neon/core/core.h"
 #include "Neon/core/types/Execution.h"
-#include "Neon/set/MultiDeviceObjectUid.h"
+#include "Neon/set/MultiXpuDataUid.h"
 
 namespace Neon::set::interface {
 
 template <typename P, typename S>
-class MultiDeviceObjectInterface
+class MultiXpuDataInterface
 {
    public:
     using Partition = P;
     using Storage = S;
 
-    using Self = MultiDeviceObjectInterface<Partition, Storage>;
+    using Self = MultiXpuDataInterface<Partition, Storage>;
 
-    virtual ~MultiDeviceObjectInterface() = default;
+    virtual ~MultiXpuDataInterface() = default;
 
-    MultiDeviceObjectInterface();
+    MultiXpuDataInterface();
 
     virtual auto updateIO(int streamId = 0)
         -> void = 0;
@@ -44,7 +44,7 @@ class MultiDeviceObjectInterface
 
     auto getStorage() const -> const Storage&;
 
-    auto getUid() const -> Neon::set::MultiDeviceObjectUid;
+    auto getUid() const -> Neon::set::dataDependency::MultiXpuDataUid;
 
    protected:
     static auto swapUIDs(Self& A, Self& B) -> void;
@@ -56,33 +56,33 @@ class MultiDeviceObjectInterface
 };
 
 template <typename P, typename S>
-auto MultiDeviceObjectInterface<P, S>::getStorage() -> Storage&
+auto MultiXpuDataInterface<P, S>::getStorage() -> Storage&
 {
     return *(mStorage.get());
 }
 template <typename P, typename S>
-auto MultiDeviceObjectInterface<P, S>::getStorage() const -> const Storage&
+auto MultiXpuDataInterface<P, S>::getStorage() const -> const Storage&
 {
     return *(mStorage.get());
 }
 
 template <typename P, typename S>
-auto MultiDeviceObjectInterface<P, S>::getUid() const -> Neon::set::MultiDeviceObjectUid
+auto MultiXpuDataInterface<P, S>::getUid() const -> Neon::set::dataDependency::MultiXpuDataUid
 {
     void*                           addr = static_cast<void*>(mUid.get());
-    Neon::set::MultiDeviceObjectUid uidRes = (size_t)addr;
+    Neon::set::dataDependency::MultiXpuDataUid uidRes = (size_t)addr;
     return uidRes;
 }
 
 template <typename P, typename S>
-MultiDeviceObjectInterface<P, S>::MultiDeviceObjectInterface()
+MultiXpuDataInterface<P, S>::MultiXpuDataInterface()
 {
     mStorage = std::make_shared<Storage>();
     mUid = std::make_shared<int>();
 }
 
 template <typename P, typename S>
-auto MultiDeviceObjectInterface<P, S>::swapUIDs(MultiDeviceObjectInterface::Self& A, MultiDeviceObjectInterface::Self& B) -> void
+auto MultiXpuDataInterface<P, S>::swapUIDs(MultiXpuDataInterface::Self& A, MultiXpuDataInterface::Self& B) -> void
 {
     std::swap(A.mUid,B.mUid);
 }
diff --git a/libNeonSet/include/Neon/set/MultiXpuDataUid.h b/libNeonSet/include/Neon/set/MultiXpuDataUid.h
new file mode 100644
index 00000000..490e9b99
--- /dev/null
+++ b/libNeonSet/include/Neon/set/MultiXpuDataUid.h
@@ -0,0 +1,8 @@
+#pragma once
+
+namespace Neon::set::dataDependency {
+
+using MultiXpuDataUid = size_t;
+using MultiXpuDataIdx = size_t;
+
+}  // namespace Neon::set::dataDependency
diff --git a/libNeonSet/include/Neon/set/Replica.h b/libNeonSet/include/Neon/set/Replica.h
index ee7bafa7..508b7944 100644
--- a/libNeonSet/include/Neon/set/Replica.h
+++ b/libNeonSet/include/Neon/set/Replica.h
@@ -3,7 +3,7 @@
 #include <memory>
 #include "Neon/set/Containter.h"
 #include "Neon/set/DevSet.h"
-#include "Neon/set/MultiDeviceObjectInterface.h"
+#include "Neon/set/MultiXpuDataInterface.h"
 
 
 namespace Neon::set::internal::datum {
@@ -69,7 +69,7 @@ namespace Neon::set {
  * @tparam Obj
  */
 template <typename Obj>
-class Replica : public Neon::set::interface::MultiDeviceObjectInterface<Neon::set::internal::datum::Partition<Obj>,
+class Replica : public Neon::set::interface::MultiXpuDataInterface<Neon::set::internal::datum::Partition<Obj>,
                                                                         Neon::set::internal::datum::Storage<Obj>>
 {
    public:
diff --git a/libNeonSet/include/Neon/set/SingletonSet.h b/libNeonSet/include/Neon/set/SingletonSet.h
index 6cdc7d12..bd91a577 100644
--- a/libNeonSet/include/Neon/set/SingletonSet.h
+++ b/libNeonSet/include/Neon/set/SingletonSet.h
@@ -72,10 +72,10 @@ struct SingletonSet
      * Returns a unique identifier for the data set.
      * @return
      */
-    auto uid() -> MultiDeviceObjectUid
+    auto uid() ->Neon::set::dataDependency::MultiXpuDataUid
     {
         T_ta*                addr = m_data.get();
-        MultiDeviceObjectUid uidRes = (size_t)addr;
+       Neon::set::dataDependency::MultiXpuDataUid uidRes = (size_t)addr;
         return uidRes;
     }
 
@@ -83,10 +83,10 @@ struct SingletonSet
      * Returns a unique identifier for the data set.
      * @return
      */
-    auto uid() const -> MultiDeviceObjectUid
+    auto uid() const ->Neon::set::dataDependency::MultiXpuDataUid
     {
         T_ta*                addr = m_data.get();
-        MultiDeviceObjectUid uidRes = (size_t)addr;
+       Neon::set::dataDependency::MultiXpuDataUid uidRes = (size_t)addr;
         return uidRes;
     }
 
diff --git a/libNeonSet/include/Neon/set/StencilSemantic.h b/libNeonSet/include/Neon/set/StencilSemantic.h
new file mode 100644
index 00000000..cd512ae7
--- /dev/null
+++ b/libNeonSet/include/Neon/set/StencilSemantic.h
@@ -0,0 +1,41 @@
+#pragma once
+#include <string>
+#include <vector>
+
+#include "Neon/core/core.h"
+
+namespace Neon::set {
+
+enum struct StencilSemantic
+{
+    standard = 0 /*<  Transfer for halo update on grid structure    */,
+    streaming = 1 /*< Transfer for halo update on lattice structure */
+};
+
+
+struct StencilSemanticUtils
+{
+    static constexpr int nOptions = 2;
+
+    static auto toString(StencilSemantic opt) -> std::string;
+    static auto fromString(const std::string& opt) -> StencilSemantic;
+    static auto getOptions() -> std::array<StencilSemantic, nOptions>;
+    
+    struct Cli
+    {
+        explicit Cli(std::string);
+        explicit Cli(StencilSemantic model);
+        Cli();
+
+        auto getOption() -> StencilSemantic;
+        auto set(const std::string& opt) -> void;
+        auto getStringOptions() -> std::string;
+
+       private:
+        bool mSet = false;
+        StencilSemantic mOption;
+    };
+};
+
+
+}  // namespace Neon::set
diff --git a/libNeonSet/include/Neon/set/Transfer.h b/libNeonSet/include/Neon/set/Transfer.h
index dbece3b9..1d2053b7 100644
--- a/libNeonSet/include/Neon/set/Transfer.h
+++ b/libNeonSet/include/Neon/set/Transfer.h
@@ -3,8 +3,8 @@
 #include <vector>
 
 #include "Neon/core/core.h"
+#include "Neon/set/StencilSemantic.h"
 #include "Neon/set/TransferMode.h"
-#include "Neon/set/TransferSemantic.h"
 
 namespace Neon {
 namespace set {
@@ -31,14 +31,14 @@ struct Transfer
     Endpoint_t       m_dst;
     Endpoint_t       m_src;
     size_t           m_size{0};
-    TransferSemantic m_structure;
+    StencilSemantic  m_structure;
 
    public:
     Transfer(TransferMode      mode,
              const Endpoint_t& dst,
              const Endpoint_t& src,
              size_t            size,
-             TransferSemantic  structure = TransferSemantic::grid)
+             StencilSemantic   structure = StencilSemantic::standard)
         : m_mode(mode), m_dst(dst), m_src(src), m_size(size), m_structure(structure)
     {
     }
@@ -96,14 +96,14 @@ struct PeerTransferOption
     operationMode_e        m_operationMode = Neon::set::PeerTransferOption::execute;
     TransferMode           m_transferMode = Neon::set::TransferMode::get;
 
-    Neon::set::TransferSemantic m_structure;
+    Neon::set::StencilSemantic m_structure;
 
    public:
     /**
      * Constructor with stream parameter
      */
     explicit PeerTransferOption(TransferMode                tranferMode,
-                                Neon::set::TransferSemantic structure)
+                                Neon::set::StencilSemantic structure)
         : m_transfers(nullptr),
           m_streamSet(nullptr),
           m_operationMode(operationMode_e::execute),
@@ -120,7 +120,7 @@ struct PeerTransferOption
      */
     PeerTransferOption(TransferMode                    tranferMode,
                        std::vector<Transfer>& NEON_OUT transfers,
-                       Neon::set::TransferSemantic     structure)
+                       Neon::set::StencilSemantic      structure)
         : m_transfers(&transfers),
           m_streamSet(nullptr),
           m_operationMode(operationMode_e::storeInfo),
@@ -180,7 +180,7 @@ struct PeerTransferOption
         return *m_transfers;
     }
 
-    auto structure() const -> const Neon::set::TransferSemantic&
+    auto structure() const -> const Neon::set::StencilSemantic&
     {
         return m_structure;
     }
diff --git a/libNeonSet/include/Neon/set/TransferSemantic.h b/libNeonSet/include/Neon/set/TransferSemantic.h
deleted file mode 100644
index ae347fac..00000000
--- a/libNeonSet/include/Neon/set/TransferSemantic.h
+++ /dev/null
@@ -1,42 +0,0 @@
-#pragma once
-#include <string>
-#include <vector>
-
-#include "Neon/core/core.h"
-
-namespace Neon::set {
-
-
-enum struct TransferSemantic
-{
-    grid = 0 /*<    Transfer for halo update on grid structure    */,
-    lattice = 1 /*< Transfer for halo update on lattice structure */
-};
-
-
-struct TransferSemanticUtils
-{
-    static constexpr int nOptions = 2;
-
-    static auto toString(TransferSemantic opt) -> std::string;
-    static auto fromString(const std::string& opt) -> TransferSemantic;
-    static auto getOptions() -> std::array<TransferSemantic, nOptions>;
-    
-    struct Cli
-    {
-        explicit Cli(std::string);
-        explicit Cli(TransferSemantic model);
-        Cli();
-
-        auto getOption() -> TransferSemantic;
-        auto set(const std::string& opt) -> void;
-        auto getStringOptions() -> std::string;
-
-       private:
-        bool mSet = false;
-        TransferSemantic  mOption;
-    };
-};
-
-
-}  // namespace Neon::set
diff --git a/libNeonSet/include/Neon/set/container/AnchorContainer.h b/libNeonSet/include/Neon/set/container/AnchorContainer.h
index 945885b3..68069bed 100644
--- a/libNeonSet/include/Neon/set/container/AnchorContainer.h
+++ b/libNeonSet/include/Neon/set/container/AnchorContainer.h
@@ -23,29 +23,27 @@ struct AnchorContainer : ContainerAPI
    public:
     AnchorContainer(const std::string& name);
 
-    auto parse() -> const std::vector<Neon::set::internal::dependencyTools::DataToken>& override;
-
-    auto getHostContainer() -> std::shared_ptr<ContainerAPI> final;
-
-    virtual auto getDeviceContainer() -> std::shared_ptr<ContainerAPI> final;
+    auto parse() -> const std::vector<Neon::set::dataDependency::Token>& override;
 
     /**
      * Run container over streams
      * @param streamIdx
      * @param dataView
      */
-    virtual auto run(int streamIdx = 0, Neon::DataView dataView = Neon::DataView::STANDARD) -> void override;
+    virtual auto run(int            streamIdx = 0,
+                     Neon::DataView dataView = Neon::DataView::STANDARD) -> void override;
 
     /**
      * Run container over streams
      * @param streamIdx
      * @param dataView
      */
-    virtual auto run(Neon::SetIdx setIdx, int streamIdx, Neon::DataView dataView) -> void override;
+    virtual auto run(Neon::SetIdx   setIdx,
+                     int            streamIdx,
+                     Neon::DataView dataView) -> void override;
 
    private:
-    std::vector<Neon::set::internal::dependencyTools::DataToken> mEmtpy;
-
+    std::vector<Neon::set::dataDependency::Token> mEmtpy;
 };
 
 }  // namespace internal
diff --git a/libNeonSet/include/Neon/set/container/ContainerAPI.h b/libNeonSet/include/Neon/set/container/ContainerAPI.h
index 28805856..cf83a46e 100644
--- a/libNeonSet/include/Neon/set/container/ContainerAPI.h
+++ b/libNeonSet/include/Neon/set/container/ContainerAPI.h
@@ -1,11 +1,10 @@
 #pragma once
 
-#include "Neon/set/container/ContainerOperationType.h"
-#include "Neon/set/container/ContainerPatternType.h"
-
 #include "Neon/set/DevSet.h"
-#include "Neon/set/container/ContainerExecutionType.h"
-#include "Neon/set/dependencyTools/DataParsing.h"
+#include "Neon/set/container/types/ContainerExecutionType.h"
+#include "Neon/set/container/types/ContainerOperationType.h"
+#include "Neon/set/container/types/ContainerPatternType.h"
+// #include "Neon/set/dependency/Token.h"
 
 #include "functional"
 #include "type_traits"
@@ -16,6 +15,11 @@ struct Loader;
 
 namespace Neon::set::container {
 struct Graph;
+struct GraphNode;
+}  // namespace Neon::set::container
+
+namespace Neon::set::dataDependency {
+struct Token;
 }
 
 namespace Neon::set::internal {
@@ -26,6 +30,8 @@ namespace Neon::set::internal {
  */
 struct ContainerAPI
 {
+    virtual auto configureWithScheduling(Neon::set::container::GraphNode& graphNode) -> void;
+
    public:
     friend Neon::set::Loader;
 
@@ -43,13 +49,16 @@ struct ContainerAPI
     /**
      * Run this Container over a stream.
      */
-    virtual auto run(int streamIdx, Neon::DataView dataView = Neon::DataView::STANDARD)
+    virtual auto run(int            streamIdx,
+                     Neon::DataView dataView = Neon::DataView::STANDARD)
         -> void = 0;
 
     /**
      * Run this Container over a stream.
      */
-    virtual auto run(Neon::SetIdx idx, int streamIdx, Neon::DataView dataView)
+    virtual auto run(Neon::SetIdx   idx,
+                     int            streamIdx,
+                     Neon::DataView dataView)
         -> void = 0;
 
     /**
@@ -67,7 +76,7 @@ struct ContainerAPI
     /**
      * Returns a handle to the internal graph of Containers.
      */
-    virtual auto getGraph()
+    virtual auto getGraph() const
         -> const Neon::set::container::Graph&;
 
     /**
@@ -75,8 +84,10 @@ struct ContainerAPI
      * @return
      */
     virtual auto parse()
-        -> const std::vector<Neon::set::internal::dependencyTools::DataToken>& = 0;
+        -> const std::vector<Neon::set::dataDependency::Token>&;
 
+    virtual auto getTransferMode() const
+        -> Neon::set::TransferMode;
 
     /**
      * Returns a name associated to the container.
@@ -88,13 +99,7 @@ struct ContainerAPI
      * Returns a list of tokens as result of parsing the Container loading lambda.
      */
     auto getTokens() const
-        -> const std::vector<Neon::set::internal::dependencyTools::DataToken>&;
-
-    /**
-     * Returns a list of tokens as result of parsing the Container loading lambda.
-     */
-    auto getTokenRef()
-        -> std::vector<Neon::set::internal::dependencyTools::DataToken>&;
+        -> const std::vector<Neon::set::dataDependency::Token>&;
 
     /**
      * Get the execution type for the Container.
@@ -126,10 +131,16 @@ struct ContainerAPI
     auto toLog(uint64_t ContainerUid) -> void;
 
    protected:
+    /**
+     * Returns a list of tokens as result of parsing the Container loading lambda.
+     */
+    auto getTokensRef()
+        -> std::vector<Neon::set::dataDependency::Token>&;
+
     /**
      * Add a new token
      */
-    auto addToken(Neon::set::internal::dependencyTools::DataToken& dataParsing)
+    auto addToken(Neon::set::dataDependency::Token& dataParsing)
         -> void;
 
     /**
@@ -154,7 +165,7 @@ struct ContainerAPI
      * Generate a string that will be printed in case or exceptions
      * @return
      */
-    auto helpGetNameForError()
+    auto helpGetNameForError() const
         -> std::string;
 
     /**
@@ -179,7 +190,7 @@ struct ContainerAPI
      * Set the patter for this Container based on a list of tokens.
      * @param tokens
      */
-    auto setContainerPattern(const std::vector<Neon::set::internal::dependencyTools::DataToken>& tokens)
+    auto setContainerPattern(const std::vector<Neon::set::dataDependency::Token>& tokens)
         -> void;
 
     /**
@@ -196,7 +207,7 @@ struct ContainerAPI
         -> void;
 
    private:
-    using TokenList = std::vector<Neon::set::internal::dependencyTools::DataToken>;
+    using TokenList = std::vector<Neon::set::dataDependency::Token>;
 
     std::string                                                          mName{"Anonymous"}; /**< Name of the Container */
     bool                                                                 mParsingDataUpdated = false;
diff --git a/libNeonSet/include/Neon/set/container/DataTransferContainer.h b/libNeonSet/include/Neon/set/container/DataTransferContainer.h
new file mode 100644
index 00000000..1d7c737d
--- /dev/null
+++ b/libNeonSet/include/Neon/set/container/DataTransferContainer.h
@@ -0,0 +1,70 @@
+#pragma once
+#include "Neon/core/core.h"
+
+#include "Neon/set/container/ContainerAPI.h"
+#include "Neon/set/container/Loader.h"
+
+namespace Neon::set::internal {
+
+template <typename MxpuDataT>
+struct DataTransferContainer
+    : ContainerAPI
+{
+    virtual ~DataTransferContainer() override = default;
+
+    DataTransferContainer(const MxpuDataT&           multiXpuData,
+                          Neon::set::TransferMode    transferMode,
+                          Neon::set::StencilSemantic transferSemantic)
+        : mMultiXpuData(multiXpuData),
+          mTransferMode(transferMode),
+          mTransferSemantic(transferSemantic)
+    {
+        setName("DataTransferContainer");
+
+        setContainerExecutionType(ContainerExecutionType::deviceManaged);
+        setContainerOperationType(ContainerOperationType::communication);
+        setDataViewSupport(DataViewSupport::off);
+
+        mDataTransferFun = [&](Neon::SetIdx setIdx,
+                               int          streamIdx) {
+            Neon::set::HuOptions options(this->mTransferMode,
+                                         false,
+                                         streamIdx,
+                                         mTransferSemantic);
+            this->mMultiXpuData.haloUpdate(setIdx, options);
+        };
+    }
+
+    auto run(int            streamIdx,
+             Neon::DataView dataView) -> void override
+    {
+        const Neon::Backend& bk = mMultiXpuData.getBackend();
+        const int            setCardinality = bk.devSet().setCardinality();
+
+#pragma omp parallel for num_threads(setCardinality)
+        for (int i = 0; i < setCardinality; ++i) {
+            run(Neon::SetIdx(i), streamIdx, dataView);
+        }
+    }
+
+    auto run(Neon::SetIdx   setIdx,
+             int            streamIdx,
+             Neon::DataView /*dataView*/) -> void override
+    {
+        if (ContainerExecutionType::deviceManaged == this->getContainerExecutionType()) {
+            mDataTransferFun(setIdx, streamIdx);
+            return;
+        }
+        NEON_THROW_UNSUPPORTED_OPTION("");
+    }
+
+   private:
+    std::function<void(Neon::SetIdx setIdx,
+                       int          streamIdx)>
+                               mDataTransferFun;
+    MxpuDataT                  mMultiXpuData;
+    Neon::set::TransferMode    mTransferMode;
+    Neon::set::StencilSemantic mTransferSemantic;
+};
+
+}  // namespace Neon::set::internal
diff --git a/libNeonSet/include/Neon/set/container/DeviceContainer.h b/libNeonSet/include/Neon/set/container/DeviceContainer.h
index 28b90294..cab76c1f 100644
--- a/libNeonSet/include/Neon/set/container/DeviceContainer.h
+++ b/libNeonSet/include/Neon/set/container/DeviceContainer.h
@@ -4,17 +4,8 @@
 #include "Neon/set/container/ContainerAPI.h"
 #include "Neon/set/container/Loader.h"
 
-namespace Neon {
-namespace set {
-namespace internal {
-
-/**
- * Specialized implementation of KContainer_i
- *
- *
- * @tparam DataIteratorContainerT
- * @tparam UserComputeLambdaT
- */
+namespace Neon::set::internal {
+
 template <typename DataIteratorContainerT,
           typename UserComputeLambdaT>
 struct DeviceContainer : ContainerAPI
@@ -22,7 +13,6 @@ struct DeviceContainer : ContainerAPI
    public:
     virtual ~DeviceContainer() override = default;
 
-   public:
     DeviceContainer(const std::string&                            name,
                     ContainerAPI::DataViewSupport                 dataViewSupport,
                     const DataIteratorContainerT&                 dataIteratorContainer,
@@ -78,7 +68,7 @@ struct DeviceContainer : ContainerAPI
         return parser;
     }
 
-    auto parse() -> const std::vector<Neon::set::internal::dependencyTools::DataToken>& override
+    auto parse() -> const std::vector<Neon::set::dataDependency::Token>& override
     {
         if (!this->isParsingDataUpdated()) {
             auto parser = newParser();
@@ -90,23 +80,13 @@ struct DeviceContainer : ContainerAPI
         return getTokens();
     }
 
-
-    auto
-    getHostContainer() -> std::shared_ptr<ContainerAPI> final
-    {
-        NEON_THROW_UNSUPPORTED_OPTION("This Container type can not be decoupled.");
-    }
-
-    virtual auto getDeviceContainer() -> std::shared_ptr<ContainerAPI> final
-    {
-        NEON_THROW_UNSUPPORTED_OPTION("This Container type can not be decoupled.");
-    }
     /**
      * Run container over streams
      * @param streamIdx
      * @param dataView
      */
-    virtual auto run(int streamIdx = 0, Neon::DataView dataView = Neon::DataView::STANDARD) -> void override
+    virtual auto run(int            streamIdx = 0,
+                     Neon::DataView dataView = Neon::DataView::STANDARD) -> void override
     {
 
         const Neon::Backend&    bk = m_dataIteratorContainer.getBackend();
@@ -132,18 +112,30 @@ struct DeviceContainer : ContainerAPI
      * @param streamIdx
      * @param dataView
      */
-    virtual auto run(Neon::SetIdx setIdx, int streamIdx, Neon::DataView dataView) -> void override
+    virtual auto run(Neon::SetIdx   setIdx,
+                     int            streamIdx,
+                     Neon::DataView dataView) -> void override
     {
 
         const Neon::Backend&    bk = m_dataIteratorContainer.getBackend();
         Neon::set::KernelConfig kernelConfig(dataView, bk, streamIdx, this->getLaunchParameters(dataView));
 
+#pragma omp critical
+        {
+            const int threadRank = omp_get_thread_num();
+            NEON_TRACE("TRACE DeviceContainer run rank {} setIdx {} stream {} dw {}",
+                       threadRank, setIdx.idx(), kernelConfig.stream(), Neon::DataViewUtil::toString(kernelConfig.dataView()));
+        };
+
         if (ContainerExecutionType::device == this->getContainerExecutionType()) {
             bk.devSet().template kernelLambdaWithIterator<DataIteratorContainerT, UserComputeLambdaT>(
                 setIdx,
                 kernelConfig,
                 m_dataIteratorContainer,
-                [&](Neon::DeviceType devE, Neon::SetIdx setIdx, Neon::DataView dataView) -> UserComputeLambdaT {
+                [&](Neon::DeviceType devE,
+                    Neon::SetIdx     setIdx,
+                    Neon::DataView   dataView)
+                    -> UserComputeLambdaT {
                     Loader             loader = this->newLoader(devE, setIdx, dataView, LoadingMode_e::EXTRACT_LAMBDA);
                     UserComputeLambdaT userLambda = this->m_loadingLambda(loader);
                     return userLambda;
@@ -163,6 +155,4 @@ struct DeviceContainer : ContainerAPI
     DataIteratorContainerT m_dataIteratorContainer;
 };
 
-}  // namespace internal
-}  // namespace set
-}  // namespace Neon
+}  // namespace Neon::set::internal
diff --git a/libNeonSet/include/Neon/set/container/DeviceManagedContainer.h b/libNeonSet/include/Neon/set/container/DeviceManagedContainer.h
index f8e9cdec..515b721a 100644
--- a/libNeonSet/include/Neon/set/container/DeviceManagedContainer.h
+++ b/libNeonSet/include/Neon/set/container/DeviceManagedContainer.h
@@ -62,7 +62,7 @@ struct DeviceManagedContainer : ContainerAPI
         return parser;
     }
 
-    auto parse() -> const std::vector<Neon::set::internal::dependencyTools::DataToken>& override
+    auto parse() -> const std::vector<Neon::set::dataDependency::Token>& override
     {
         Neon::SetIdx setIdx(0);
         if (!this->mParsingDataUpdated) {
@@ -108,9 +108,6 @@ struct DeviceManagedContainer : ContainerAPI
         if (ContainerExecutionType::deviceManaged == this->getContainerType()) {
             const Neon::Backend& bk = mDataContainer.getBackend();
 
-            // We use device 0 as a dummy setIdx to create a loader.
-            // The actual value is not important as the managed container will take care of launching on all devices.
-            SetIdx         dummyTargetSetIdx = 0;
             Loader         loader = this->newLoader(bk.devType(), setIdx, dataView, LoadingMode_e::EXTRACT_LAMBDA);
             ComputeLambdaT computeLambda = this->mLoadingLambda(setIdx, loader);
             computeLambda(streamIdx, dataView);
diff --git a/libNeonSet/include/Neon/set/container/DeviceThenHostManagedContainer.h b/libNeonSet/include/Neon/set/container/DeviceThenHostManagedContainer.h
index 42b9aa6a..ae8ee3ff 100644
--- a/libNeonSet/include/Neon/set/container/DeviceThenHostManagedContainer.h
+++ b/libNeonSet/include/Neon/set/container/DeviceThenHostManagedContainer.h
@@ -64,7 +64,7 @@ struct DeviceThenHostManagedContainer : ContainerAPI
         return parser;
     }
 
-    auto parse() -> const std::vector<Neon::set::internal::dependencyTools::DataToken>& override
+    auto parse() -> const std::vector<Neon::set::dataDependency::Token>& override
     {
         mHost->parse();
         mDevice->parse();
@@ -73,12 +73,12 @@ struct DeviceThenHostManagedContainer : ContainerAPI
         auto const& devTokens = mDevice->getTokens();
 
         for (auto const& token : devTokens) {
-            getTokenRef().push_back(token);
+            getTokensRef().push_back(token);
         }
-        std::vector<Neon::set::internal::dependencyTools::DataToken> filtered;
+        std::vector<Neon::set::dataDependency::Token> filtered;
         for (auto const& token : hostTokens) {
             bool foundMatch = false;
-            for (auto& acceptedTokens : getTokenRef()) {
+            for (auto& acceptedTokens : getTokensRef()) {
                 if (token.uid() == acceptedTokens.uid()) {
                     acceptedTokens.mergeAccess(token.access());
                     foundMatch = true;
@@ -90,7 +90,7 @@ struct DeviceThenHostManagedContainer : ContainerAPI
         }
 
         for (auto const& token : filtered) {
-            getTokenRef().push_back(token);
+            getTokensRef().push_back(token);
         }
 
         return getTokens();
diff --git a/libNeonSet/include/Neon/set/container/Graph.h b/libNeonSet/include/Neon/set/container/Graph.h
index 5403fd02..1914c923 100644
--- a/libNeonSet/include/Neon/set/container/Graph.h
+++ b/libNeonSet/include/Neon/set/container/Graph.h
@@ -5,8 +5,19 @@
 
 #include "Neon/set/container/graph/Bfs.h"
 #include "Neon/set/container/graph/GraphDependency.h"
+#include "Neon/set/container/graph/GraphDependencyType.h"
 #include "Neon/set/container/graph/GraphNode.h"
 
+
+namespace Neon::skeleton::internal {
+struct MultiXpuGraph;
+}
+
+namespace Neon::set::container {
+struct GraphNode;
+struct GraphDependency;
+}  // namespace Neon::set::container
+
 namespace Neon::set::container {
 
 /**
@@ -15,13 +26,15 @@ namespace Neon::set::container {
  * directed edges of the graph are dependencies between the containers.
  * Dependencies my be data driven or user provided.
  *
- *
  */
 struct Graph
 {
     using Uid = GraphData::Uid;
     using Index = GraphData::Index;
     friend struct Bfs;
+    friend Neon::set::container::GraphNode;
+    friend Neon::set::container::GraphDependency;
+    friend Neon::skeleton::internal::MultiXpuGraph;
 
    public:
     Graph();
@@ -76,6 +89,23 @@ struct Graph
                        GraphDependencyType type)
         -> GraphDependency&;
 
+    /**
+     * Adds a dependency between two node of the graph
+     */
+    auto addDependency(const GraphNode&                        nodeA,
+                       const GraphNode&                        nodeB,
+                       const Neon::set::dataDependency::Token& token)
+        -> GraphDependency&;
+
+    auto removeDependency(const GraphDependency&)
+        -> void;
+
+
+    /**
+     * Helper - it removes redundant dependencies
+     */
+    auto removeRedundantDependencies() -> void;
+
     /**
      * Returns the dependency type between two nodes.
      */
@@ -83,6 +113,14 @@ struct Graph
                            const GraphNode& nodeB)
         -> GraphDependencyType;
 
+    auto getDependency(const GraphNode& nodeA,
+                       const GraphNode& nodeB)
+        const -> const GraphDependency&;
+
+    auto getMutableDependency(const GraphNode& nodeA,
+                              const GraphNode& nodeB)
+        -> GraphDependency&;
+
     /**
      * Clone a node and return a reference to the new clone.
      * The cloning process connects the clone the the same nodes of the original
@@ -105,7 +143,9 @@ struct Graph
      */
     auto getSubsequentGraphNodes(const GraphNode&                        graphNode,
                                  const std::vector<GraphDependencyType>& dependencyTypes = {GraphDependencyType::user,
-                                                                                            GraphDependencyType::data}) -> std::vector<GraphNode*>;
+                                                                                            GraphDependencyType::data})
+        -> std::vector<GraphNode*>;
+
     /**
      * Set the stream to run the graph.
      * We provide a preset function so that some initialization
@@ -146,7 +186,24 @@ struct Graph
         -> void;
 
     auto getNumberOfNodes()
-        ->int;
+        -> int;
+
+    auto forEachDependency(const std::function<void(const GraphDependency&)>& fun)
+        const -> void;
+
+    auto forEachNode(const std::function<void(const GraphNode&)>& fun)
+        const -> void;
+
+    /**
+     * Adding a graph between two nodes A and B
+     * The method works only on Graph type containers.
+     * Finally, it returns the number of added nodes.
+     */
+    auto expandAndMerge(const GraphNode& A,
+                        const Container& graphOriginal,
+                        const GraphNode& B,
+                        bool             propagateSchedulingHints)
+        -> int;
 
    protected:
     /**
@@ -159,10 +216,6 @@ struct Graph
      */
     auto helpCheckBackendStatus() -> void;
 
-    /**
-     * Helper - it removes redundant dependencies
-     */
-    auto helpRemoveRedundantDependencies() -> void;
 
     /**
      * Compute BFS
@@ -173,9 +226,8 @@ struct Graph
      * Returns the out-neighbour of a target node
      */
     auto helpGetOutNeighbors(GraphData::Uid,
-                             bool                                    fileterOutEnd = true,
-                             const std::vector<GraphDependencyType>& dependencyTypes = {GraphDependencyType::user,
-                                                                                        GraphDependencyType::data})
+                             bool                                    fileterOutEnd,
+                             const std::vector<GraphDependencyType>& dependencyTypes)
         -> std::set<GraphData::Uid>;
 
     /**
@@ -231,19 +283,21 @@ struct Graph
      * - order of execution
      * - mapping between streams and graph nodes
      */
-    auto helpComputeScheduling(bool filterOutAnchors, int anchorStream)
+    auto helpComputeScheduling(bool filterOutAnchors,
+                               int  anchorStream)
         -> void;
 
     /**
      * Helper - it executes the graph on all devices
      */
-    auto helpExecute(int anchorStream)
+    auto helpExecuteWithOmpAtNodeLevel(int anchorStream)
         -> void;
 
     /**
      * Helper - it executes the graph on a target device
      */
-    auto helpExecute(Neon::SetIdx setIdx, int anchorStream)
+    auto helpExecute(Neon::SetIdx setIdx,
+                     int          anchorStream)
         -> void;
     /**
      * Helper - It resets node scheduling data
@@ -261,7 +315,9 @@ struct Graph
      * Helper - it maps node to streams.
      * Returns the max stream Id used by the scheduling
      */
-    auto helpComputeScheduling_02_mappingStreams(Bfs& bfs, bool filterOutAnchors, int anchorStream)
+    auto helpComputeScheduling_02_mappingStreams(Bfs& bfs,
+                                                 bool filterOutAnchors,
+                                                 int  anchorStream)
         -> int;
 
     /**
@@ -274,9 +330,15 @@ struct Graph
     /**
      * Helper - it Books the required resources from the backend.
      */
-    auto helpComputeScheduling_04_ensureResources(int maxStreamId, int maxEventId)
+    auto helpComputeScheduling_04_ensureResources(int maxStreamId,
+                                                  int maxEventId)
         -> void;
 
+    /**
+     * Helper - it Books the required resources from the backend.
+     */
+    auto helpComputeScheduling_05_executionOrder(bool filterOutAnchors, Bfs& bfs)
+        -> void;
 
     using RawGraph = DiGraph<GraphNode, GraphDependency>;
 
diff --git a/libNeonSet/include/Neon/set/container/GraphContainer.h b/libNeonSet/include/Neon/set/container/GraphContainer.h
index 3630ce1a..f10ead04 100644
--- a/libNeonSet/include/Neon/set/container/GraphContainer.h
+++ b/libNeonSet/include/Neon/set/container/GraphContainer.h
@@ -17,39 +17,30 @@ struct GraphContainer : ContainerAPI
    public:
     ~GraphContainer() override = default;
 
-    /**
-     * User facing API to define a kernel
-     * @param data
-     * @param userLambda
-     */
     GraphContainer(const std::string&                         name,
                    const Neon::set::container::Graph&         containerGraph,
                    std::function<void(Neon::SetIdx, Loader&)> loadingLambda);
 
-    auto newParser() -> Loader;
+    auto newParser()
+        -> Loader;
 
-    auto parse() -> const std::vector<Neon::set::internal::dependencyTools::DataToken>& override;
+    auto parse()
+        -> const std::vector<Neon::set::dataDependency::Token>& override;
 
-    auto getGraph() -> const Neon::set::container::Graph& override;
+    auto getGraph()
+      const  -> const Neon::set::container::Graph& override;
 
-    auto getHostContainer() -> std::shared_ptr<internal::ContainerAPI> override;
-
-    auto getDeviceContainer() -> std::shared_ptr<internal::ContainerAPI> override;
-    /**
-     * Run container over streams
-     * @param streamIdx
-     * @param dataView
-     */
-    auto run(int streamIdx = 0,
+    auto run(int            streamIdx = 0,
              Neon::DataView dataView = Neon::DataView::STANDARD)
         -> void override;
 
     auto run(Neon::SetIdx   setIdx,
              int            streamIdx = 0,
-             Neon::DataView dataView = Neon::DataView::STANDARD) -> void override;
+             Neon::DataView dataView = Neon::DataView::STANDARD)
+        -> void override;
 
    private:
-    std::function<void(Neon::SetIdx, Loader&)>         mLoadingLambda;
+    std::function<void(Neon::SetIdx, Loader&)>   mLoadingLambda;
     std::shared_ptr<Neon::set::container::Graph> mGraph;
 };
 
diff --git a/libNeonSet/include/Neon/set/container/HaloUpdateContainer.h b/libNeonSet/include/Neon/set/container/HaloUpdateContainer.h
new file mode 100644
index 00000000..a5a48df7
--- /dev/null
+++ b/libNeonSet/include/Neon/set/container/HaloUpdateContainer.h
@@ -0,0 +1,34 @@
+#pragma once
+
+#include "Neon/core/core.h"
+
+#include "Neon/set/container/ContainerAPI.h"
+#include "Neon/set/container/Graph.h"
+#include "Neon/set/container/GraphContainer.h"
+#include "Neon/set/container/Loader.h"
+#include "Neon/set/container/types/SynchronizationContainerType.h"
+
+namespace Neon::set {
+struct Container;
+}
+
+namespace Neon::set::internal {
+
+template <typename MultiXpuDataT>
+struct HaloUpdateContainer
+    : public GraphContainer
+{
+
+   public:
+    ~HaloUpdateContainer() override = default;
+
+    HaloUpdateContainer(const Neon::Backend&        bk,
+                        const Neon::set::Container& dataTransferContainer,
+                        const Neon::set::Container& syncContainer);
+
+   private:
+};
+
+}  // namespace Neon::set::internal
+
+#include "Neon/set/container/HaloUpdateContainer_imp.h"
\ No newline at end of file
diff --git a/libNeonSet/include/Neon/set/container/HaloUpdateContainer_imp.h b/libNeonSet/include/Neon/set/container/HaloUpdateContainer_imp.h
new file mode 100644
index 00000000..7746ee4e
--- /dev/null
+++ b/libNeonSet/include/Neon/set/container/HaloUpdateContainer_imp.h
@@ -0,0 +1,35 @@
+#include "Neon/core/core.h"
+
+#include "Neon/set/container/HaloUpdateContainer.h"
+
+namespace Neon::set::internal {
+
+template <typename MultiXpuDataT>
+HaloUpdateContainer<MultiXpuDataT>::
+    HaloUpdateContainer(const Neon::Backend&        bk,
+                        const Neon::set::Container& dataTransferContainer,
+                        const Neon::set::Container& syncContainer)
+{
+    Neon::set::container::Graph graph(bk);
+
+    auto dataTranferNode = graph.addNode(dataTransferContainer);
+    auto syncNode = graph.addNode(syncContainer);
+
+    if (dataTransferContainer.getContainerInterface().getTransferMode() ==
+        Neon::set::TransferMode::get) {
+        graph.addDependency(syncNode, dataTranferNode, GraphDependencyType::data);
+    } else {
+        graph.addDependency(dataTranferNode, syncNode, GraphDependencyType::data);
+    }
+
+    auto           name = std::string("HaloUpdate");
+    GraphContainer graphContainer(graph, [&](Neon::set::Loader& loader) {
+        // Nothing to load
+    });
+
+    this->GraphContainer = graphContainer;
+
+    setContainerOperationType(ContainerOperationType::communication);
+    setDataViewSupport(DataViewSupport::off);
+}
+}  // namespace Neon::set::internal
diff --git a/libNeonSet/include/Neon/set/container/HostManagedContainer.h b/libNeonSet/include/Neon/set/container/HostManagedContainer.h
index 20c1b306..99429d20 100644
--- a/libNeonSet/include/Neon/set/container/HostManagedContainer.h
+++ b/libNeonSet/include/Neon/set/container/HostManagedContainer.h
@@ -1,8 +1,8 @@
 #pragma once
 
 #include "Neon/set/container/ContainerAPI.h"
-#include "Neon/set/container/HostManagedSyncType.h"
 #include "Neon/set/container/Loader.h"
+#include "Neon/set/container/types/HostManagedSyncType.h"
 
 namespace Neon::set::internal {
 
@@ -71,7 +71,7 @@ struct HostManagedContainer : ContainerAPI
         return parser;
     }
 
-    auto parse() -> const std::vector<Neon::set::internal::dependencyTools::DataToken>& override
+    auto parse() -> const std::vector<Neon::set::dataDependency::Token>& override
     {
         auto         parser = newParser();
         Neon::SetIdx setIdx(0);
diff --git a/libNeonSet/include/Neon/set/container/Loader.h b/libNeonSet/include/Neon/set/container/Loader.h
index bdbfe74e..bb7180b7 100644
--- a/libNeonSet/include/Neon/set/container/Loader.h
+++ b/libNeonSet/include/Neon/set/container/Loader.h
@@ -1,10 +1,15 @@
 #pragma once
-//#include <experimental/type_traits>
+
+#include "type_traits"
+
 #include "Neon/set/DevSet.h"
-#include "Neon/set/dependencyTools/DataParsing.h"
+#include "Neon/set/HuOptions.h"
+#include "Neon/set/StencilSemantic.h"
 #include "Neon/set/container/ContainerAPI.h"
+#include "Neon/set/dependency/AccessType.h"
+#include "Neon/set/dependency/ComputeType.h"
+#include "Neon/set/dependency/Token.h"
 
-#include "type_traits"
 namespace Neon::set {
 namespace internal {
 
@@ -19,115 +24,6 @@ struct LoadingMode_e
     LoadingMode_e(const LoadingMode_e&) = delete;
 };
 
-namespace tmp {
-// From:
-// https://en.cppreference.com/w/cpp/experimental/is_detected
-namespace detail {
-template <class Default, class AlwaysVoid, template <class...> class Op, class... Args>
-struct detector
-{
-    using value_t = std::false_type;
-    using type = Default;
-};
-
-template <class Default, template <class...> class Op, class... Args>
-struct detector<Default, std::void_t<Op<Args...>>, Op, Args...>
-{
-    using value_t = std::true_type;
-    using type = Op<Args...>;
-};
-
-}  // namespace detail
-
-struct nonesuch
-{
-    ~nonesuch() = delete;
-    nonesuch(nonesuch const&) = delete;
-    void operator=(nonesuch const&) = delete;
-};
-
-template <template <class...> class Op, class... Args>
-using is_detected = typename detail::detector<nonesuch, void, Op, Args...>::value_t;
-
-template <template <class...> class Op, class... Args>
-using detected_t = typename detail::detector<nonesuch, void, Op, Args...>::type;
-
-template <class Default, template <class...> class Op, class... Args>
-using detected_or = detail::detector<Default, void, Op, Args...>;
-
-template <template <class...> class Op, class... Args>
-constexpr bool is_detected_v = is_detected<Op, Args...>::value;
-
-}  // namespace tmp
-
-template <typename Field_ta>
-struct HaloUpdateExtractor_t
-{
-    // field.haloUpdate(bk, opt);
-    // const Neon::set::Backend& /*bk*/,
-    // Neon::set::HuOptions_t& /*opt*/
-   private:
-    template <typename T>
-    using HaloUpdate = decltype(std::declval<T>().haloUpdate(std::declval<Neon::set::HuOptions&>()));
-
-    template <typename T>
-    static constexpr bool HasHaloUpdate = tmp::is_detected_v<HaloUpdate, T>;
-
-   public:
-    static auto get([[maybe_unused]] const Field_ta& field) -> auto
-    {
-        if constexpr (HasHaloUpdate<Field_ta>) {
-            auto huFun = [field](Neon::set::HuOptions& opt) {
-                field.haloUpdate(opt);
-            };
-            return huFun;
-        } else {
-            auto huFun = [field](Neon::set::HuOptions& opt) {
-                (void)opt;
-            };
-
-            return huFun;
-        }
-        NEON_THROW_UNSUPPORTED_OPTION("");
-    }
-};
-
-template <typename Field_ta>
-struct HaloUpdatePerDeviceExtractor_t
-{
-    // field.haloUpdate(bk, opt);
-    // const Neon::set::Backend& /*bk*/,
-    // Neon::set::HuOptions_t& /*opt*/
-   private:
-    template <typename T>
-    using HaloUpdatePerDevice = decltype(std::declval<T>().haloUpdate(std::declval<Neon::SetIdx&>(),
-                                                                      std::declval<Neon::set::HuOptions&>()));
-
-    template <typename T>
-    static constexpr bool HasHaloUpdatePerDevice = tmp::is_detected_v<HaloUpdatePerDevice, T>;
-
-   public:
-    static auto get([[maybe_unused]] const Field_ta& field) -> auto
-    {
-        if constexpr (HasHaloUpdatePerDevice<Field_ta>) {
-            auto huFun = [field](Neon::SetIdx          setIdx,
-                                 Neon::set::HuOptions& opt) {
-                field.haloUpdate(setIdx, opt);
-            };
-            return huFun;
-        } else {
-            auto huFun = [field](Neon::SetIdx          setIdx,
-                                 Neon::set::HuOptions& opt) {
-                (void)opt;
-                (void)setIdx;
-            };
-
-            return huFun;
-        }
-        NEON_THROW_UNSUPPORTED_OPTION("");
-    }
-};
-
 }  // namespace internal
 
 
@@ -151,10 +47,10 @@ struct Loader
 
    public:
     Loader(Neon::set::internal::ContainerAPI&    container,
-             Neon::DeviceType                      devE,
-             Neon::SetIdx                          setIdx,
-             Neon::DataView                        dataView,
-             Neon::set::internal::LoadingMode_e::e loadingMode)
+           Neon::DeviceType                      devE,
+           Neon::SetIdx                          setIdx,
+           Neon::DataView                        dataView,
+           Neon::set::internal::LoadingMode_e::e loadingMode)
         : m_container(container),
           m_devE(devE),
           m_setIdx(setIdx),
@@ -163,98 +59,25 @@ struct Loader
     {
     }
 
-   private:
    public:
-    enum struct StencilOptions
-    {
-        LATTICE,
-        LATTICE_REVERSED,
-        DEFAULT,
-        DEFAULT_REVERSE,
-    };
-
-
     template <typename Field_ta>
-    auto load(Field_ta&      field,
-              Neon::Compute  computeE = Neon::Compute::MAP,
-              StencilOptions stencilOptions = StencilOptions::DEFAULT)
-        -> std::enable_if_t<!std::is_const_v<Field_ta>, typename Field_ta::Partition&>
-    {
+    auto load(Field_ta&       field,
+              Neon::Compute   computeE = Neon::Compute::MAP,
+              StencilSemantic stencilSemantic = StencilSemantic::standard)
+        -> std::enable_if_t<!std::is_const_v<Field_ta>, typename Field_ta::Partition&>;
 
-        switch (m_loadingMode) {
-            case Neon::set::internal::LoadingMode_e::PARSE_AND_EXTRACT_LAMBDA: {
-                using namespace Neon::set::internal::dependencyTools;
-                DataUId_t              uid = field.getUid();
-                constexpr Access_et::e access = Access_et::WRITE;
-                Compute                compute = computeE;
-                DataToken              dataToken(uid, access, compute);
-
-                if (compute == Neon::Compute::STENCIL &&
-                    (stencilOptions == StencilOptions::DEFAULT || stencilOptions == StencilOptions::LATTICE)) {
-                    Neon::NeonException exp("Loader");
-                    exp << "Loading a non const field for a stencil operation is not supported in Neon";
-                    NEON_THROW(exp);
-                }
-
-                m_container.addToken(dataToken);
-
-                return field.getPartition(m_devE, m_setIdx, m_dataView);
-            }
-            case Neon::set::internal::LoadingMode_e::EXTRACT_LAMBDA: {
-                return field.getPartition(m_devE, m_setIdx, m_dataView);
-            }
-        }
-        NEON_DEV_UNDER_CONSTRUCTION("");
-    }
-
-    auto computeMode() -> bool
-    {
-        return m_loadingMode == Neon::set::internal::LoadingMode_e::EXTRACT_LAMBDA;
-    }
+    auto computeMode() -> bool;
 
     /**
      * Loading a const field
      */
     template <typename Field_ta>
-    auto load(Field_ta&     field /**< the const field to be loaded            */,
-              Neon::Compute computeE = Neon::Compute::MAP /**< computation patter applied to the field */)
-        -> std::enable_if_t<std::is_const_v<Field_ta>, const typename Field_ta::Partition&>
-    {
-        switch (m_loadingMode) {
-            case Neon::set::internal::LoadingMode_e::PARSE_AND_EXTRACT_LAMBDA: {
-                using namespace Neon::set::internal::dependencyTools;
-                DataUId_t              uid = field.getUid();
-                constexpr Access_et::e access = Access_et::READ;
-                Neon::Compute          compute = computeE;
-                DataToken              dataToken(uid, access, compute);
-
-                if (compute == Neon::Compute::STENCIL) {
-                    dataToken.setHaloUpdate(
-                        [&](Neon::set::HuOptions& opt) -> void {
-                            // TODO: add back following line with template metaprogramming
-                            // field.haloUpdate(bk, opt);
-                            // https://gist.github.com/fenbf/d2cd670704b82e2ce7fd
-                            auto huFun = internal::HaloUpdateExtractor_t<Field_ta>::get(field);
-                            huFun( opt);
-
-                        return; },
-                        [&](Neon::SetIdx setIdx, Neon::set::HuOptions& opt) -> void {
-                            auto huFun = internal::HaloUpdatePerDeviceExtractor_t<Field_ta>::get(field);
-                            huFun(setIdx, opt);
-
-                            return;
-                        });
-                }
-                m_container.addToken(dataToken);
-
-                return field.getPartition(m_devE, m_setIdx, m_dataView);
-            }
-            case Neon::set::internal::LoadingMode_e::EXTRACT_LAMBDA: {
-                return field.getPartition(m_devE, m_setIdx, m_dataView);
-            }
-        }
-        NEON_DEV_UNDER_CONSTRUCTION("");
-    }
+    auto load(Field_ta&       field /**< the const field to be loaded            */,
+              Neon::Compute   computeE = Neon::Compute::MAP /**< computation patter applied to the field */,
+              StencilSemantic stencilSemantic = StencilSemantic::standard)
+        -> std::enable_if_t<std::is_const_v<Field_ta>, const typename Field_ta::Partition&>;
 };
 
-}  // namespace Neon
\ No newline at end of file
+}  // namespace Neon::set
+
+#include "Neon/set/container/Loader_imp.h"
\ No newline at end of file
diff --git a/libNeonSet/include/Neon/set/container/Loader_imp.h b/libNeonSet/include/Neon/set/container/Loader_imp.h
new file mode 100644
index 00000000..dcfa85b9
--- /dev/null
+++ b/libNeonSet/include/Neon/set/container/Loader_imp.h
@@ -0,0 +1,224 @@
+#pragma once
+
+#include "type_traits"
+
+#include "Neon/set/Containter.h"
+
+namespace Neon::set {
+namespace internal {
+
+namespace tmp {
+// From:
+// https://en.cppreference.com/w/cpp/experimental/is_detected
+namespace detail {
+template <class Default, class AlwaysVoid, template <class...> class Op, class... Args>
+struct detector
+{
+    using value_t = std::false_type;
+    using type = Default;
+};
+
+template <class Default, template <class...> class Op, class... Args>
+struct detector<Default, std::void_t<Op<Args...>>, Op, Args...>
+{
+    using value_t = std::true_type;
+    using type = Op<Args...>;
+};
+
+}  // namespace detail
+
+struct nonesuch
+{
+    ~nonesuch() = delete;
+    nonesuch(nonesuch const&) = delete;
+    void operator=(nonesuch const&) = delete;
+};
+
+template <template <class...> class Op, class... Args>
+using is_detected = typename detail::detector<nonesuch, void, Op, Args...>::value_t;
+
+template <template <class...> class Op, class... Args>
+using detected_t = typename detail::detector<nonesuch, void, Op, Args...>::type;
+
+template <class Default, template <class...> class Op, class... Args>
+using detected_or = detail::detector<Default, void, Op, Args...>;
+
+template <template <class...> class Op, class... Args>
+constexpr bool is_detected_v = is_detected<Op, Args...>::value;
+
+}  // namespace tmp
+
+template <typename Field_ta>
+struct DataTransferExtractor
+{
+    // field.haloUpdate(bk, opt);
+    // const Neon::set::Backend& /*bk*/,
+    // Neon::set::HuOptions_t& /*opt*/
+   private:
+    template <typename T>
+    using HaloUpdate = decltype(std::declval<T>().haloUpdateContainer(std::declval<Neon::set::TransferMode>(),
+                                                                      std::declval<Neon::set::StencilSemantic>()));
+
+    template <typename T>
+    static constexpr bool HasHaloUpdateMethod = tmp::is_detected_v<HaloUpdate, T>;
+
+   public:
+    /**
+     * Function that extract that wraps the haloUpdateContainer method of a field for future use.
+     * If the function is not detected the input parameter status flag is set to false.
+     */
+    static auto get([[maybe_unused]] const Field_ta& field /**< target field */,
+                    bool&                            status /**< status flag. True means extraction was successful */) -> auto
+    {
+        if constexpr (HasHaloUpdateMethod<Field_ta>) {
+            auto huFun = [field, &status](Neon::set::TransferMode    transferMode,
+                                          Neon::set::StencilSemantic stencilSemantic)
+                -> Neon::set::Container {
+                Neon::set::Container container = field.haloUpdateContainer(transferMode, stencilSemantic);
+                return container;
+            };
+            status = true;
+            return huFun;
+        } else {
+            auto huFun = [field, &status](Neon::set::TransferMode    transferMode,
+                                          Neon::set::StencilSemantic stencilSemantic)
+                -> Neon::set::Container {
+                (void)transferMode;
+                (void)stencilSemantic;
+                return {};
+            };
+            status = false;
+            return huFun;
+        }
+        NEON_THROW_UNSUPPORTED_OPTION("");
+    }
+};
+
+// template <typename Field_ta>
+// struct HaloUpdatePerDeviceExtractor_t
+//{
+//     // field.haloUpdate(bk, opt);
+//     // const Neon::set::Backend& /*bk*/,
+//     // Neon::set::HuOptions_t& /*opt*/
+//    private:
+//     template <typename T>
+//     using HaloUpdatePerDevice = decltype(std::declval<T>().haloUpdate(std::declval<Neon::SetIdx&>(),
+//                                                                       std::declval<Neon::set::HuOptions&>()));
+//
+//     template <typename T>
+//     static constexpr bool HasHaloUpdatePerDevice = tmp::is_detected_v<HaloUpdatePerDevice, T>;
+//
+//    public:
+//     static auto get([[maybe_unused]] const Field_ta& field) -> auto
+//     {
+//         if constexpr (HasHaloUpdatePerDevice<Field_ta>) {
+//             auto huFun = [field](Neon::SetIdx          setIdx,
+//                                  Neon::set::HuOptions& opt) {
+//                 field.haloUpdate(setIdx, opt);
+//             };
+//             return huFun;
+//         } else {
+//             auto huFun = [field](Neon::SetIdx          setIdx,
+//                                  Neon::set::HuOptions& opt) {
+//                 (void)opt;
+//                 (void)setIdx;
+//             };
+//
+//             return huFun;
+//         }
+//         NEON_THROW_UNSUPPORTED_OPTION("");
+//     }
+// };
+
+}  // namespace internal
+
+template <typename Field_ta>
+auto Loader::
+    load(Field_ta&       field,
+         Neon::Compute   computeE,
+         StencilSemantic stencilSemantic)
+        -> std::enable_if_t<!std::is_const_v<Field_ta>, typename Field_ta::Partition&>
+{
+
+    switch (m_loadingMode) {
+        case Neon::set::internal::LoadingMode_e::PARSE_AND_EXTRACT_LAMBDA: {
+            using namespace Neon::set::dataDependency;
+            Neon::set::dataDependency::MultiXpuDataUid uid = field.getUid();
+            constexpr auto                             access = Neon::set::dataDependency::AccessType::WRITE;
+            Compute                                    compute = computeE;
+            Token                                      token(uid, access, compute);
+
+            if (compute == Neon::Compute::STENCIL &&
+                (stencilSemantic == StencilSemantic::standard ||
+                 stencilSemantic == StencilSemantic::streaming)) {
+                Neon::NeonException exp("Loader");
+                exp << "Loading a non const field for a stencil operation is not supported in Neon";
+                NEON_THROW(exp);
+            }
+
+            m_container.addToken(token);
+
+            return field.getPartition(m_devE, m_setIdx, m_dataView);
+        }
+        case Neon::set::internal::LoadingMode_e::EXTRACT_LAMBDA: {
+            return field.getPartition(m_devE, m_setIdx, m_dataView);
+        }
+    }
+    NEON_DEV_UNDER_CONSTRUCTION("");
+}
+
+/**
+ * Loading a const field
+ */
+template <typename Field_ta>
+auto Loader::
+    load(Field_ta&       field,
+         Neon::Compute   computeE,
+         StencilSemantic stencilSemantic)
+        -> std::enable_if_t<std::is_const_v<Field_ta>, const typename Field_ta::Partition&>
+{
+    switch (m_loadingMode) {
+        case Neon::set::internal::LoadingMode_e::PARSE_AND_EXTRACT_LAMBDA: {
+            using namespace Neon::set::dataDependency;
+            Neon::set::dataDependency::MultiXpuDataUid uid = field.getUid();
+            constexpr auto                             access = Neon::set::dataDependency::AccessType::READ;
+            Neon::Compute                              compute = computeE;
+            Token                                      token(uid, access, compute);
+
+            if (compute == Neon::Compute::STENCIL) {
+                token.setDataTransferContainer(
+                    [&](Neon::set::TransferMode transferMode)
+                        -> Neon::set::Container {
+                        // TODO: add back following line with template metaprogramming
+                        // field.haloUpdate(bk, opt);
+                        // https://gist.github.com/fenbf/d2cd670704b82e2ce7fd
+                        bool                 status;
+                        auto                 huFun = internal::DataTransferExtractor<Field_ta>::get(field, status);
+
+                        if (!status) {
+                            Neon::NeonException e("Neon::Loader");
+                            e << std::string("Unable to extract haloUpdateContainer from the target field: ") + field.getName() + " UID " + std::to_string(field.getUid());
+                            NEON_THROW(e);
+                        }
+
+                        Neon::set::Container container = huFun(transferMode, stencilSemantic);
+
+                        if (container.getContainerInterface().getContainerExecutionType() != ContainerExecutionType::graph) {
+                            NEON_THROW_UNSUPPORTED_OPERATION("Halo update Containers type should be Graph");
+                        }
+
+                        return container;
+                    });
+            }
+            m_container.addToken(token);
+
+            return field.getPartition(m_devE, m_setIdx, m_dataView);
+        }
+        case Neon::set::internal::LoadingMode_e::EXTRACT_LAMBDA: {
+            return field.getPartition(m_devE, m_setIdx, m_dataView);
+        }
+    }
+    NEON_DEV_UNDER_CONSTRUCTION("");
+}
+
+}  // namespace Neon::set
\ No newline at end of file
diff --git a/libNeonSet/include/Neon/set/container/OldDeviceManagedContainer.h b/libNeonSet/include/Neon/set/container/OldDeviceManagedContainer.h
index ba653e0d..4f9aaf73 100644
--- a/libNeonSet/include/Neon/set/container/OldDeviceManagedContainer.h
+++ b/libNeonSet/include/Neon/set/container/OldDeviceManagedContainer.h
@@ -26,14 +26,19 @@ struct OldDeviceManagedContainer : ContainerAPI
      */
     OldDeviceManagedContainer(const std::string&                                 name,
                               Neon::set::internal::ContainerAPI::DataViewSupport dataViewSupport,
+                              Neon::set::ContainerPatternType patternType,
                               const DataContainer&                               dataIteratorContainer,
                               std::function<ComputeLambdaT(Loader&)>             loadingLambda)
         : mLoadingLambda(loadingLambda),
           mDataContainer(dataIteratorContainer)
     {
+        setName(name);
+
         setContainerExecutionType(ContainerExecutionType::deviceManaged);
+        setContainerOperationType(ContainerOperationType::compute);
+        setContainerPattern(patternType);
+
         setDataViewSupport(dataViewSupport);
-        setName(name);
     }
 
     auto newLoader(Neon::DeviceType devE,
@@ -59,7 +64,7 @@ struct OldDeviceManagedContainer : ContainerAPI
         return parser;
     }
 
-    auto parse() -> const std::vector<Neon::set::internal::dependencyTools::DataToken>& override
+    auto parse() -> const std::vector<Neon::set::dataDependency::Token>& override
     {
         auto parser = newParser();
         this->mLoadingLambda(parser);
diff --git a/libNeonSet/include/Neon/set/container/SynchronizationContainer.h b/libNeonSet/include/Neon/set/container/SynchronizationContainer.h
new file mode 100644
index 00000000..83633db4
--- /dev/null
+++ b/libNeonSet/include/Neon/set/container/SynchronizationContainer.h
@@ -0,0 +1,81 @@
+#pragma once
+#include "Neon/core/core.h"
+
+#include "Neon/set/container/ContainerAPI.h"
+#include "Neon/set/container/DeviceContainer.h"
+#include "Neon/set/container/Graph.h"
+#include "Neon/set/container/Loader.h"
+#include "Neon/set/container/graph/GraphNode.h"
+#include "Neon/set/container/types/SynchronizationContainerType.h"
+
+#include <omp.h>
+
+namespace Neon::set::internal {
+
+template <typename MxpuDataT>
+struct SynchronizationContainer
+    : ContainerAPI
+{
+    ~SynchronizationContainer() override = default;
+
+    explicit SynchronizationContainer(const MxpuDataT&             multiXpuData,
+                                      SynchronizationContainerType syncType)
+        : mMultiXpuData(multiXpuData),
+          mSynchronizationType(syncType)
+    {
+        setName("SynchronizationContainer");
+
+        setContainerExecutionType(ContainerExecutionType::deviceManaged);
+        setContainerOperationType(ContainerOperationType::synchronization);
+        setDataViewSupport(DataViewSupport::off);
+
+        if (syncType != SynchronizationContainerType::hostOmpBarrier) {
+            NEON_THROW_UNSUPPORTED_OPERATION("");
+        }
+    }
+
+    auto run(int            streamIdx,
+             Neon::DataView /*dataView*/) -> void override
+    {
+        const Neon::Backend& bk = mMultiXpuData.getBackend();
+        bk.sync(streamIdx);
+    }
+
+    auto
+    run(Neon::SetIdx   setIdx,
+        int            streamIdx,
+        Neon::DataView /*dataView*/)
+        -> void override
+    {
+        const auto& bk = mMultiXpuData.getBackend();
+        if (mEvents.empty()) {
+            bk.sync(setIdx, streamIdx);
+        } else {
+            for (auto eventId : mEvents) {
+                bk.syncEvent(setIdx, eventId);
+            }
+        }
+
+#pragma omp barrier
+//#pragma omp critical
+//        {
+//            const int threadRank = omp_get_thread_num();
+//            NEON_TRACE("TRACE SynchronizationContainer rank {} setIdx {} stream {} ", threadRank, setIdx.idx(), streamIdx);
+//        };
+    }
+
+    auto configureWithScheduling(Neon::set::container::GraphNode& /*graphNode*/)
+        -> void override
+    {
+//        mEvents = graphNode.getScheduling().getDependentEvents();
+//        graphNode.getScheduling().getDependentEvents().clear();
+    }
+
+   private:
+    MxpuDataT                    mMultiXpuData;
+    SynchronizationContainerType mSynchronizationType;
+    std::vector<int>             mEvents;
+
+};  // namespace Neon::set::internal
+
+}  // namespace Neon::set::internal
diff --git a/libNeonSet/include/Neon/set/container/graph/Bfs.h b/libNeonSet/include/Neon/set/container/graph/Bfs.h
index 0208af63..5786c29e 100644
--- a/libNeonSet/include/Neon/set/container/graph/Bfs.h
+++ b/libNeonSet/include/Neon/set/container/graph/Bfs.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include "Neon/set/container/graph/GraphData.h"
+#include <string>
 
 namespace Neon::set::container {
 
@@ -62,9 +63,10 @@ struct Bfs
      */
     auto clear() -> void;
 
+    auto toString()->std::string;
+
    private:
     std::vector<Level> data;
 };
 
 }  // namespace Neon::set::container
-
diff --git a/libNeonSet/include/Neon/set/container/graph/GraphDependency.h b/libNeonSet/include/Neon/set/container/graph/GraphDependency.h
index 58945e1b..f9f27117 100644
--- a/libNeonSet/include/Neon/set/container/graph/GraphDependency.h
+++ b/libNeonSet/include/Neon/set/container/graph/GraphDependency.h
@@ -1,22 +1,74 @@
 #pragma once
 
+#include "Neon/set/container/graph/GraphNode.h"
+#include "Neon/set/dependency/Token.h"
+#include "Neon/core/types/digraph.h"
 #include "GraphDependencyType.h"
 
+namespace Neon::skeleton::internal {
+struct MultiXpuGraph;
+}
+
 namespace Neon::set::container {
 
+struct GraphNode;
+struct Graph;
+
 struct GraphDependency
 {
-    std::string getLabel();
+    using Tokens = std::vector<Neon::set::dataDependency::Token>;
+    using Token = Neon::set::dataDependency::Token;
+    using RawGraph = DiGraph<Neon::set::container::GraphNode, GraphDependency>;
+
+    friend Neon::skeleton::internal::MultiXpuGraph;
+    friend Graph;
 
    public:
     GraphDependency();
-    GraphDependency(GraphDependencyType type);
 
-    auto setType(GraphDependencyType type) -> void;
-    auto getType() const-> GraphDependencyType;
+    explicit GraphDependency(GraphDependencyType   type,
+                             const RawGraph::Edge& edge);
+
+    explicit GraphDependency(const Token&          type,
+                             const RawGraph::Edge& edge);
+
+    explicit GraphDependency(const Tokens&         type,
+                             const RawGraph::Edge& edge);
+
+    auto setType(GraphDependencyType   type,
+                 const RawGraph::Edge& edge)
+        -> void;
+
+    auto getType()
+        const -> GraphDependencyType;
+
+    auto getLabel() const
+        -> std::string;
+
+    auto addToken(const Neon::set::dataDependency::Token& token)
+        -> void;
+
+    auto getSourceNode(const Graph& graph)
+        const -> const GraphNode&;
+
+    auto getDestinationNode(const Graph& graph)
+        const -> const GraphNode&;
+    /**
+     * Returns the tokens generating this dependency
+     */
+    auto getTokens()
+        const -> const Tokens&;
+
+    auto hasStencilDependency()
+        const -> bool;
 
    private:
+    auto getRawEdge()
+        const -> RawGraph::Edge;
+
     GraphDependencyType mType;
+    Tokens              mTokens /**< Tokens creating this dependency. */;
+    RawGraph::Edge      mEdge;
     // TODO - add information for data and Scheduling dependency
 };
 
diff --git a/libNeonSet/include/Neon/set/container/graph/GraphInfo.h b/libNeonSet/include/Neon/set/container/graph/GraphInfo.h
new file mode 100644
index 00000000..b834f638
--- /dev/null
+++ b/libNeonSet/include/Neon/set/container/graph/GraphInfo.h
@@ -0,0 +1,36 @@
+#pragma once
+
+#include <cstdint>
+#include "vector"
+
+namespace Neon::set::container {
+
+class GraphInfo
+{
+   public:
+    using NodeUid = uint64_t;
+    using NodeIdx = uint64_t;
+
+    constexpr static NodeUid notSet = 0;
+    constexpr static NodeUid beginUid = 1;
+    constexpr static NodeUid endUid = 2;
+    constexpr static NodeUid firstInternal = 3;
+
+    GraphInfo();
+    GraphInfo(int uid);
+
+    auto setUid(NodeUid uid) -> void;
+    auto setIndex(NodeIdx index) -> void;
+
+    auto getUid() const -> NodeUid;
+    auto getIndex() const -> NodeIdx;
+
+   private:
+    NodeUid mUid /**< unique identifier for the node.
+              * This is different from a Container uid as in a graph the same container can appear more than once.
+              * */
+        ;
+    NodeIdx mIndex /** relative index w.r.t the completed graph. This value may change during the life of the graph */;
+};
+
+}  // namespace Neon::set::container
diff --git a/libNeonSet/include/Neon/set/container/graph/GraphNode.h b/libNeonSet/include/Neon/set/container/graph/GraphNode.h
index a0ad22d8..71504272 100644
--- a/libNeonSet/include/Neon/set/container/graph/GraphNode.h
+++ b/libNeonSet/include/Neon/set/container/graph/GraphNode.h
@@ -2,15 +2,18 @@
 
 #include "GraphData.h"
 #include "GraphNodeScheduling.h"
-#include "Neon/set/Containter.h"
+#include "Neon/set/container/types/ContainerOperationType.h"
+#include "Neon/set/container/types/ContainerPatternType.h"
+
+namespace Neon::set {
+struct Container;
+}
 
 namespace Neon::set::container {
 
+
 struct GraphNode
 {
-    std::string getLabel(bool debug);
-
-    std::string         getLabelProperty();
 
    public:
     GraphNode();
@@ -21,65 +24,89 @@ struct GraphNode
     /**
      * Factory method to generate a begin node
      */
-    static auto newBeginNode() -> GraphNode;
+    static auto newBeginNode()
+        -> GraphNode;
 
     /**
      * Factory method to generate a end node
      */
-    static auto newEndNode() -> GraphNode;
+    static auto newEndNode()
+        -> GraphNode;
 
     /**
      * Executes the scheduling operation associated to the node
      */
-    auto execute() -> void;
+    auto execute()
+        -> void;
 
     /**
      * Returns a reference to graph information related to this node.
      * */
-    auto getGraphData() -> GraphData&;
+    auto getGraphData()
+        -> GraphData&;
 
     /**
      * Returns a reference to some graph information related to this node.
      * */
-    auto getGraphData() const -> const GraphData&;
+    auto getGraphData()
+        const -> const GraphData&;
 
     /**
      * Returns the scheduling information to run this node
      */
-    auto getScheduling() -> GraphNodeScheduling&;
+    auto getScheduling()
+        -> GraphNodeScheduling&;
 
     /**
      * Returns the scheduling information to run this node
      */
-    auto getScheduling() const -> const GraphNodeScheduling&;
+    auto getScheduling()
+        const -> const GraphNodeScheduling&;
 
     /**
      * Returns a reference to the container stored by this node.
      */
-    auto getContainer() -> Container&;
+    auto getContainer()
+        -> Container&;
 
     /**
      * Returns a reference to the container stored by this node.
      */
-    auto getContainer() const -> const Container&;
+    auto getContainer()
+        const -> const Container&;
 
     /**
      * Returns the operation type of the container associated to this node
      */
-    auto getContainerOperationType() const -> Neon::set::ContainerOperationType;
+    auto getContainerOperationType()
+        const -> Neon::set::ContainerOperationType;
 
-    auto toString() -> std::string;
+    auto toString()
+        const -> std::string;
 
+    auto getLabel(bool debug)
+        const -> std::string;
+
+    auto getLabelProperty()
+        const -> std::string;
 
    private:
-    auto helpGetDotProperties() -> std::string;
-    auto helpGetDotName() -> std::string;
-    auto helpGetDotInfo() -> std::string;
-
-    Container           mContainer /**< Any Neon container */;
-    GraphNodeScheduling mGraphNodeScheduling /**< Scheduling information for the node */;
-    GraphData           mGraphNodeOrganization /**< Information to organize the node w.r.t. the rest of the graph */;
-    ContainerPatternType getContainerpatternType() const;
+    auto helpGetDotProperties()
+        const -> std::string;
+
+    auto helpGetDotName()
+        const -> std::string;
+
+    auto helpGetDotInfo()
+        const -> std::string;
+
+    auto getContainerpatternType()
+        const -> ContainerPatternType;
+
+
+    std::shared_ptr<Container> mContainerPrt /**< Any Neon container */;
+    GraphNodeScheduling        mGraphNodeScheduling /**< Scheduling information for the node */;
+    GraphData                  mGraphNodeOrganization /**< Information to organize the node w.r.t. the rest of the graph */;
 };
 
 }  // namespace Neon::set::container
diff --git a/libNeonSet/include/Neon/set/container/graph/GraphNodeScheduling.h b/libNeonSet/include/Neon/set/container/graph/GraphNodeScheduling.h
index caae61dc..a9ade1c2 100644
--- a/libNeonSet/include/Neon/set/container/graph/GraphNodeScheduling.h
+++ b/libNeonSet/include/Neon/set/container/graph/GraphNodeScheduling.h
@@ -11,31 +11,38 @@ class GraphNodeScheduling
     /**
      *  Get list of events to wait the completion of.
      */
-    auto getDependentEvents() -> std::vector<int>&;
+    auto getDependentEvents()
+        -> std::vector<int>&;
+
+    auto getDependentEvents()
+        const -> const std::vector<int>&;
 
     /**
      * Set the data view for the node
      * @param dataView
      */
-    auto setDataView(Neon::DataView dataView) -> void;
+    auto setDataView(Neon::DataView dataView)
+        -> void;
 
     GraphNodeScheduling();
 
     /**
      * Returns data view associated to this node;
      */
-    auto getDataView() const -> Neon::DataView;
+    auto getDataView()
+        const -> Neon::DataView;
 
     /**
      *  Get the stream to execute the Container
      */
-    auto getStream() const
-        -> int;
+    auto getStream()
+        const -> int;
 
     /**
      * Set the stream for the Container execution
      */
-    auto setStream(int stream /**< stream for the Container execution */) -> void;
+    auto setStream(int stream /**< stream for the Container execution */)
+        -> void;
 
     /**
      *  Get the event to asynchronously signal that the execution of the Container is completed.
@@ -46,16 +53,25 @@ class GraphNodeScheduling
     /**
      * Set the event to asynchronously signal the completion of the Container.
      */
-    auto setEvent(int event /**< Event to be used to signal the completion of the Container */) -> void;
+    auto setEvent(int event /**< Event to be used to signal the completion of the Container */)
+        -> void;
+
+    auto getExecutionOrder() const
+        -> int;
+
+    auto setExecutionOerder(int)
+        -> void;
 
     /**
      * Reset all scheduling data
      */
-    void reset();
+    auto reset()
+        -> void;
 
    private:
     int              mStream{-1} /**< Stream for each operation for the node */;
     int              mEvent{-1} /**< Event to be used to signal the completion of the node container */;
+    int              mExecutionOrder;
     std::vector<int> mDependentEvents /**< Events to be waited for before running the Container */;
     Neon::DataView   mDataView{DataView::STANDARD};
 };
diff --git a/libNeonSet/include/Neon/set/container/ContainerExecutionType.h b/libNeonSet/include/Neon/set/container/types/ContainerExecutionType.h
similarity index 70%
rename from libNeonSet/include/Neon/set/container/ContainerExecutionType.h
rename to libNeonSet/include/Neon/set/container/types/ContainerExecutionType.h
index 2673c4e2..202296ef 100644
--- a/libNeonSet/include/Neon/set/container/ContainerExecutionType.h
+++ b/libNeonSet/include/Neon/set/container/types/ContainerExecutionType.h
@@ -1,7 +1,6 @@
 #pragma once
 
 #include "Neon/set/DevSet.h"
-#include "Neon/set/dependencyTools/DataParsing.h"
 #include "functional"
 #include "type_traits"
 
@@ -18,18 +17,26 @@ enum struct ContainerExecutionType
     deviceThenHostManaged = 2, /** a container that stores operation on both device and host. For this type of Container a getHostContainer method is enabled to retrieved a container with the host code */
     hostManaged = 3 /** host managed container */,
     graph = 4 /** A complex container */,
-    none = 5
+    communication = 5,
+    none = 6
 };
 
 
 struct ContainerExecutionTypeUtils
 {
-    static constexpr int nOptions = 5;
+    static constexpr int nOptions = 6;
 
-    static auto toString(ContainerExecutionType option) -> std::string;
-    static auto fromString(const std::string& option) -> ContainerExecutionType;
-    static auto getOptions() -> std::array<ContainerExecutionType, nOptions>;
-    static auto isExpandable(ContainerExecutionType option) -> bool;
+    static auto toString(ContainerExecutionType option)
+        -> std::string;
+
+    static auto fromString(const std::string& option)
+        -> ContainerExecutionType;
+
+    static auto getOptions()
+        -> std::array<ContainerExecutionType, nOptions>;
+
+    static auto isExpandable(ContainerExecutionType option)
+        -> bool;
 };
 
 /**
diff --git a/libNeonSet/include/Neon/set/container/ContainerOperationType.h b/libNeonSet/include/Neon/set/container/types/ContainerOperationType.h
similarity index 87%
rename from libNeonSet/include/Neon/set/container/ContainerOperationType.h
rename to libNeonSet/include/Neon/set/container/types/ContainerOperationType.h
index edf9b061..59fae9aa 100644
--- a/libNeonSet/include/Neon/set/container/ContainerOperationType.h
+++ b/libNeonSet/include/Neon/set/container/types/ContainerOperationType.h
@@ -1,7 +1,6 @@
 #pragma once
 
 #include "Neon/set/DevSet.h"
-#include "Neon/set/dependencyTools/DataParsing.h"
 #include "functional"
 #include "type_traits"
 
@@ -15,8 +14,8 @@ enum struct ContainerOperationType
 {
     compute = 0 /**< Compute container, can be on host or device */,
     graph = 1 /**<  A graph based container */,
-    halo = 2 /**< Halo update container **/,
-    sync = 3 /**< Synchronization Container */,
+    communication = 2 /**< Halo update container **/,
+    synchronization = 3 /**< Synchronization Container */,
     anchor = 4 /**< Synchronization Container: begin or end */
 };
 
@@ -47,4 +46,3 @@ struct ContainerOperationTypeUtils
 std::ostream& operator<<(std::ostream& os, Neon::set::ContainerOperationType const& m);
 
 }  // namespace Neon::set
-
diff --git a/libNeonSet/include/Neon/set/container/ContainerPatternType.h b/libNeonSet/include/Neon/set/container/types/ContainerPatternType.h
similarity index 93%
rename from libNeonSet/include/Neon/set/container/ContainerPatternType.h
rename to libNeonSet/include/Neon/set/container/types/ContainerPatternType.h
index 93b16a21..19424520 100644
--- a/libNeonSet/include/Neon/set/container/ContainerPatternType.h
+++ b/libNeonSet/include/Neon/set/container/types/ContainerPatternType.h
@@ -1,7 +1,6 @@
 #pragma once
 
 #include "Neon/set/DevSet.h"
-#include "Neon/set/dependencyTools/DataParsing.h"
 #include "functional"
 #include "type_traits"
 
diff --git a/libNeonSet/include/Neon/set/container/HostManagedSyncType.h b/libNeonSet/include/Neon/set/container/types/HostManagedSyncType.h
similarity index 100%
rename from libNeonSet/include/Neon/set/container/HostManagedSyncType.h
rename to libNeonSet/include/Neon/set/container/types/HostManagedSyncType.h
diff --git a/libNeonSet/include/Neon/set/container/types/SynchronizationContainerType.h b/libNeonSet/include/Neon/set/container/types/SynchronizationContainerType.h
new file mode 100644
index 00000000..522bea21
--- /dev/null
+++ b/libNeonSet/include/Neon/set/container/types/SynchronizationContainerType.h
@@ -0,0 +1,38 @@
+#pragma once
+
+#include "Neon/set/DevSet.h"
+#include "functional"
+#include "type_traits"
+
+/**
+ * Abstract interface to hide
+ */
+
+namespace Neon::set {
+
+enum struct SynchronizationContainerType
+{
+    hostOmpBarrier = 0,
+    none = 6
+};
+
+
+struct SynchronizationContainerTypeUtils
+{
+    static constexpr int nOptions = 1;
+
+    static auto toString(SynchronizationContainerType option)
+        -> std::string;
+
+    static auto fromString(const std::string& option)
+        -> SynchronizationContainerType;
+
+    static auto getOptions()
+        -> std::array<SynchronizationContainerType, nOptions>;
+};
+
+/**
+ * operator<<
+ */
+std::ostream& operator<<(std::ostream& os, Neon::set::SynchronizationContainerType const& m);
+}  // namespace Neon::set
diff --git a/libNeonSet/include/Neon/set/dependency/AccessType.h b/libNeonSet/include/Neon/set/dependency/AccessType.h
new file mode 100644
index 00000000..dc7bdc88
--- /dev/null
+++ b/libNeonSet/include/Neon/set/dependency/AccessType.h
@@ -0,0 +1,25 @@
+#pragma once
+#include "Neon/set/Backend.h"
+
+namespace Neon::set::dataDependency {
+
+
+/**
+ * Define type of operation for a kernel parameter: Read or write.
+ * Write includes also complex operation where the parameter is both read and written.
+ */
+enum struct AccessType
+{
+    READ /**< The field or kernel parameter is in read only mode */,
+    WRITE /**< The field or kernel parameter is in write mode (this include read and write) */,
+    NONE /**< Not defined */
+
+};
+
+struct AccessTypeUtils
+{
+    static auto toString(AccessType val) -> std::string;
+    static auto merge(AccessType valA, AccessType valB) -> AccessType;
+};
+
+}  // namespace Neon::dependency
\ No newline at end of file
diff --git a/libNeonSet/include/Neon/set/dependency/ComputeType.h b/libNeonSet/include/Neon/set/dependency/ComputeType.h
new file mode 100644
index 00000000..fe9b30bb
--- /dev/null
+++ b/libNeonSet/include/Neon/set/dependency/ComputeType.h
@@ -0,0 +1,28 @@
+#pragma once
+#include "Neon/set/Backend.h"
+
+namespace Neon {
+
+
+/**
+ * Enumeration for the supported type of computation by the skeleton
+ * */
+enum struct Compute
+{
+    MAP /**< Map operation */,
+    STENCIL /**< Stencil operation */,
+    REDUCE /**< Reduction operation */
+};
+
+struct ComputeUtils
+{
+    /**
+     * Returns a string for the selected allocator
+     *
+     * @param allocator
+     * @return
+     */
+    static auto toString(Compute val) -> std::string;
+};
+
+}  // namespace Neon
\ No newline at end of file
diff --git a/libNeonSet/include/Neon/set/dependency/DataDependencyType.h b/libNeonSet/include/Neon/set/dependency/DataDependencyType.h
new file mode 100644
index 00000000..378d1b93
--- /dev/null
+++ b/libNeonSet/include/Neon/set/dependency/DataDependencyType.h
@@ -0,0 +1,30 @@
+#pragma once
+#include "Neon/set/Backend.h"
+
+namespace Neon::set::dataDependency {
+
+/**
+ * Classical definition of dependency types.
+ */
+enum struct DataDependencyType
+{
+    RAW /**< Read after write */,
+    WAR /**< Write after read */,
+    RAR /**< Read after read. This is not actually a true dependency */,
+    WAW /**< This configuration may indicate something wrong in the user graph */,
+    NONE /**< Not defined */
+};
+
+struct DataDependencyTypeUtils
+{
+    /**
+     * Returns a string for the selected allocator
+     *
+     * @param allocator
+     * @return
+     */
+    static auto toString(DataDependencyType type) -> std::string;
+};
+
+std::ostream& operator<<(std::ostream& os, Neon::set::dataDependency::DataDependencyType const& m);
+}
diff --git a/libNeonSet/include/Neon/set/dependency/Token.h b/libNeonSet/include/Neon/set/dependency/Token.h
new file mode 100644
index 00000000..60044268
--- /dev/null
+++ b/libNeonSet/include/Neon/set/dependency/Token.h
@@ -0,0 +1,84 @@
+#pragma once
+
+#include "ComputeType.h"
+#include "Neon/set/Backend.h"
+#include "Neon/set/HuOptions.h"
+#include "Neon/set/MultiXpuDataUid.h"
+#include "Neon/set/dependency/AccessType.h"
+
+namespace Neon::set {
+struct Container;
+}
+
+namespace Neon::set::dataDependency {
+
+/**
+ * Stores type of operations on data for each kernels while user code is "parsed"
+ * It is used to construct the user kernel dependency graph
+ */
+struct Token
+{
+   public:
+    Token() = delete;
+
+    /**
+     * Unique constructor
+     */
+    Token(Neon::set::dataDependency::MultiXpuDataUid m_uid,
+          Neon::set::dataDependency::AccessType      m_access,
+          Neon::Compute                              m_compute);
+
+    /**
+     * Method to update a token
+     */
+    auto update(Neon::set::dataDependency::MultiXpuDataUid m_uid,
+                Neon::set::dataDependency::AccessType      m_access,
+                Neon::Compute                              m_compute)
+        -> void;
+
+    /**
+     * It returns the multi-GPU data uid
+     */
+    auto uid()
+        const -> Neon::set::dataDependency::MultiXpuDataUid;
+
+    /**
+     * It returns the type of data access
+     */
+    auto access()
+        const -> Neon::set::dataDependency::AccessType;
+
+    /**
+     * Returns the compute pattern
+     */
+    auto compute()
+        const -> Neon::Compute;
+
+    /**
+     * Converts the token into a string
+     */
+    auto toString()
+        const -> std::string;
+
+    /**
+     * It sets the halo update container associated to the multi-GPU data.
+     */
+    auto setDataTransferContainer(std::function<Neon::set::Container(Neon::set::TransferMode transferMode)> huPerDevice)
+        -> void;
+
+    auto getDataTransferContainer(Neon::set::TransferMode transferMode)
+        const -> Neon::set::Container;
+
+    auto mergeAccess(AccessType)
+        -> void;
+
+
+   private:
+    Neon::set::dataDependency::MultiXpuDataUid mUid;
+    Neon::set::dataDependency::AccessType      mAccess;
+    Neon::Compute                              mCompute;
+
+    std::function<Neon::set::Container(Neon::set::TransferMode transferMode)> mHaloUpdateExtractor;
+};
+
+}  // namespace Neon::set::dataDependency
diff --git a/libNeonSet/include/Neon/set/dependencyTools/Alias.h b/libNeonSet/include/Neon/set/dependencyTools/Alias.h
deleted file mode 100644
index 5cfcfae6..00000000
--- a/libNeonSet/include/Neon/set/dependencyTools/Alias.h
+++ /dev/null
@@ -1,27 +0,0 @@
-#pragma once
-#include "Neon/set/Backend.h"
-
-namespace Neon {
-namespace set {
-namespace internal {
-namespace dependencyTools {
-
-/**
- * Unique identifier for a kernel parameter
- */
-using DataUId_t = int64_t;
-
-/**
- * Unique identifier for a kernel parameter
- */
-using DataIdx_t = int64_t;
-
-/**
- * Index of a KernelContainer
- */
-using KernelContainerIdx_t = int64_t;
-
-}  // namespace dependencyTools
-}  // namespace internal
-}  // namespace set
-}  // namespace Neon
\ No newline at end of file
diff --git a/libNeonSet/include/Neon/set/dependencyTools/DataParsing.h b/libNeonSet/include/Neon/set/dependencyTools/DataParsing.h
deleted file mode 100644
index f6c64749..00000000
--- a/libNeonSet/include/Neon/set/dependencyTools/DataParsing.h
+++ /dev/null
@@ -1,52 +0,0 @@
-#pragma once
-#include "Neon/set/Backend.h"
-#include "Neon/set/HuOptions.h"
-#include "Neon/set/dependencyTools/Alias.h"
-#include "Neon/set/dependencyTools/enum.h"
-
-namespace Neon {
-namespace set {
-namespace internal {
-namespace dependencyTools {
-
-/**
- * Stores type of operations on data for each kernels while user code is "parsed"
- * It is used to construct the user kernel dependency graph
- */
-struct DataToken
-{
-   private:
-    DataUId_t                                                    m_uid;
-    Access_e                                                     m_access;
-    Compute                                                      m_compute;
-    std::function<void(Neon::set::HuOptions& opt)>               m_hu;
-    std::function<void(Neon::SetIdx, Neon::set::HuOptions& opt)> m_huPerDevice;
-
-   public:
-    DataToken() = delete;
-
-    DataToken(DataUId_t     m_uid,
-              Access_et::e  m_access,
-              Neon::Compute m_compute);
-
-    auto update(DataUId_t     m_uid,
-                Access_et::e  m_access,
-                Neon::Compute m_compute) -> void;
-    auto uid() const -> DataUId_t;
-    auto access() const -> Access_et::e;
-    auto compute() const -> Neon::Compute;
-    auto toString() const -> std::string;
-
-    auto setHaloUpdate(std::function<void(Neon::set::HuOptions& opt)>               hu,
-                       std::function<void(Neon::SetIdx, Neon::set::HuOptions& opt)> huPerDevice) -> void;
-
-    auto getHaloUpdate() const -> const std::function<void(Neon::set::HuOptions& opt)>&;
-    auto getHaloUpdatePerDevice() const -> const std::function<void(Neon::SetIdx, Neon::set::HuOptions& opt)>&;
-
-    auto mergeAccess( Access_et::e)->void ;
-};
-
-}  // namespace dependencyTools
-}  // namespace internal
-}  // namespace set
-}  // namespace Neon
\ No newline at end of file
diff --git a/libNeonSet/include/Neon/set/dependencyTools/enum.h b/libNeonSet/include/Neon/set/dependencyTools/enum.h
deleted file mode 100644
index a80bf07b..00000000
--- a/libNeonSet/include/Neon/set/dependencyTools/enum.h
+++ /dev/null
@@ -1,74 +0,0 @@
-#pragma once
-#include "Neon/set/Backend.h"
-
-namespace Neon {
-namespace set {
-namespace internal {
-namespace dependencyTools {
-
-/**
- * Define type of operation for a kernel parameter: Read or write.
- * Write includes also complex operation where the parameter is both read and written.
- */
-struct Access_et
-{
-    Access_et() = delete;
-    Access_et(const Access_et&) = delete;
-
-    enum e
-    {
-        READ /**< The field or kernel parameter is in read only mode */,
-        WRITE /**< The field or kernel parameter is in write mode (this include read and write) */,
-        NONE /**< Not defined */
-    };
-    static auto toString(e val) -> std::string;
-    static auto merge(e valA, e valB) -> e;
-
-};
-using Access_e = Access_et::e;
-
-/**
- * Classical definition of dependency types.
- */
-struct Dependencies_et
-{
-    Dependencies_et() = delete;
-    Dependencies_et(const Dependencies_et&) = delete;
-
-    enum e
-    {
-        RAW /**< Read after write */,
-        WAR /**< Write after read */,
-        RAR /**< Read after read. This is not actually a true dependency */,
-        WAW /**< This configuration may indicate something wrong in the user graph */,
-        NONE /**< Not defined */
-    };
-    static auto toString(e val) -> std::string;
-};
-using Dependencies_e = Dependencies_et::e;
-}  // namespace dependencyTools
-}  // namespace internal
-}  // namespace set
-
-/**
- * Enumeration for the supported type of computation by the skeleton
- * */
-enum struct Compute
-{
-    MAP /**< Map operation */,
-    STENCIL /**< Stencil operation */,
-    REDUCE /**< Reduction operation */
-};
-
-struct ComputeUtils
-{
-    /**
-     * Returns a string for the selected allocator
-     *
-     * @param allocator
-     * @return
-     */
-    static auto toString(Compute allocator) -> const char*;
-};
-
-}  // namespace Neon
\ No newline at end of file
diff --git a/libNeonSet/include/Neon/set/memory/memSet.h b/libNeonSet/include/Neon/set/memory/memSet.h
index 73d9e076..1255876a 100644
--- a/libNeonSet/include/Neon/set/memory/memSet.h
+++ b/libNeonSet/include/Neon/set/memory/memSet.h
@@ -115,10 +115,10 @@ class MemSet_t
         m_memSet_shp = std::make_shared<Mem_vec>(numEntries);
     }
 
-    auto uid() const -> Neon::set::MultiDeviceObjectUid
+    auto uid() const -> Neon::set::dataDependency::MultiXpuDataUid
     {
-        void*                           addr = static_cast<void*>(m_memSet_shp.get());
-        Neon::set::MultiDeviceObjectUid uidRes = (size_t)addr;
+        void* addr = static_cast<void*>(m_memSet_shp.get());
+        auto  uidRes = (Neon::set::dataDependency::MultiXpuDataUid)addr;
         return uidRes;
     }
 
diff --git a/libNeonSet/src/set/Backend.cpp b/libNeonSet/src/set/Backend.cpp
index 24cdd5ed..b9bfe1df 100644
--- a/libNeonSet/src/set/Backend.cpp
+++ b/libNeonSet/src/set/Backend.cpp
@@ -166,24 +166,24 @@ auto Backend::eventSet(Neon::EventIdx eventdx) -> Neon::set::GpuEventSet&
     return selfData().userEventSetVec.at(eventdx);
 }
 
-auto Backend::streamSetRotate(int&                    rotateIdx,
-                              const std::vector<int>& streamIdxVec)
-    const
-    -> const Neon::set::StreamSet&
-{
-    int streamIdx = Backend::streamSetIdxRotate(rotateIdx, streamIdxVec);
-    return selfData().streamSetVec.at(streamIdx);
-}
-
-auto Backend::streamSetIdxRotate(int&                    rotateIdx,
-                                 const std::vector<int>& streamIdxVec)
-    -> int
-{
-    int streamIdx = streamIdxVec.at(rotateIdx);
-    rotateIdx++;
-    rotateIdx = rotateIdx % streamIdxVec.size();
-    return streamIdx;
-}
+//auto Backend::streamSetRotate(int&                    rotateIdx,
+//                              const std::vector<int>& streamIdxVec)
+//    const
+//    -> const Neon::set::StreamSet&
+//{
+//    int streamIdx = Backend::streamSetIdxRotate(rotateIdx, streamIdxVec);
+//    return selfData().streamSetVec.at(streamIdx);
+//}
+//
+//auto Backend::streamSetIdxRotate(int&                    rotateIdx,
+//                                 const std::vector<int>& streamIdxVec)
+//    -> int
+//{
+//    int streamIdx = streamIdxVec.at(rotateIdx);
+//    rotateIdx++;
+//    rotateIdx = rotateIdx % streamIdxVec.size();
+//    return streamIdx;
+//}
 
 auto Backend::pushEventOnStream(int eventId, int streamId)
     -> void
@@ -299,63 +299,63 @@ auto Backend::waitEventOnStream(Neon::SetIdx setIdx, int eventId, int streamId)
     }
 }
 
-auto Backend::streamEventBarrier(const std::vector<int>& streamIdxVec) -> void
-{
-    switch (selfData().runtime) {
-        case Neon::Runtime::openmp: {
-            return;
-        }
-        case Neon::Runtime::stream: {
-            break;
-            ;
-        }
-        default: {
-            NEON_THROW_UNSUPPORTED_OPTION("");
-        }
-    }
-
-    for (int i = 0; i < int(streamIdxVec.size()); i++) {
-        selfData().streamSetVec.at(i).enqueueEvent(selfData().eventSetVec.at(i));
-    }
-
-
-    auto nextPowerOfTwo = [](unsigned int n) -> unsigned int {
-        // if n=4 v=4
-        // if n=5 v=8
-        int v = n;
-
-        v--;
-        v |= v >> 1;
-        v |= v >> 2;
-        v |= v >> 4;
-        v |= v >> 8;
-        v |= v >> 16;
-        v++;  // next power of 2
-
-        return v;
-    };
-    const unsigned int nstreams = (unsigned int)(streamIdxVec.size());
-    const unsigned int nstreamsPow2 = nextPowerOfTwo(nstreams);
-
-    for (int rLevel = 1; rLevel < int(nstreamsPow2); rLevel *= 2) {
-        const int waiterJump = rLevel * 2;
-        const int neighbourToWaitJump = rLevel;
-        for (int waiterId = 0; waiterId < int(nstreams); waiterId += waiterJump) {
-            const int neighbourId = waiterId + neighbourToWaitJump;
-            if (neighbourId < int(nstreams)) {
-                int waiterStreamId = streamIdxVec[waiterId];
-                int neighbourEventId = streamIdxVec[neighbourId];
-
-                auto waiterStream = selfData().streamSetVec.at(waiterStreamId);
-                auto neighborEvent = selfData().eventSetVec.at(neighbourEventId);
-                waiterStream.waitForEvent(neighborEvent);
-                // std::cout << " waiterStreamId " << waiterStreamId <<" neighbourEventId " <<neighbourEventId<<std::endl;
-            }
-        }
-    }
-
-    return;
-}
+//auto Backend::streamEventBarrier(const std::vector<int>& streamIdxVec) -> void
+//{
+//    switch (selfData().runtime) {
+//        case Neon::Runtime::openmp: {
+//            return;
+//        }
+//        case Neon::Runtime::stream: {
+//            break;
+//            ;
+//        }
+//        default: {
+//            NEON_THROW_UNSUPPORTED_OPTION("");
+//        }
+//    }
+//
+//    for (int i = 0; i < int(streamIdxVec.size()); i++) {
+//        selfData().streamSetVec.at(i).enqueueEvent(selfData().eventSetVec.at(i));
+//    }
+//
+//
+//    auto nextPowerOfTwo = [](unsigned int n) -> unsigned int {
+//        // if n=4 v=4
+//        // if n=5 v=8
+//        int v = n;
+//
+//        v--;
+//        v |= v >> 1;
+//        v |= v >> 2;
+//        v |= v >> 4;
+//        v |= v >> 8;
+//        v |= v >> 16;
+//        v++;  // next power of 2
+//
+//        return v;
+//    };
+//    const unsigned int nstreams = (unsigned int)(streamIdxVec.size());
+//    const unsigned int nstreamsPow2 = nextPowerOfTwo(nstreams);
+//
+//    for (int rLevel = 1; rLevel < int(nstreamsPow2); rLevel *= 2) {
+//        const int waiterJump = rLevel * 2;
+//        const int neighbourToWaitJump = rLevel;
+//        for (int waiterId = 0; waiterId < int(nstreams); waiterId += waiterJump) {
+//            const int neighbourId = waiterId + neighbourToWaitJump;
+//            if (neighbourId < int(nstreams)) {
+//                int waiterStreamId = streamIdxVec[waiterId];
+//                int neighbourEventId = streamIdxVec[neighbourId];
+//
+//                auto waiterStream = selfData().streamSetVec.at(waiterStreamId);
+//                auto neighborEvent = selfData().eventSetVec.at(neighbourEventId);
+//                waiterStream.waitForEvent(neighborEvent);
+//                // std::cout << " waiterStreamId " << waiterStreamId <<" neighbourEventId " <<neighbourEventId<<std::endl;
+//            }
+//        }
+//    }
+//
+//    return;
+//}
 
 auto Backend::setAvailableStreamSet(int nStreamSets) -> void
 {
@@ -445,6 +445,21 @@ auto Backend::sync(Neon::SetIdx setIdx, int idx) const -> void
     NEON_THROW(exp);
 }
 
+auto Backend::syncEvent(Neon::SetIdx setIdx, int eventIdx) const -> void
+{
+    if (runtime() == Neon::Runtime::openmp) {
+        return;
+    }
+    if (runtime() == Neon::Runtime::stream) {
+        const Neon::set::GpuEventSet& eventSet = selfData().userEventSetVec.at(eventIdx);
+        eventSet.sync(setIdx);
+        return;
+    }
+    NeonException exp("BackendConfig_t");
+    exp << "Backend::sync with idx not permitted for a " << Neon::RuntimeUtils::toString(runtime()) << "backend";
+    NEON_THROW(exp);
+}
+
 auto Backend::runMode() const -> const Neon::run_et ::et&
 {
     return selfData().runMode;
diff --git a/libNeonSet/src/set/Containter.cpp b/libNeonSet/src/set/Containter.cpp
index a8e198cb..390ef9e5 100644
--- a/libNeonSet/src/set/Containter.cpp
+++ b/libNeonSet/src/set/Containter.cpp
@@ -1,5 +1,7 @@
 #include "Neon/set/Containter.h"
 #include "Neon/set/container/AnchorContainer.h"
+#include "Neon/set/container/SynchronizationContainer.h"
+#include "Neon/set/container/Loader.h"
 
 namespace Neon::set {
 
@@ -130,5 +132,4 @@ auto Container::factoryGraph(const std::string&                         name,
     return Container(tmp);
 }
 
-
 }  // namespace Neon::set
diff --git a/libNeonSet/src/set/GpuStream.cpp b/libNeonSet/src/set/GpuStream.cpp
index be5069af..6a8c8e91 100644
--- a/libNeonSet/src/set/GpuStream.cpp
+++ b/libNeonSet/src/set/GpuStream.cpp
@@ -1,10 +1,10 @@
+#include <omp.h>
+#include <vector>
 #include "Neon/core/core.h"
 #include "Neon/set/GpuStreamSet.h"
 #include "Neon/sys/devices/gpu/ComputeID.h"
 #include "Neon/sys/global/GpuSysGlobal.h"
 
-#include <vector>
-
 namespace Neon {
 namespace set {
 
@@ -61,9 +61,10 @@ auto StreamSet::enqueueEvent(GpuEventSet& eventSet) const
     -> void
 {
     const int ndevs = int(m_streamVec.size());
-#pragma omp parallel for num_threads(ndevs)
-    for (int i = 0; i < ndevs; i++) {
-        m_streamVec.at(i).enqueueEvent(eventSet.event<Neon::Access::readWrite>(i));
+#pragma omp parallel num_threads(ndevs)
+    {
+        int tid = omp_get_thread_num();
+        m_streamVec.at(tid).enqueueEvent(eventSet.event<Neon::Access::readWrite>(tid));
     }
 }
 
@@ -78,9 +79,10 @@ auto StreamSet::waitForEvent(GpuEventSet& eventSet) const
     -> void
 {
     const int ndevs = int(m_streamVec.size());
-#pragma omp parallel for num_threads(ndevs)
-    for (int i = 0; i < ndevs; i++) {
-        m_streamVec.at(i).waitForEvent(eventSet.event<Neon::Access::readWrite>(i));
+#pragma omp parallel num_threads(ndevs)
+    {
+        int tid = omp_get_thread_num();
+        m_streamVec.at(tid).waitForEvent(eventSet.event<Neon::Access::readWrite>(tid));
     }
 }
 
diff --git a/libNeonSet/src/set/HuOptions.cpp b/libNeonSet/src/set/HuOptions.cpp
index 978d9939..f7295a0f 100644
--- a/libNeonSet/src/set/HuOptions.cpp
+++ b/libNeonSet/src/set/HuOptions.cpp
@@ -7,7 +7,7 @@ namespace set {
 HuOptions::HuOptions(Neon::set::TransferMode     transferMode,
                      bool                        startWithBarrier,
                      int                         streamSetIdx,
-                     Neon::set::TransferSemantic structure)
+                     Neon::set::StencilSemantic structure)
     : m_startWithBarrier(startWithBarrier),
       m_streamSetIdx(streamSetIdx),
       m_peerTransferOpt(transferMode, structure),
@@ -18,7 +18,7 @@ HuOptions::HuOptions(Neon::set::TransferMode     transferMode,
 
 HuOptions::HuOptions(Neon::set::TransferMode transferMode,
                      NEON_OUT std::vector<Neon::set::Transfer>& transfers,
-                     Neon::set::TransferSemantic                structure)
+                     Neon::set::StencilSemantic                 structure)
     : m_startWithBarrier(false),
       m_streamSetIdx(0),
       m_peerTransferOpt(transferMode, transfers, structure),
@@ -27,7 +27,8 @@ HuOptions::HuOptions(Neon::set::TransferMode transferMode,
     // EMPTY
 }
 
-auto HuOptions::getPeerTransferOpt(const Neon::Backend& bk) -> Neon::set::PeerTransferOption&
+auto HuOptions::getPeerTransferOpt(const Neon::Backend& bk)
+    -> Neon::set::PeerTransferOption&
 {
     if (m_peerTransferOpt.operationMode() ==
         Neon::set::PeerTransferOption::operationMode_e::storeInfo) {
@@ -52,7 +53,8 @@ auto HuOptions::streamSetIdx() const
     return m_streamSetIdx;
 }
 
-auto HuOptions::transfers() -> std::vector<Neon::set::Transfer>&
+auto HuOptions::transfers()
+    -> std::vector<Neon::set::Transfer>&
 {
     return m_peerTransferOpt.transfers();
 }
@@ -75,7 +77,8 @@ auto HuOptions::isExecuteMode() const
     return operationMode() == Neon::set::PeerTransferOption::operationMode_e::execute;
 }
 
-auto HuOptions::structure() -> Neon::set::TransferSemantic
+auto HuOptions::getSemantic()
+    const -> Neon::set::StencilSemantic
 {
     return m_structure;
 }
diff --git a/libNeonSet/src/set/StencilSemantic.cpp b/libNeonSet/src/set/StencilSemantic.cpp
new file mode 100644
index 00000000..560b687a
--- /dev/null
+++ b/libNeonSet/src/set/StencilSemantic.cpp
@@ -0,0 +1,98 @@
+#include "Neon/set/StencilSemantic.h"
+
+namespace Neon::set {
+
+auto StencilSemanticUtils::toString(StencilSemantic option) -> std::string
+{
+    switch (option) {
+        case StencilSemantic::streaming: {
+            return "streaming";
+        }
+        case StencilSemantic::standard: {
+            return "grid";
+        }
+    }
+    NEON_THROW_UNSUPPORTED_OPTION("");
+}
+
+auto StencilSemanticUtils::fromString(const std::string& occ) -> StencilSemantic
+{
+    std::array<StencilSemantic, 4> opts{StencilSemantic::standard, StencilSemantic::streaming};
+    for (auto a : opts) {
+        if (toString(a) == occ) {
+            return a;
+        }
+    }
+    NEON_THROW_UNSUPPORTED_OPTION("");
+}
+
+auto StencilSemanticUtils::getOptions() -> std::array<StencilSemantic, nOptions>
+{
+    std::array<StencilSemantic, nOptions> opts = {StencilSemantic::standard, StencilSemantic::streaming};
+    return opts;
+}
+
+StencilSemanticUtils::Cli::Cli()
+{
+    mSet = false;
+}
+
+StencilSemanticUtils::Cli::Cli(std::string s)
+{
+    set(s);
+}
+
+StencilSemanticUtils::Cli::Cli(StencilSemantic model)
+{
+    mOption = model;
+}
+
+auto StencilSemanticUtils::Cli::getOption() -> StencilSemantic
+{
+    if (!mSet) {
+        std::stringstream errorMsg;
+        errorMsg << "TransferSemantic was not set.";
+        NEON_ERROR(errorMsg.str());
+    }
+    return mOption;
+}
+
+auto StencilSemanticUtils::Cli::set(const std::string& opt)
+    -> void
+{
+    try {
+        mOption = StencilSemanticUtils::fromString(opt);
+    } catch (...) {
+        std::stringstream errorMsg;
+        errorMsg << "TransferSemantic: " << opt << " is not a valid option (valid options are {";
+        auto options = StencilSemanticUtils::getOptions();
+        int i = 0;
+        for (auto o : options) {
+            if(i!=0){
+                errorMsg << ", "<< StencilSemanticUtils::toString(o) ;
+            }
+            errorMsg << StencilSemanticUtils::toString(o);
+            i=1;
+        }
+        errorMsg << "})";
+        NEON_ERROR(errorMsg.str());
+    }
+    mSet = true;
+}
+
+auto StencilSemanticUtils::Cli::getStringOptions() -> std::string
+{
+    std::stringstream s;
+    auto              options = StencilSemanticUtils::getOptions();
+    int               i = 0;
+    for (auto o : options) {
+        if (i != 0) {
+            s << ", " ;
+        }
+        s << StencilSemanticUtils::toString(o);
+        i = 1;
+    }
+    std::string msg= s.str();
+    return msg;
+}
+}  // namespace Neon
diff --git a/libNeonSet/src/set/TransferSemantic.cpp b/libNeonSet/src/set/TransferSemantic.cpp
deleted file mode 100644
index 0fb4b395..00000000
--- a/libNeonSet/src/set/TransferSemantic.cpp
+++ /dev/null
@@ -1,98 +0,0 @@
-#include "Neon/set/TransferSemantic.h"
-
-namespace Neon::set {
-
-auto TransferSemanticUtils::toString(TransferSemantic occ) -> std::string
-{
-    switch (occ) {
-        case TransferSemantic::lattice: {
-            return "lattice";
-        }
-        case TransferSemantic::grid: {
-            return "grid";
-        }
-    }
-    NEON_THROW_UNSUPPORTED_OPTION("");
-}
-
-auto TransferSemanticUtils::fromString(const std::string& occ) -> TransferSemantic
-{
-    std::array<TransferSemantic, 4> opts{TransferSemantic::grid, TransferSemantic::lattice};
-    for (auto a : opts) {
-        if (toString(a) == occ) {
-            return a;
-        }
-    }
-    NEON_THROW_UNSUPPORTED_OPTION("");
-}
-
-auto TransferSemanticUtils::getOptions() -> std::array<TransferSemantic, nOptions>
-{
-    std::array<TransferSemantic, nOptions> opts = {TransferSemantic::grid, TransferSemantic::lattice};
-    return opts;
-}
-
-TransferSemanticUtils::Cli::Cli()
-{
-    mSet = false;
-}
-
-TransferSemanticUtils::Cli::Cli(std::string s)
-{
-    set(s);
-}
-
-TransferSemanticUtils::Cli::Cli(TransferSemantic model)
-{
-    mOption = model;
-}
-
-auto TransferSemanticUtils::Cli::getOption() -> TransferSemantic
-{
-    if (!mSet) {
-        std::stringstream errorMsg;
-        errorMsg << "TransferSemantic was not set.";
-        NEON_ERROR(errorMsg.str());
-    }
-    return mOption;
-}
-
-auto TransferSemanticUtils::Cli::set(const std::string& opt)
-    -> void
-{
-    try {
-        mOption = TransferSemanticUtils::fromString(opt);
-    } catch (...) {
-        std::stringstream errorMsg;
-        errorMsg << "TransferSemantic: " << opt << " is not a valid option (valid options are {";
-        auto options = TransferSemanticUtils::getOptions();
-        int i = 0;
-        for (auto o : options) {
-            if(i!=0){
-                errorMsg << ", "<< TransferSemanticUtils::toString(o) ;
-            }
-            errorMsg << TransferSemanticUtils::toString(o);
-            i=1;
-        }
-        errorMsg << "})";
-        NEON_ERROR(errorMsg.str());
-    }
-    mSet = true;
-}
-
-auto TransferSemanticUtils::Cli::getStringOptions() -> std::string
-{
-    std::stringstream s;
-    auto              options = TransferSemanticUtils::getOptions();
-    int               i = 0;
-    for (auto o : options) {
-        if (i != 0) {
-            s << ", " ;
-        }
-        s << TransferSemanticUtils::toString(o);
-        i = 1;
-    }
-    std::string msg= s.str();
-    return msg;
-}
-}  // namespace Neon
diff --git a/libNeonSet/src/set/container/AnchorContainer.cpp b/libNeonSet/src/set/container/AnchorContainer.cpp
index b100e679..38667ee6 100644
--- a/libNeonSet/src/set/container/AnchorContainer.cpp
+++ b/libNeonSet/src/set/container/AnchorContainer.cpp
@@ -13,26 +13,25 @@ AnchorContainer::AnchorContainer(const std::string& name)
 }
 
 
-auto AnchorContainer::parse() -> const std::vector<Neon::set::internal::dependencyTools::DataToken>&
+auto AnchorContainer::
+    parse()
+        -> const std::vector<Neon::set::dataDependency::Token>&
 {
     return mEmtpy;
 }
 
-auto AnchorContainer::getHostContainer() -> std::shared_ptr<ContainerAPI>
+auto AnchorContainer::
+    run(int /*streamIdx*/,
+        Neon::DataView /*dataView*/)
+        -> void
 {
-    NEON_THROW_UNSUPPORTED_OPTION("This Container type can not be decoupled.");
 }
 
-auto AnchorContainer::getDeviceContainer() -> std::shared_ptr<ContainerAPI>
-{
-    NEON_THROW_UNSUPPORTED_OPTION("This Container type can not be decoupled.");
-}
-
-auto AnchorContainer::run(int /*streamIdx*/ , Neon::DataView /*dataView*/ ) -> void
-{
-}
-
-auto AnchorContainer::run(Neon::SetIdx /*setIdx*/, int /*streamIdx*/, Neon::DataView /*dataView*/) -> void
+auto AnchorContainer::
+    run(Neon::SetIdx /*setIdx*/,
+        int /*streamIdx*/,
+        Neon::DataView /*dataView*/)
+        -> void
 {
 }
 
diff --git a/libNeonSet/src/set/container/ContainerAPI.cpp b/libNeonSet/src/set/container/ContainerAPI.cpp
index c7e07f8d..a9b70f92 100644
--- a/libNeonSet/src/set/container/ContainerAPI.cpp
+++ b/libNeonSet/src/set/container/ContainerAPI.cpp
@@ -1,69 +1,81 @@
 #include "Neon/set/container/ContainerAPI.h"
+#include "Neon/set/dependency/Token.h"
 
 namespace Neon::set::internal {
 
 
-auto ContainerAPI::addToken(Neon::set::internal::dependencyTools::DataToken& dataParsing)
-    -> void
+auto ContainerAPI::
+    addToken(Neon::set::dataDependency::Token& dataParsing)
+        -> void
 {
     mParsed.push_back(dataParsing);
 }
 
-auto ContainerAPI::getName() const
+auto ContainerAPI::
+    getName() const
     -> const std::string&
 {
     return mName;
 }
 
-auto ContainerAPI::getTokens() const
-    -> const std::vector<Neon::set::internal::dependencyTools::DataToken>&
+auto ContainerAPI::
+    getTokens()
+        const -> const std::vector<Neon::set::dataDependency::Token>&
 {
     return mParsed;
 }
 
-auto ContainerAPI::getTokenRef()
-    -> std::vector<Neon::set::internal::dependencyTools::DataToken>&
+auto ContainerAPI::
+    getTokensRef()
+        -> std::vector<Neon::set::dataDependency::Token>&
 {
     return mParsed;
 }
 
-auto ContainerAPI::setName(const std::string& name)
-    -> void
+auto ContainerAPI::
+    setName(const std::string& name)
+        -> void
 {
     mName = name;
 }
 
-auto ContainerAPI::setLaunchParameters(Neon::DataView dw)
-    -> Neon::set::LaunchParameters&
+auto ContainerAPI::
+    setLaunchParameters(Neon::DataView dw)
+        -> Neon::set::LaunchParameters&
 {
     return mLaunchParameters[DataViewUtil::toInt(dw)];
 }
 
-auto ContainerAPI::getLaunchParameters(Neon::DataView dw) const
-    -> const Neon::set::LaunchParameters&
+auto ContainerAPI::
+    getLaunchParameters(Neon::DataView dw)
+        const -> const Neon::set::LaunchParameters&
 {
     return mLaunchParameters[DataViewUtil::toInt(dw)];
 }
 
-auto ContainerAPI::getDataViewSupport() const -> ContainerAPI::DataViewSupport
+auto ContainerAPI::
+    getDataViewSupport() const -> ContainerAPI::DataViewSupport
 {
     return mDataViewSupport;
 }
 
-auto ContainerAPI::setDataViewSupport(ContainerAPI::DataViewSupport dataViewSupport)
-    -> void
+auto ContainerAPI::
+    setDataViewSupport(ContainerAPI::DataViewSupport dataViewSupport)
+        -> void
 {
     mDataViewSupport = dataViewSupport;
 }
 
-auto ContainerAPI::setContainerPattern(Neon::set::ContainerPatternType patternType)
-    -> void
+auto ContainerAPI::
+    setContainerPattern(Neon::set::ContainerPatternType patternType)
+        -> void
 {
     this->mContainerPatternType = patternType;
 }
 
-auto ContainerAPI::setContainerPattern(const std::vector<Neon::set::internal::dependencyTools::DataToken>& tokens)
-    -> void
+auto ContainerAPI::
+    setContainerPattern(const std::vector<Neon::set::dataDependency::Token>& tokens)
+        -> void
 {
     Neon::set::ContainerPatternType patternType = Neon::set::ContainerPatternType::map;
 
@@ -84,8 +96,9 @@ auto ContainerAPI::setContainerPattern(const std::vector<Neon::set::internal::de
     this->mContainerPatternType = patternType;
 }
 
-auto ContainerAPI::toLog(uint64_t uid)
-    -> void
+auto ContainerAPI::
+    toLog(uint64_t uid)
+        -> void
 {
     std::stringstream listOfTokes;
     for (auto& token : mParsed) {
@@ -97,41 +110,47 @@ auto ContainerAPI::toLog(uint64_t uid)
     NEON_INFO("Container {}: tokens = [{}]", uid, listOfTokes.str());
 }
 
-auto ContainerAPI::getContainerExecutionType()
-    const
+auto ContainerAPI::
+    getContainerExecutionType()
+        const
     -> ContainerExecutionType
 {
     return mContainerExecutionType;
 }
 
-auto ContainerAPI::getContainerOperationType()
-    const
+auto ContainerAPI::
+    getContainerOperationType()
+        const
     -> ContainerOperationType
 {
     return mContainerOperationType;
 }
 
-auto ContainerAPI::getContainerPatternType()
-    const
+auto ContainerAPI::
+    getContainerPatternType()
+        const
     -> ContainerPatternType
 {
     return mContainerPatternType;
 }
 
-auto ContainerAPI::setContainerExecutionType(ContainerExecutionType containerType)
-    -> void
+auto ContainerAPI::
+    setContainerExecutionType(ContainerExecutionType containerType)
+        -> void
 {
     mContainerExecutionType = containerType;
 }
 
-auto ContainerAPI::setContainerOperationType(ContainerOperationType containerType)
-    -> void
+auto ContainerAPI::
+    setContainerOperationType(ContainerOperationType containerType)
+        -> void
 {
     mContainerOperationType = containerType;
 }
 
-auto ContainerAPI::getGraph()
-    -> const Neon::set::container::Graph&
+auto ContainerAPI::
+    getGraph()
+        const -> const Neon::set::container::Graph&
 {
     std::string         description = helpGetNameForError();
     Neon::NeonException exp("ContainerAPI");
@@ -141,8 +160,9 @@ auto ContainerAPI::getGraph()
     NEON_THROW(exp);
 }
 
-auto ContainerAPI::getHostContainer()
-    -> std::shared_ptr<ContainerAPI>
+auto ContainerAPI::
+    getHostContainer()
+        -> std::shared_ptr<ContainerAPI>
 {
     std::string         description = helpGetNameForError();
     Neon::NeonException exp("ContainerAPI");
@@ -152,8 +172,9 @@ auto ContainerAPI::getHostContainer()
     NEON_THROW(exp);
 }
 
-auto ContainerAPI::helpGetNameForError()
-    -> std::string
+auto ContainerAPI::
+    helpGetNameForError()
+        const -> std::string
 {
     std::stringstream s;
     s << getName()
@@ -164,8 +185,9 @@ auto ContainerAPI::helpGetNameForError()
     return s.str();
 }
 
-auto ContainerAPI::getDeviceContainer()
-    -> std::shared_ptr<ContainerAPI>
+auto ContainerAPI::
+    getDeviceContainer()
+        -> std::shared_ptr<ContainerAPI>
 {
     std::string         description = helpGetNameForError();
     Neon::NeonException exp("ContainerAPI");
@@ -175,13 +197,47 @@ auto ContainerAPI::getDeviceContainer()
     NEON_THROW(exp);
 }
 
-auto ContainerAPI::isParsingDataUpdated() -> bool
+auto ContainerAPI::
+    isParsingDataUpdated() -> bool
 {
     return mParsingDataUpdated;
 }
 
-auto ContainerAPI::setParsingDataUpdated(bool status) -> void
+auto ContainerAPI::
+    setParsingDataUpdated(bool status) -> void
 {
     mParsingDataUpdated = status;
 }
+
+auto ContainerAPI::
+    parse()
+        -> const std::vector<Neon::set::dataDependency::Token>&
+{
+    std::string         description = helpGetNameForError();
+    Neon::NeonException exp("ContainerAPI");
+    exp << description << " "
+        << "parse"
+        << " is not supported.";
+    NEON_THROW(exp);
+}
+
+auto ContainerAPI::
+    getTransferMode()
+        const -> Neon::set::TransferMode
+{
+    std::string         description = helpGetNameForError();
+    Neon::NeonException exp("ContainerAPI");
+    exp << description << " "
+        << "getTransferMode"
+        << " is not supported.";
+    NEON_THROW(exp);
+}
+
+
+auto ContainerAPI::
+ configureWithScheduling([[maybe_unused]] Neon::set::container::GraphNode& graphNode)
+        -> void{
+
+}
+
 }  // namespace Neon::set::internal
diff --git a/libNeonSet/src/set/container/Graph.cpp b/libNeonSet/src/set/container/Graph.cpp
index d9541cdb..0ec71b31 100644
--- a/libNeonSet/src/set/container/Graph.cpp
+++ b/libNeonSet/src/set/container/Graph.cpp
@@ -1,7 +1,10 @@
 #include "Neon/set/container/Graph.h"
 #include <algorithm>
+#include "Neon/set/Containter.h"
 #include "Neon/set/container/graph/Bfs.h"
-
+#ifdef NEON_USE_NVTX
+#include <nvToolsExt.h>
+#endif
 namespace Neon::set::container {
 
 Graph::Graph()
@@ -16,21 +19,27 @@ Graph::Graph()
     helpInvalidateScheduling();
 }
 
-auto Graph::getBeginNode() const -> const GraphNode&
+auto Graph::
+    getBeginNode()
+        const -> const GraphNode&
 {
     return mRawGraph.getVertexProperty(GraphData::beginUid);
 }
 
-auto Graph::getEndNode() const -> const GraphNode&
+auto Graph::
+    getEndNode()
+        const -> const GraphNode&
 {
     return mRawGraph.getVertexProperty(GraphData::endUid);
 }
 
-auto Graph::addNodeInBetween(const GraphNode&          nodeA,
-                             Container                 containerB,
-                             const GraphNode&          nodeC,
-                             const GraphDependencyType ab,
-                             const GraphDependencyType bc) -> GraphNode&
+auto Graph::
+    addNodeInBetween(const GraphNode&          nodeA,
+                     Container                 containerB,
+                     const GraphNode&          nodeC,
+                     const GraphDependencyType ab,
+                     const GraphDependencyType bc)
+        -> GraphNode&
 {
     helpCheckBackendStatus();
     helpInvalidateScheduling();
@@ -41,7 +50,9 @@ auto Graph::addNodeInBetween(const GraphNode&          nodeA,
     return nodeB;
 }
 
-auto Graph::addNode(const Container& container) -> GraphNode&
+auto Graph::
+    addNode(const Container& container)
+        -> GraphNode&
 {
     helpCheckBackendStatus();
     helpInvalidateScheduling();
@@ -56,9 +67,11 @@ auto Graph::addNode(const Container& container) -> GraphNode&
     return mRawGraph.getVertexProperty(node.getGraphData().getUid());
 }
 
-auto Graph::addDependency(const GraphNode&    nodeA,
-                          const GraphNode&    nodeB,
-                          GraphDependencyType type) -> GraphDependency&
+auto Graph::
+    addDependency(const GraphNode&    nodeA,
+                  const GraphNode&    nodeB,
+                  GraphDependencyType type)
+        -> GraphDependency&
 {
     helpCheckBackendStatus();
     if (nodeA.getGraphData().getUid() == nodeB.getGraphData().getUid()) {
@@ -66,17 +79,92 @@ auto Graph::addDependency(const GraphNode&    nodeA,
     }
     helpInvalidateScheduling();
 
-    GraphDependency ab(type);
+    auto aUid = nodeA.getGraphData().getUid();
+    auto bUid = nodeB.getGraphData().getUid();
+
+    GraphDependency ab(type, {aUid, bUid});
 
     mRawGraph.addEdge(nodeA.getGraphData().getUid(),
                       nodeB.getGraphData().getUid(),
                       ab);
 
+    if (GraphDependencyType::scheduling != type) {
+        if (mRawGraph.hasEdge(aUid, GraphData::endUid) &&
+            GraphData::endUid != bUid) {
+            mRawGraph.removeEdge(aUid, GraphData::endUid);
+        }
+
+        if (mRawGraph.hasEdge(GraphData::beginUid, bUid) &&
+            GraphData::beginUid != aUid) {
+            mRawGraph.removeEdge(GraphData::beginUid, bUid);
+        }
+    }
+
     return mRawGraph.getEdgeProperty({nodeA.getGraphData().getUid(),
                                       nodeB.getGraphData().getUid()});
 }
 
-auto Graph::removeNode(GraphNode& gn) -> Container
+auto Graph::
+    addDependency(const GraphNode&                        nodeA,
+                  const GraphNode&                        nodeB,
+                  const Neon::set::dataDependency::Token& token)
+        -> GraphDependency&
+{
+    helpCheckBackendStatus();
+    if (nodeA.getGraphData().getUid() == nodeB.getGraphData().getUid()) {
+        NEON_THROW_UNSUPPORTED_OPERATION("");
+    }
+    helpInvalidateScheduling();
+
+    if (mRawGraph.hasEdge(nodeA.getGraphData().getUid(),
+                          nodeB.getGraphData().getUid())) {
+        GraphDependency& graphDependency = mRawGraph.getEdgeProperty({nodeA.getGraphData().getUid(),
+                                                                      nodeB.getGraphData().getUid()});
+        graphDependency.addToken(token);
+    } else {
+        GraphDependency ab(token, {nodeA.getGraphData().getUid(),
+                                   nodeB.getGraphData().getUid()});
+
+        mRawGraph.addEdge(nodeA.getGraphData().getUid(),
+                          nodeB.getGraphData().getUid(),
+                          ab);
+    }
+
+
+    return mRawGraph.getEdgeProperty({nodeA.getGraphData().getUid(),
+                                      nodeB.getGraphData().getUid()});
+}
+
+auto Graph::
+    removeDependency(const GraphDependency& graphDependency)
+        -> void
+{
+    helpCheckBackendStatus();
+    helpInvalidateScheduling();
+
+    const auto& nodeA = graphDependency.getSourceNode(*this);
+    const auto& nodeB = graphDependency.getDestinationNode(*this);
+
+    const auto nodeAuid = nodeA.getGraphData().getUid();
+    const auto nodeBuid = nodeB.getGraphData().getUid();
+    ;
+
+    mRawGraph.removeEdge(nodeAuid,
+                         nodeBuid);
+
+    if (mRawGraph.outEdgesCount(nodeAuid) == 0) {
+        this->addDependency(nodeA, getEndNode(), GraphDependencyType::data);
+    }
+
+    if (mRawGraph.inEdgesCount(nodeBuid) == 0) {
+        this->addDependency(getBeginNode(), nodeB, GraphDependencyType::data);
+    }
+}
+
+
+auto Graph::
+    removeNode(GraphNode& gn)
+        -> Container
 {
     helpInvalidateScheduling();
 
@@ -117,8 +205,9 @@ auto Graph::removeNode(GraphNode& gn) -> Container
     return gn.getContainer();
 }
 
-auto Graph::removeNodeAndItsDependencies(GraphNode& gn)
-    -> Container
+auto Graph::
+    removeNodeAndItsDependencies(GraphNode& gn)
+        -> Container
 {
     auto uidB = gn.getGraphData().getUid();
 
@@ -161,9 +250,10 @@ auto Graph::removeNodeAndItsDependencies(GraphNode& gn)
     return gn.getContainer();
 }
 
-auto Graph::getProceedingGraphNodes(const GraphNode&                        graphNode,
-                                    const std::vector<GraphDependencyType>& dependencyTypes)
-    -> std::vector<GraphNode*>
+auto Graph::
+    getProceedingGraphNodes(const GraphNode&                        graphNode,
+                            const std::vector<GraphDependencyType>& dependencyTypes)
+        -> std::vector<GraphNode*>
 {
     std::vector<GraphNode*> nodes;
 
@@ -191,9 +281,10 @@ auto Graph::getProceedingGraphNodes(const GraphNode&                        grap
     return nodes;
 }
 
-auto Graph::getSubsequentGraphNodes(const GraphNode&                        graphNode,
-                                    const std::vector<GraphDependencyType>& dependencyTypes)
-    -> std::vector<GraphNode*>
+auto Graph::
+    getSubsequentGraphNodes(const GraphNode&                        graphNode,
+                            const std::vector<GraphDependencyType>& dependencyTypes)
+        -> std::vector<GraphNode*>
 {
     std::vector<GraphNode*> nodes;
 
@@ -220,8 +311,9 @@ auto Graph::getSubsequentGraphNodes(const GraphNode&                        grap
     return nodes;
 }
 
-auto Graph::cloneNode(const GraphNode& graphNode)
-    -> GraphNode&
+auto Graph::
+    cloneNode(const GraphNode& graphNode)
+        -> GraphNode&
 {
     helpInvalidateScheduling();
 
@@ -239,13 +331,13 @@ auto Graph::cloneNode(const GraphNode& graphNode)
         auto dependencyType = getDependencyType(graphNode, *post);
         addDependency(newNode, *post, dependencyType);
     }
-
     return newNode;
 }
 
-auto Graph::getDependencyType(const GraphNode& nodeA,
-                              const GraphNode& nodeB)
-    -> GraphDependencyType
+auto Graph::
+    getDependencyType(const GraphNode& nodeA,
+                      const GraphNode& nodeB)
+        -> GraphDependencyType
 {
     auto uidA = nodeA.getGraphData().getUid();
     auto uidB = nodeB.getGraphData().getUid();
@@ -256,14 +348,42 @@ auto Graph::getDependencyType(const GraphNode& nodeA,
     return dependencyType;
 }
 
-auto Graph::helpInvalidateScheduling()
-    -> void
+auto Graph::
+    getDependency(const GraphNode& nodeA,
+                  const GraphNode& nodeB)
+        const -> const GraphDependency&
+{
+    auto uidA = nodeA.getGraphData().getUid();
+    auto uidB = nodeB.getGraphData().getUid();
+
+    const auto& dependency = mRawGraph.getEdgeProperty({uidA, uidB});
+
+    return dependency;
+}
+
+auto Graph::
+    getMutableDependency(const GraphNode& nodeA,
+                         const GraphNode& nodeB)
+        -> GraphDependency&
+{
+    auto uidA = nodeA.getGraphData().getUid();
+    auto uidB = nodeB.getGraphData().getUid();
+
+    auto& dependency = mRawGraph.getEdgeProperty({uidA, uidB});
+
+    return dependency;
+}
+
+auto Graph::
+    helpInvalidateScheduling()
+        -> void
 {
     mSchedulingStatusIsValid = false;
 }
 
-auto Graph::helpRemoveRedundantDependencies()
-    -> void
+auto Graph::
+    removeRedundantDependencies()
+        -> void
 {
     // Vectors of edges to be removed
     std::vector<std::pair<size_t, size_t>> edgesToBeRemoved;
@@ -272,17 +392,21 @@ auto Graph::helpRemoveRedundantDependencies()
         // For each node do:
 
         // Check node's children
-        auto visitingNode = mRawGraph.getVertexProperty(diGraphNodeId).getGraphData().getUid();
-        const auto& children = helpGetOutNeighbors(visitingNode, false);
-        if (children.size() <= 1) {
+        auto        visitingNode = this->helpGetGraphNode(diGraphNodeId);
+        const auto& childrenPtr = this->getSubsequentGraphNodes(visitingNode, {GraphDependencyType::user,
+                                                                               GraphDependencyType::data});
+        if (childrenPtr.size() <= 1) {
             // If no more than one, move to the next node
             // Nothing to do for the visiting node as there are no redundant paths
             // Let's move to another
             return;
         }
         // Start checking for redundant paths
-        for (const auto& targetChild : children) {
-            if (helpGetInEdges(targetChild, false).size() <= 1) {
+        for (const auto& targetChildPtr : childrenPtr) {
+            if (this->getProceedingGraphNodes(*targetChildPtr, {GraphDependencyType::user,
+                                                                GraphDependencyType::data})
+                    .size() <= 1) {
+                //                helpGetInEdges(targetChild, false).size() <= 1) {
                 // This targetChild can only be reached by one father
                 // No redundant path here
                 continue;
@@ -291,24 +415,32 @@ auto Graph::helpRemoveRedundantDependencies()
             // Checking all siblings' paths.
             // We are looking for the targetChild in the path of any of its siblings.
             // A BFS visit is used for the process.
-            for (const auto& targetSibling : children) {
-                if (targetSibling == targetChild) {
+            for (const auto& targetSiblingPtr : childrenPtr) {
+                if (targetSiblingPtr->getGraphData().getUid() ==
+                    targetChildPtr->getGraphData().getUid()) {
                     continue;
                 }
                 // first BFS frontier are the targetSibling's child
-                auto frontier = mRawGraph.outNeighbors(targetSibling);
-                while (frontier.size() != 0) {
+                auto frontierOfUid = [&] {
+                    auto             vec = this->getSubsequentGraphNodes(*targetSiblingPtr);
+                    std::set<size_t> output;
+                    for (auto v : vec) {
+                        output.insert(v->getGraphData().getUid());
+                    }
+                    return output;
+                }();
+                while (!frontierOfUid.empty()) {
                     auto nextFrontier = std::set<size_t>();
 
-                    for (const auto& nodeInFrontier : frontier) {
-                        if (nodeInFrontier == targetChild) {
+                    for (const auto& nodeUidInFrontier : frontierOfUid) {
+                        if (nodeUidInFrontier == targetChildPtr->getGraphData().getUid()) {
                             // We have found a redundant path
                             foundRedundant = true;
                             break;
                         } else {
                             // Let's continue by updating the frontier for the next iteration
-                            for (auto nodeFrontierForNextIteration : helpGetOutNeighbors(nodeInFrontier)) {
-                                nextFrontier.insert(nodeFrontierForNextIteration);
+                            for (auto nodeFrontierForNextIteration : this->getSubsequentGraphNodes(this->helpGetGraphNode(nodeUidInFrontier))) {
+                                nextFrontier.insert(nodeFrontierForNextIteration->getGraphData().getUid());
                             }
                         }
                     }
@@ -317,13 +449,14 @@ auto Graph::helpRemoveRedundantDependencies()
                         // A longer and altenrative path has been found.
                         break;
                     }
-                    frontier = nextFrontier;
+                    frontierOfUid = nextFrontier;
                 }
                 if (foundRedundant)
                     break;
             }
             if (foundRedundant) {
-                edgesToBeRemoved.push_back({visitingNode, targetChild});
+                edgesToBeRemoved.push_back({visitingNode.getGraphData().getUid(),
+                                            targetChildPtr->getGraphData().getUid()});
             }
         }
     });
@@ -332,10 +465,11 @@ auto Graph::helpRemoveRedundantDependencies()
     }
 }
 
-auto Graph::helpGetOutNeighbors(GraphData::Uid                          nodeUid,
-                                bool                                    filteredOut,
-                                const std::vector<GraphDependencyType>& dependencyTypes)
-    -> std::set<GraphData::Uid>
+auto Graph::
+    helpGetOutNeighbors(GraphData::Uid                          nodeUid,
+                        bool                                    filteredOut,
+                        const std::vector<GraphDependencyType>& dependencyTypes)
+        -> std::set<GraphData::Uid>
 {
     std::set<GraphData::Uid> outNgh;
     mRawGraph.forEachOutEdge(
@@ -355,10 +489,11 @@ auto Graph::helpGetOutNeighbors(GraphData::Uid                          nodeUid,
     return outNgh;
 }
 
-auto Graph::helpGetInNeighbors(GraphData::Uid                          nodeUid,
-                               bool                                    filterOutBegin,
-                               const std::vector<GraphDependencyType>& dependencyTypes)
-    -> std::set<GraphData::Uid>
+auto Graph::
+    helpGetInNeighbors(GraphData::Uid                          nodeUid,
+                       bool                                    filterOutBegin,
+                       const std::vector<GraphDependencyType>& dependencyTypes)
+        -> std::set<GraphData::Uid>
 {
     std::set<GraphData::Uid> inNgh;
     mRawGraph.forEachInEdge(
@@ -377,10 +512,11 @@ auto Graph::helpGetInNeighbors(GraphData::Uid                          nodeUid,
     return inNgh;
 }
 
-auto Graph::helpGetOutEdges(GraphData::Uid                          nodeUid,
-                            bool                                    filterOutEnd,
-                            const std::vector<GraphDependencyType>& dependencyTypes)
-    -> std::set<std::pair<GraphData::Uid, GraphData::Uid>>
+auto Graph::
+    helpGetOutEdges(GraphData::Uid                          nodeUid,
+                    bool                                    filterOutEnd,
+                    const std::vector<GraphDependencyType>& dependencyTypes)
+        -> std::set<std::pair<GraphData::Uid, GraphData::Uid>>
 {
     std::set<std::pair<GraphData::Uid, GraphData::Uid>> outEdges;
     mRawGraph.forEachOutEdge(
@@ -399,10 +535,11 @@ auto Graph::helpGetOutEdges(GraphData::Uid                          nodeUid,
     return outEdges;
 }
 
-auto Graph::helpGetInEdges(GraphData::Uid                          nodeUid,
-                           bool                                    filterOutBegin,
-                           const std::vector<GraphDependencyType>& dependencyTypes)
-    -> std::set<std::pair<GraphData::Uid, GraphData::Uid>>
+auto Graph::
+    helpGetInEdges(GraphData::Uid                          nodeUid,
+                   bool                                    filterOutBegin,
+                   const std::vector<GraphDependencyType>& dependencyTypes)
+        -> std::set<std::pair<GraphData::Uid, GraphData::Uid>>
 {
     std::set<std::pair<GraphData::Uid, GraphData::Uid>> inEdges;
     mRawGraph.forEachInEdge(
@@ -421,9 +558,10 @@ auto Graph::helpGetInEdges(GraphData::Uid                          nodeUid,
     return inEdges;
 }
 
-auto Graph::helpGetBFS(bool                                    filterOutBeginEnd,
-                       const std::vector<GraphDependencyType>& dependencyTypes)
-    -> Bfs
+auto Graph::
+    helpGetBFS(bool                                    filterOutBeginEnd,
+               const std::vector<GraphDependencyType>& dependencyTypes)
+        -> Bfs
 {
     using Frontier = std::unordered_map<GraphData::Uid, size_t>;
 
@@ -431,10 +569,23 @@ auto Graph::helpGetBFS(bool                                    filterOutBeginEnd
 
     Frontier a;
     Frontier b;
+    Frontier tmp;
 
     Frontier* currentFrontier = &a;
     Frontier* nextFrontier = &b;
 
+    [[maybe_unused]] auto printFrontier = [](const Frontier* frontier,
+                                             std::string     prefix = "") {
+        std::stringstream s;
+        s << "[";
+        s << prefix << " ";
+        for (auto& el : *frontier) {
+            auto [nodeId, counter] = el;
+            s << "(" << nodeId << "," << counter << ")";
+        }
+        s << "]";
+        std::cout << s.str() << std::endl;
+    };
 
     if (!filterOutBeginEnd) {
         currentFrontier->insert({getBeginNode().getGraphData().getUid(), 0});
@@ -450,30 +601,46 @@ auto Graph::helpGetBFS(bool                                    filterOutBeginEnd
     while (currentFrontier->size() != 0) {
         auto [newLevel, newLevelIdx] = bfs.getNewLevel();
         nextFrontier->clear();
+        tmp.clear();
+
+        {  // all nodes with a counter higher than 1 are moved directly to the next frontier
+            for (auto& currentFrontierNode : *currentFrontier) {
+                if (currentFrontierNode.second == 0) {
+                    tmp.insert(currentFrontierNode);
+                } else {
+                    nextFrontier->insert(currentFrontierNode);
+                }
+            }
+            *currentFrontier = tmp;
+        }
 
+        // printFrontier(currentFrontier, "currentFrontier");
+        // printFrontier(nextFrontier, "nextFrontier");
         for (auto& currentFrontierNode : *currentFrontier) {
-            if (currentFrontierNode.second == 0) {
-                // All incoming dependencies have been resolved.
-                // The node is ready to be added to the current BFS level
-                newLevel.push_back(currentFrontierNode.first);
-
-                // Adding the node's children to the next frontier
-                auto currentFrontierNodeChildren = helpGetOutNeighbors(currentFrontierNode.first, filterOutBeginEnd);
-                for (const auto& child : currentFrontierNodeChildren) {
-                    auto it = std::find_if(nextFrontier->begin(), nextFrontier->end(),
-                                           [&child](auto& entry) {
-                                               return (entry.first == child);
-                                           });
-                    if (it != nextFrontier->end()) {
-                        it->second--;
-                    } else {
-                        auto numChildDependencies = helpGetInEdges(child, filterOutBeginEnd).size();
-                        nextFrontier->insert({child, numChildDependencies - 1});
-                    }
+            // At this any currentFrontierNode has .second ==0;
+            // printFrontier(currentFrontier, "currentFrontier");
+            // std::cout << "selecting " << currentFrontierNode.first << std::endl;
+
+            // All incoming dependencies have been resolved.
+            // The node is ready to be added to the current BFS level
+            newLevel.push_back(currentFrontierNode.first);
+
+            // Adding the node's children to the next frontier
+            auto currentFrontierNodeChildren = helpGetOutNeighbors(currentFrontierNode.first,
+                                                                   filterOutBeginEnd, dependencyTypes);
+            for (const auto& child : currentFrontierNodeChildren) {
+                auto it = std::find_if(nextFrontier->begin(), nextFrontier->end(),
+                                       [&child](auto& entry) {
+                                           return (entry.first == child);
+                                       });
+                if (it != nextFrontier->end()) {
+                    it->second--;
+                } else {
+                    auto numChildDependencies = helpGetInEdges(child, filterOutBeginEnd, dependencyTypes).size();
+                    nextFrontier->insert({child, numChildDependencies - 1});
                 }
-            } else {
-                nextFrontier->insert(currentFrontierNode);
             }
+            // printFrontier(nextFrontier, "nextFrontier");
         }
         std::swap(currentFrontier, nextFrontier);
     }
@@ -481,18 +648,21 @@ auto Graph::helpGetBFS(bool                                    filterOutBeginEnd
     return bfs;
 }
 
-auto Graph::helpComputeScheduling(bool filterOutAnchors, int anchorStream)
-    -> void
+auto Graph::
+    helpComputeScheduling(bool filterOutAnchors, int anchorStream)
+        -> void
 {
     helpComputeScheduling_00_resetData();
     mBfs = helpComputeScheduling_01_generatingBFS(filterOutAnchors);
     int maxStreamId = helpComputeScheduling_02_mappingStreams(mBfs, filterOutAnchors, anchorStream);
     int maxEventId = helpComputeScheduling_03_events(mBfs);
     helpComputeScheduling_04_ensureResources(maxStreamId, maxEventId);
+    helpComputeScheduling_05_executionOrder(filterOutAnchors, mBfs);
 }
 
-auto Graph::helpComputeScheduling_01_generatingBFS(bool filterOutAnchors)
-    -> Bfs
+auto Graph::
+    helpComputeScheduling_01_generatingBFS(bool filterOutAnchors)
+        -> Bfs
 {
     return helpGetBFS(filterOutAnchors, {GraphDependencyType::data,
                                          GraphDependencyType::user});
@@ -510,31 +680,26 @@ auto Graph::helpGetGraphNode(GraphData::Uid uid) const -> const GraphNode&
 
 auto Graph::helpComputeScheduling_00_resetData() -> void
 {
-    mRawGraph.forEachVertex([&](const GraphData::Uid & graphNodeId) {
+    mRawGraph.forEachVertex([&](const GraphData::Uid& graphNodeId) {
         auto& targetNode = mRawGraph.getVertexProperty(graphNodeId);
         targetNode.getScheduling().reset();
     });
 }
 
-auto Graph::helpComputeScheduling_02_mappingStreams(Bfs& bfs,
-                                                    bool filterOutAnchors,
-                                                    int  anchorStream)
-    -> int
+auto Graph::
+    helpComputeScheduling_02_mappingStreams(Bfs& bfs,
+                                            bool filterOutAnchors,
+                                            int  anchorStream)
+        -> int
 {
-    mSchedulingStatusIsValid = true;
-    mMaxNumberStreams = bfs.getMaxLevelWidth();
-
     // used stream -> true
     // available -> false
     constexpr bool usedStream = true;
     constexpr bool availableStream = false;
 
-    std::vector<bool> streamsStatus(mMaxNumberStreams,
-                                    availableStream);
-
-    auto bookFirstAvailableStream = [&]() {
+    const auto bookFirstAvailableStream = [&](std::vector<bool>& streamsStatus) {
         for (int i = 0; i < int(streamsStatus.size()); i++) {
-            if (availableStream == streamsStatus[i]) {
+            if (availableStream == streamsStatus.at(i)) {
                 streamsStatus[i] = usedStream;
                 return i;
             }
@@ -542,20 +707,31 @@ auto Graph::helpComputeScheduling_02_mappingStreams(Bfs& bfs,
         NEON_THROW_UNSUPPORTED_OPERATION("");
     };
 
-    auto isStreamAvailable = [&](int streamId)
-        -> bool {
-        return streamsStatus[streamId] == availableStream;
-    };
-
-    auto bookStream = [&](int streamId)
+    const auto bookStream = [&](std::vector<bool>& streamsStatus,
+                               int                streamId)
         -> bool {
-        if (isStreamAvailable(streamId)) {
+        if (streamsStatus.at(streamId) == availableStream) {
             streamsStatus[streamId] = usedStream;
             return true;
         }
         return false;
     };
 
+    const auto resetBooking = [&](std::vector<bool>& streamsStatus)
+        -> void {
+        for (auto&& entry : streamsStatus) {
+            entry = availableStream;
+        }
+    };
+
+    mSchedulingStatusIsValid = true;
+    mMaxNumberStreams = bfs.getMaxLevelWidth();
+
+
+    std::vector<bool> streamsStatus(mMaxNumberStreams,
+                                    availableStream);
+
+
     // The stream mapping process is computer per level.
     // On each level we have two steps
     // a. map nodes with the streams of one of the proceeding nodes when possible
@@ -574,42 +750,42 @@ auto Graph::helpComputeScheduling_02_mappingStreams(Bfs& bfs,
                 ex << "Inconsistent status of the container graph.";
                 NEON_THROW(ex);
             }
-            mRawGraph.getVertexProperty(level[0]).getScheduling().setStream(anchorStream);
+            this->helpGetGraphNode(level[0]).getScheduling().setStream(anchorStream);
             return;
         }
         // Step a.
         for (auto& nodeUid : level) {
-            auto& node = mRawGraph.getVertexProperty(nodeUid);
+            auto& node = this->helpGetGraphNode(nodeUid);
 
-            int associatedStream = [&]() -> int {
+            const int helpAssociatedStream = [&] {
                 if (levelIdx == 0) {
-                    return bookFirstAvailableStream();
+                    return bookFirstAvailableStream(streamsStatus);
                 }
-                auto& preNodes = mRawGraph.inNeighbors(node.getGraphData().getUid());
-                for (auto& preNodeIdx : preNodes) {
-                    auto preNodeStream = mRawGraph.getVertexProperty(preNodeIdx).getScheduling().getStream();
-                    if (bookStream(preNodeStream)) {
+                const auto preNodePtrs = this->getProceedingGraphNodes(node);
+                for (auto& preNode : preNodePtrs) {
+                    auto preNodeStream = preNode->getScheduling().getStream();
+                    if (bookStream(streamsStatus, preNodeStream)) {
                         return preNodeStream;
                     }
                 }
                 return -1;
             }();
 
-            if (associatedStream == -1) {
+            if (helpAssociatedStream == -1) {
                 // track nodes that need to go through step 2
                 delayedBooking.push_back(&node);
             } else {
-                node.getScheduling().setStream(associatedStream);
+                node.getScheduling().setStream(helpAssociatedStream);
             }
         }
 
         // Step b.
         for (auto nodePrt : delayedBooking) {
-            auto associatedStream = bookFirstAvailableStream();
-            (*nodePrt).getScheduling().setStream(associatedStream);
+            auto associatedStream = bookFirstAvailableStream(streamsStatus);
+            nodePrt->getScheduling().setStream(associatedStream);
         }
 
-        streamsStatus = std::vector<bool>(mMaxNumberStreams, false);
+        resetBooking(streamsStatus);
     });
 
     if (!filterOutAnchors && anchorStream > -1) {
@@ -618,27 +794,27 @@ auto Graph::helpComputeScheduling_02_mappingStreams(Bfs& bfs,
         endNode.getScheduling().setStream(anchorStream);
     }
 
-    this->ioToDot("tge", "tge", true);
     return mMaxNumberStreams - 1;
 }
 
-auto Graph::helpComputeScheduling_03_events(Bfs& bfs)
-    -> int
+auto Graph::
+    helpComputeScheduling_03_events(Bfs& bfs)
+        -> int
 {
     int eventCount = 0;
 
     bfs.forEachNodeByLevel(*this, [&](GraphNode& targetNode, int /*levelId*/) {
-        int  targetStreamId = targetNode.getScheduling().getStream();
-        auto preNodeIds = mRawGraph.inNeighbors(targetNode.getGraphData().getUid());
-        if (preNodeIds.size() == 0) {
+        int targetStreamId = targetNode.getScheduling().getStream();
+
+        auto preNodeIds = this->getProceedingGraphNodes(targetNode);
+        if (preNodeIds.empty()) {
             // this is the first node, no need to have dependencies
             return;
         }
         // Processing PreNodes on different streams than the node
         std::vector<GraphNode*> preNodesOnDifferentStreams;
-        for (auto nodeId : preNodeIds) {
-            auto& preNode = mRawGraph.getVertexProperty(nodeId);
-            auto  preNodeStream = preNode.getScheduling().getStream();
+        for (auto* preNode : preNodeIds) {
+            auto preNodeStream = preNode->getScheduling().getStream();
             if (preNodeStream == targetStreamId) {
                 continue;
             }
@@ -647,10 +823,10 @@ auto Graph::helpComputeScheduling_03_events(Bfs& bfs)
             // b. add the pre-node event to the list of the target node
 
             // a.
-            int preNodeEvent = preNode.getScheduling().getEvent();
+            int preNodeEvent = preNode->getScheduling().getEvent();
             if (preNodeEvent == -1) {
                 preNodeEvent = eventCount;
-                preNode.getScheduling().setEvent(preNodeEvent);
+                preNode->getScheduling().setEvent(preNodeEvent);
                 eventCount++;
             }
             // b.
@@ -661,20 +837,23 @@ auto Graph::helpComputeScheduling_03_events(Bfs& bfs)
     return eventCount - 1;
 }
 
-auto Graph::helpComputeScheduling_04_ensureResources(int maxStreamId,
-                                                     int maxEventId)
-    -> void
+auto Graph::
+    helpComputeScheduling_04_ensureResources(int maxStreamId,
+                                             int maxEventId)
+        -> void
 {
     auto bk = getBackend();
     bk.setAvailableStreamSet(maxStreamId + 1);
     bk.setAvailableUserEvents(maxEventId + 1);
 }
 
-auto Graph::ioToDot(const std::string& fname,
-                    const std::string& graphName,
-                    bool               debug) -> void
+auto Graph::
+    ioToDot(const std::string& fname,
+            const std::string& graphName,
+            bool               debug)
+        -> void
 {
-    this->helpRemoveRedundantDependencies();
+    this->removeRedundantDependencies();
 
     auto vertexLabel = [&](size_t v) -> std::string {
         auto& node = mRawGraph.getVertexProperty(v);
@@ -693,9 +872,9 @@ auto Graph::ioToDot(const std::string& fname,
 
         if (edgeMeta.getType() == GraphDependencyType::scheduling) {
             // return "style=dashed, color=\"#2A9D8F\"";
-            return "style=dashed, color=\"#F4A261\", penwidth=7";
+            return "style=dashed, color=\"#F4A261\", penwidth=3";
         }
-        return "color=\"#d9d9d9\", penwidth=7";
+        return " penwidth=3";
     };
 
     auto vertexLabelProperty = [&](const size_t& v) {
@@ -706,7 +885,24 @@ auto Graph::ioToDot(const std::string& fname,
                             vertexLabelProperty, edgeLabelProperty);
 }
 
-Graph::Graph(const Backend& bk)
+auto Graph::helpComputeScheduling_05_executionOrder(bool filterOutAnchors, Bfs& bfs) -> void
+{
+    bfs = helpGetBFS(filterOutAnchors, {GraphDependencyType::data,
+                                        GraphDependencyType::user,
+                                        GraphDependencyType::scheduling});
+
+    int levels = bfs.getNumberOfLevels();
+    int execOrder = 0;
+    for (int i = 0; i < levels; i++) {
+        bfs.forEachNodeAtLevel(i, *this, [&](Neon::set::container::GraphNode& graphNode) {
+            graphNode.getScheduling().setExecutionOerder(execOrder);
+            execOrder++;
+        });
+    }
+}
+
+Graph::
+    Graph(const Backend& bk)
 {
     mBackend = bk;
     mBackendIsSet = true;
@@ -721,8 +917,9 @@ Graph::Graph(const Backend& bk)
     helpInvalidateScheduling();
 }
 
-auto Graph::getBackend() const
-    -> const Neon::Backend&
+auto Graph::
+    getBackend()
+        const -> const Neon::Backend&
 {
     if (mBackendIsSet) {
         return mBackend;
@@ -732,10 +929,11 @@ auto Graph::getBackend() const
     NEON_THROW(ex);
 }
 
-auto Graph::run(Neon::SetIdx   setIdx,
-                int            streamIdx,
-                Neon::DataView dataView)
-    -> void
+auto Graph::
+    run(Neon::SetIdx   setIdx,
+        int            streamIdx,
+        Neon::DataView dataView)
+        -> void
 {
     if (dataView != Neon::DataView::STANDARD) {
         NEON_THROW_UNSUPPORTED_OPERATION("");
@@ -745,21 +943,23 @@ auto Graph::run(Neon::SetIdx   setIdx,
     this->helpExecute(setIdx, streamIdx);
 }
 
-auto Graph::run(int            streamIdx,
-                Neon::DataView dataView)
-    -> void
+auto Graph::
+    run(int            streamIdx,
+        Neon::DataView dataView)
+        -> void
 {
     if (dataView != Neon::DataView::STANDARD) {
         NEON_THROW_UNSUPPORTED_OPERATION("");
     }
 
     this->runtimePreSet(streamIdx);
-    this->helpExecute(streamIdx);
+    this->helpExecuteWithOmpAtNodeLevel(streamIdx);
 }
 
-auto Graph::helpExecute(Neon::SetIdx setIdx,
-                        int          anchorStream)
-    -> void
+auto Graph::
+    helpExecute(Neon::SetIdx setIdx,
+                int          anchorStream)
+        -> void
 {
     if (anchorStream > -1 && (anchorStream != mAnchorStreamPreSet || mFilterOutAnchorsPreSet == true)) {
         Neon::NeonException ex("");
@@ -788,8 +988,9 @@ auto Graph::helpExecute(Neon::SetIdx setIdx,
     }
 }
 
-auto Graph::helpExecute(int anchorStream)
-    -> void
+auto Graph::
+    helpExecuteWithOmpAtNodeLevel(int anchorStream)
+        -> void
 {
     if (anchorStream > -1 && (anchorStream != mAnchorStreamPreSet || mFilterOutAnchorsPreSet == true)) {
         Neon::NeonException ex("");
@@ -797,13 +998,75 @@ auto Graph::helpExecute(int anchorStream)
         NEON_THROW(ex);
     }
 
-    int ndevs = getBackend().devSet().setCardinality();
-    {
-#pragma omp parallel for num_threads(ndevs)
-        for (int setIdx = 0; setIdx < ndevs; setIdx++) {
-            helpExecute(setIdx, anchorStream);
-        }
+#ifdef NEON_USE_NVTX
+    nvtxRangePush("Graph Iteration");
+#endif
+    int levels = mBfs.getNumberOfLevels();
+    for (int i = 0; i < levels; i++) {
+        mBfs.forEachNodeAtLevel(i, *this, [&](Neon::set::container::GraphNode& graphNode) {
+            auto&       scheduling = graphNode.getScheduling();
+            auto&       container = graphNode.getContainer();
+            const auto& waitingEvents = scheduling.getDependentEvents();
+            const auto& signalEvents = scheduling.getEvent();
+            const auto& stream = scheduling.getStream();
+
+            for (auto toBeWaited : waitingEvents) {
+                mBackend.waitEventOnStream(toBeWaited, stream);
+            }
+#ifdef NEON_USE_NVTX
+            nvtxRangePush((std::string("Container Run") + container.getName()).c_str());
+#endif
+            container.run(stream, scheduling.getDataView());
+#ifdef NEON_USE_NVTX
+            nvtxRangePop();
+#endif
+            if (signalEvents >= 0) {
+                mBackend.pushEventOnStream(signalEvents, stream);
+            }
+        });
     }
+#ifdef NEON_USE_NVTX
+    nvtxRangePop();
+#endif
+
+    // #ifdef NEON_USE_NVTX
+    //     nvtxRangePush("Graph Iteration");
+    // #endif
+    //
+    //     const int setCardinality = mBackend.devSet().setCardinality();
+    //
+    //     int levels = mBfs.getNumberOfLevels();
+    // #pragma omp parallel num_threads(setCardinality)
+    //     {
+    //         const int threadRank = omp_get_thread_num();
+    //
+    //         for (int i = 0; i < levels; i++) {
+    //             mBfs.forEachNodeAtLevel(i, *this, [&](Neon::set::container::GraphNode& graphNode) {
+    //                 auto&       scheduling = graphNode.getScheduling();
+    //                 auto&       container = graphNode.getContainer();
+    //                 const auto& waitingEvents = scheduling.getDependentEvents();
+    //                 const auto& signalEvents = scheduling.getEvent();
+    //                 const auto& stream = scheduling.getStream();
+    //
+    //                 for (auto toBeWaited : waitingEvents) {
+    //                     mBackend.waitEventOnStream(threadRank, toBeWaited, stream);
+    //                 }
+    // #ifdef NEON_USE_NVTX
+    //                 nvtxRangePush((container.getName()+Neon::DataViewUtil::toString(scheduling.getDataView())).c_str());
+    // #endif
+    //                 container.run(threadRank, stream, scheduling.getDataView());
+    // #ifdef NEON_USE_NVTX
+    //                 nvtxRangePop();
+    // #endif
+    //                 if (signalEvents >= 0) {
+    //                     mBackend.pushEventOnStream(threadRank, signalEvents, stream);
+    //                 }
+    //             });
+    //         }
+    //     }
+    // #ifdef NEON_USE_NVTX
+    //     nvtxRangePop();
+    // #endif
 }
 
 auto Graph::runtimePreSet(int anchorStream) -> void
@@ -811,7 +1074,13 @@ auto Graph::runtimePreSet(int anchorStream) -> void
     helpComputeScheduling(false, anchorStream);
     mAnchorStreamPreSet = anchorStream;
     mFilterOutAnchorsPreSet = false;
+    for (int i = 0; i < mBfs.getNumberOfLevels(); i++) {
+        mBfs.forEachNodeAtLevel(i, *this, [&](Neon::set::container::GraphNode& graphNode) {
+            graphNode.getContainer().getContainerInterface().configureWithScheduling(graphNode);
+        });
+    }
 }
+
 auto Graph::expandSubGraphs() -> void
 {
     bool atLeastOneWasFound = false;
@@ -836,7 +1105,7 @@ auto Graph::expandSubGraphs() -> void
         if (!validTarget) {
             if (atLeastOneWasFound) {
                 helpInvalidateScheduling();
-                this->helpRemoveRedundantDependencies();
+                this->removeRedundantDependencies();
                 // this->ioToDot(std::to_string(i) + "_t_05", "kllkj", true);
             }
             return;
@@ -892,8 +1161,9 @@ auto Graph::expandSubGraphs() -> void
         // this->ioToDot(std::to_string(i) + "_t_04", "kllkj", true);
     }
 }
-auto Graph::helpCheckBackendStatus()
-    -> void
+auto Graph::
+    helpCheckBackendStatus()
+        -> void
 {
     if (!mBackendIsSet) {
         NeonException exception("Container Graph");
@@ -901,11 +1171,141 @@ auto Graph::helpCheckBackendStatus()
         NEON_THROW(exception);
     }
 }
-auto Graph::getNumberOfNodes() -> int
+
+auto Graph::
+    getNumberOfNodes()
+        -> int
 {
     // We remove 2 because of the head and tail holders.
     return int(mRawGraph.numVertices() - 2);
 }
 
+auto Graph::
+    forEachDependency(const std::function<void(const GraphDependency&)>& fun)
+        const -> void
+{
+    mRawGraph.forEachEdge([&](const auto& edge) {
+        const auto& dep = this->mRawGraph.getEdgeProperty(edge);
+        fun(dep);
+    });
+}
+
+auto Graph::
+    forEachNode(const std::function<void(const GraphNode&)>& fun)
+        const -> void
+{
+    mRawGraph.forEachVertex([&](size_t nodeId) {
+        auto node = this->mRawGraph.getVertexProperty(nodeId);
+        fun(node);
+    });
+}
+
+auto Graph::
+    expandAndMerge(const GraphNode& A,
+                   const Container& container,
+                   const GraphNode& B,
+                   bool             propagateSchedulingHints)
+        -> int
+{
+    if (container.getContainerExecutionType() != ContainerExecutionType::graph) {
+        NEON_THROW_UNSUPPORTED_OPERATION("Container should be of type Graph");
+    }
+
+    Graph toMergeGraph = container.getContainerInterface().getGraph();
+    toMergeGraph.expandSubGraphs();
+    int numNodes = toMergeGraph.getNumberOfNodes();
+
+    auto schedulingDepOfB = getProceedingGraphNodes(B, {GraphDependencyType::scheduling});
+
+    std::unordered_map<size_t, size_t> fromInputToLocal;
+
+    auto isInternalNode = [&](const GraphNode& inputNode) {
+        auto inputUid = inputNode.getGraphData().getUid();
+        if (GraphData::beginUid != inputUid &&
+            GraphData::endUid != inputUid) {
+            return true;
+        }
+        return false;
+    };
+
+    auto isInternalDependency = [&](const GraphDependency& inputDependency) {
+        const auto& source = inputDependency.getSourceNode(toMergeGraph);
+        const auto& dest = inputDependency.getDestinationNode(toMergeGraph);
+
+        if (isInternalNode(source) &&
+            isInternalNode(dest)) {
+            return true;
+        }
+        return false;
+    };
+
+    // adding nodes to the graph
+    toMergeGraph.forEachNode([&](const GraphNode& inputNode) {
+        // discarding begin and end nodes
+        if (isInternalNode(inputNode)) {
+            auto& container = inputNode.getContainer();
+            auto& newGraphNode = this->addNode(container);
+
+            fromInputToLocal[inputNode.getGraphData().getUid()] =
+                newGraphNode.getGraphData().getUid();
+        }
+    });
+
+    // adding dependency to the graph
+    toMergeGraph.forEachDependency([&](const GraphDependency& inputDependency) {
+        // discarding begin and end nodes
+        if (isInternalDependency(inputDependency)) {
+            const auto& sourceInput = inputDependency.getSourceNode(toMergeGraph);
+            const auto& destInput = inputDependency.getDestinationNode(toMergeGraph);
+
+            size_t sourceUid = fromInputToLocal[sourceInput.getGraphData().getUid()];
+            size_t destUid = fromInputToLocal[destInput.getGraphData().getUid()];
+
+            const GraphNode& source = this->helpGetGraphNode(sourceUid);
+            const GraphNode& dest = this->helpGetGraphNode(destUid);
+
+            this->addDependency(source, dest, inputDependency.getType());
+        }
+    });
+
+
+    {  // Connecting node A with all the children of the input graph begin node
+        // And propagating the scheduling dependencies of B too
+        const auto&             inputBeginNode = toMergeGraph.getBeginNode();
+        std::vector<GraphNode*> subsequentGraphNodes = toMergeGraph.getSubsequentGraphNodes(inputBeginNode);
+
+        for (auto inputGraphNodePtr : subsequentGraphNodes) {
+            const auto&  source = A;
+            const size_t destUid = fromInputToLocal[inputGraphNodePtr->getGraphData().getUid()];
+            auto         dest = this->helpGetGraphNode(destUid);
+            const auto&  inputDependency = toMergeGraph.getDependency(inputBeginNode, *inputGraphNodePtr);
+            this->addDependency(source, dest, inputDependency.getType());
+
+            if (propagateSchedulingHints) {
+                for (auto& schedulingAnteNode : schedulingDepOfB) {
+                    this->addDependency(*schedulingAnteNode, dest, GraphDependencyType::scheduling);
+                }
+            }
+        }
+    }
+
+
+    {  // Connecting node B with all the parents of the input graph end node
+        const auto&             inputEndNode = toMergeGraph.getEndNode();
+        std::vector<GraphNode*> proceedingGraphNodes = toMergeGraph.getProceedingGraphNodes(inputEndNode);
+        for (auto inputGraphNodePtr : proceedingGraphNodes) {
+            const size_t sourceUid = fromInputToLocal[inputGraphNodePtr->getGraphData().getUid()];
+
+            const auto& source = this->helpGetGraphNode(sourceUid);
+            const auto& dest = B;
+
+            const auto& inputDependency = toMergeGraph.getDependency(*inputGraphNodePtr, inputEndNode);
+            this->addDependency(source, dest, inputDependency.getType());
+        }
+    }
+
+    return numNodes;
+}
+
 
 }  // namespace Neon::set::container
diff --git a/libNeonSet/src/set/container/GraphContainer.cpp b/libNeonSet/src/set/container/GraphContainer.cpp
index e266ccb3..4127295b 100644
--- a/libNeonSet/src/set/container/GraphContainer.cpp
+++ b/libNeonSet/src/set/container/GraphContainer.cpp
@@ -3,9 +3,10 @@
 
 namespace Neon::set::internal {
 
-GraphContainer::GraphContainer(const std::string&                         name,
-                               const Neon::set::container::Graph&         containerGraph,
-                               std::function<void(Neon::SetIdx, Loader&)> loadingLambda)
+GraphContainer::
+    GraphContainer(const std::string&                         name,
+                   const Neon::set::container::Graph&         containerGraph,
+                   std::function<void(Neon::SetIdx, Loader&)> loadingLambda)
     : mLoadingLambda(loadingLambda)
 {
     mGraph = std::make_shared<Neon::set::container::Graph>(containerGraph);
@@ -17,7 +18,9 @@ GraphContainer::GraphContainer(const std::string&                         name,
     this->parse();
 }
 
-auto GraphContainer::newParser() -> Loader
+auto GraphContainer::
+    newParser()
+        -> Loader
 {
     auto parser = Loader(*this,
                          Neon::DeviceType::CPU,
@@ -27,7 +30,9 @@ auto GraphContainer::newParser() -> Loader
     return parser;
 }
 
-auto GraphContainer::parse() -> const std::vector<Neon::set::internal::dependencyTools::DataToken>&
+auto GraphContainer::
+    parse()
+        -> const std::vector<Neon::set::dataDependency::Token>&
 {
     Neon::SetIdx setIdx(0);
     if (!this->isParsingDataUpdated()) {
@@ -40,35 +45,29 @@ auto GraphContainer::parse() -> const std::vector<Neon::set::internal::dependenc
     return getTokens();
 }
 
-auto GraphContainer::getGraph() -> const Neon::set::container::Graph&
+auto GraphContainer::
+    getGraph()
+        const -> const Neon::set::container::Graph&
 {
     return *mGraph;
 }
 
-auto GraphContainer::getHostContainer() -> std::shared_ptr<internal::ContainerAPI>
-{
-    NEON_THROW_UNSUPPORTED_OPTION("A managed Container Container is not associated with any host operation.");
-}
-
-auto GraphContainer::getDeviceContainer() -> std::shared_ptr<internal::ContainerAPI>
-{
-    NEON_THROW_UNSUPPORTED_OPTION("A managed Container Container is not associated with any host operation.");
-}
-
 /**
  * Run container over streams
  * @param streamIdx
  * @param dataView
  */
-auto GraphContainer::run(int            streamIdx,
-                         Neon::DataView dataView) -> void
+auto GraphContainer::
+    run(int            streamIdx,
+        Neon::DataView dataView) -> void
 {
     mGraph->run(streamIdx, dataView);
 }
 
-auto GraphContainer::run(Neon::SetIdx   setIdx,
-                         int            streamIdx,
-                         Neon::DataView dataView) -> void
+auto GraphContainer::
+    run(Neon::SetIdx   setIdx,
+        int            streamIdx,
+        Neon::DataView dataView) -> void
 {
     mGraph->run(setIdx, streamIdx, dataView);
 }
diff --git a/libNeonSet/src/set/container/Loader.cpp b/libNeonSet/src/set/container/Loader.cpp
new file mode 100644
index 00000000..5c9ec560
--- /dev/null
+++ b/libNeonSet/src/set/container/Loader.cpp
@@ -0,0 +1,13 @@
+#include "type_traits"
+
+#include "Neon/set/Containter.h"
+
+namespace Neon::set {
+
+auto Loader::
+    computeMode() -> bool
+{
+    return m_loadingMode == Neon::set::internal::LoadingMode_e::EXTRACT_LAMBDA;
+}
+
+}  // namespace Neon::set
\ No newline at end of file
diff --git a/libNeonSet/src/set/container/graph/Bfs.cpp b/libNeonSet/src/set/container/graph/Bfs.cpp
index 12a64697..d789e16c 100644
--- a/libNeonSet/src/set/container/graph/Bfs.cpp
+++ b/libNeonSet/src/set/container/graph/Bfs.cpp
@@ -1,4 +1,5 @@
 #include "Neon/set/container/graph/Bfs.h"
+#include <sstream>
 
 namespace Neon::set::container {
 
@@ -8,9 +9,6 @@ auto Bfs::getNumberOfLevels() -> int
     return int(data.size());
 }
 
-/**
- * Returns a reference to a level and it's level index
- */
 auto Bfs::getNewLevel() -> std::pair<std::vector<GraphData::Uid>&, int>
 {
     data.push_back(std::vector<GraphData::Uid>());
@@ -18,26 +16,17 @@ auto Bfs::getNewLevel() -> std::pair<std::vector<GraphData::Uid>&, int>
     return {data[idx], idx};
 }
 
-/**
- * Returns a reference to a specific level
- */
 auto Bfs::getLevel(int levelId) const
     -> const std::vector<GraphData::Uid>&
 {
     return data[levelId];
 }
 
-/**
- * Returns a reference to a specific level
- */
 auto Bfs::getLevel(int levelId) -> std::vector<GraphData::Uid>&
 {
     return data[levelId];
 }
 
-/**
- * Returns max level width
- */
 auto Bfs::getMaxLevelWidth() const -> int
 {
     int maxWidth = 0;
@@ -47,9 +36,6 @@ auto Bfs::getMaxLevelWidth() const -> int
     return maxWidth;
 }
 
-/**
- * Returns max level width
- */
 auto Bfs::getLevelWidth(int levelIdx) const
     -> int
 {
@@ -61,4 +47,20 @@ auto Bfs::clear() -> void
     data.clear();
 }
 
+auto Bfs::toString() -> std::string
+{
+    std::stringstream s;
+    s << "Num levels "<<data.size();
+    int i=0;
+    for(const auto& level : data){
+        s <<"\t\tLevel "<<i<<" (";
+        for(const auto& uid : level){
+            s << uid << " ";
+        }
+        s<<")"<<std::endl;
+        i++;
+    }
+    return s.str();
+}
+
 }  // namespace Neon::set::container
diff --git a/libNeonSet/src/set/container/graph/GraphDependency.cpp b/libNeonSet/src/set/container/graph/GraphDependency.cpp
index 5bfcc022..29f76e4a 100644
--- a/libNeonSet/src/set/container/graph/GraphDependency.cpp
+++ b/libNeonSet/src/set/container/graph/GraphDependency.cpp
@@ -1,28 +1,102 @@
 #include "Neon/set/container/graph/GraphDependency.h"
+#include "Neon/set/container/Graph.h"
+
 #include <string>
+
 namespace Neon::set::container {
 
-GraphDependency::GraphDependency()
+GraphDependency::
+    GraphDependency()
 {
 }
 
-auto GraphDependency::setType(GraphDependencyType type) -> void
+auto GraphDependency::
+    setType(GraphDependencyType   type,
+            const RawGraph::Edge& edge)
+        -> void
 {
     mType = type;
+    mEdge = edge;
 }
 
-auto GraphDependency::getType() const -> GraphDependencyType
+auto GraphDependency::
+    getType()
+        const -> GraphDependencyType
 {
     return mType;
 }
-GraphDependency::GraphDependency(GraphDependencyType type)
+GraphDependency::
+    GraphDependency(GraphDependencyType   type,
+                    const RawGraph::Edge& edge)
+{
+    setType(type, edge);
+}
+
+GraphDependency::
+    GraphDependency(const dataDependency::Token& token,
+                    const RawGraph::Edge&        edge)
+{
+    setType(GraphDependencyType::data, edge);
+    mTokens.push_back(token);
+}
+
+GraphDependency::
+    GraphDependency(const std::vector<Neon::set::dataDependency::Token>& tokens,
+                    const RawGraph::Edge&                                edge)
 {
-    setType(type);
+    setType(GraphDependencyType::data, edge);
+    mTokens = tokens;
 }
 
-auto GraphDependency::getLabel() -> std::string
+auto GraphDependency::
+    getLabel()
+        const -> std::string
 {
     return GraphDependencyTypeUtil::toString(getType());
 }
 
+auto GraphDependency::
+    addToken(const Token& token)
+        -> void
+{
+    mTokens.push_back(token);
+}
+
+
+auto GraphDependency::getTokens()
+    const -> const Tokens&
+{
+    return mTokens;
+}
+
+auto GraphDependency::hasStencilDependency()
+    const -> bool
+{
+    bool isStencil = std::any_of(mTokens.begin(),
+                                 mTokens.end(),
+                                 [](const auto& token) {
+                                     return token.compute() == Neon::Compute::STENCIL;
+                                 });
+    return isStencil;
+}
+
+auto GraphDependency::getRawEdge()
+    const -> RawGraph::Edge
+{
+    return mEdge;
+}
+
+auto GraphDependency::getSourceNode(const Graph& graph)
+    const -> const GraphNode&
+{
+    return graph.helpGetGraphNode(mEdge.first);
+}
+
+auto GraphDependency::getDestinationNode(const Graph& graph)
+    const -> const GraphNode&
+{
+    return graph.helpGetGraphNode(mEdge.second);
+}
+
+
 }  // namespace Neon::set::container
diff --git a/libNeonSet/src/set/container/graph/GraphNode.cpp b/libNeonSet/src/set/container/graph/GraphNode.cpp
index 220b426d..7af3a45b 100644
--- a/libNeonSet/src/set/container/graph/GraphNode.cpp
+++ b/libNeonSet/src/set/container/graph/GraphNode.cpp
@@ -1,72 +1,89 @@
 #include "Neon/set/container/graph/GraphNode.h"
-#include "Neon/set/container/AnchorContainer.h"
-#include "Neon/set/container/ContainerExecutionType.h"
+#include "Neon/set/container/types/ContainerExecutionType.h"
+#include "Neon/set/Containter.h"
 
 namespace Neon::set::container {
 
 GraphNode::GraphNode()
 {
+    mContainerPrt = std::make_shared<Container>();
 }
 
-auto GraphNode::newBeginNode() -> GraphNode
+auto GraphNode::
+    newBeginNode() -> GraphNode
 {
     GraphNode node;
     node.mGraphNodeOrganization.setUid(GraphData::beginUid);
-    node.mContainer = Neon::set::Container::factoryAnchor("Begin");
+    node.mContainerPrt = std::make_shared<Container>(Neon::set::Container::factoryAnchor("Begin"));
     return node;
 }
 
-auto GraphNode::newEndNode() -> GraphNode
+auto GraphNode::
+    newEndNode() -> GraphNode
 {
     GraphNode node;
     node.mGraphNodeOrganization.setUid(GraphData::endUid);
-    node.mContainer = Neon::set::Container::factoryAnchor("End");
+    node.mContainerPrt = std::make_shared<Container>(Neon::set::Container::factoryAnchor("End"));
     return node;
 }
 
-auto GraphNode::getGraphData() -> GraphData&
+auto GraphNode::
+    getGraphData() -> GraphData&
 {
     return mGraphNodeOrganization;
 }
 
-auto GraphNode::getGraphData() const -> const GraphData&
+auto GraphNode::
+    getGraphData()
+        const -> const GraphData&
 {
     return mGraphNodeOrganization;
 }
 
-auto GraphNode::getScheduling() -> GraphNodeScheduling&
+auto GraphNode::
+    getScheduling() -> GraphNodeScheduling&
 {
     return mGraphNodeScheduling;
 }
 
-auto GraphNode::getScheduling() const -> const GraphNodeScheduling&
+auto GraphNode::
+    getScheduling()
+        const -> const GraphNodeScheduling&
 {
     return mGraphNodeScheduling;
 }
 
-auto GraphNode::getContainer() -> Container&
+auto GraphNode::
+    getContainer() -> Container&
 {
-    return mContainer;
+    return *mContainerPrt;
 }
 
-auto GraphNode::getContainer() const -> const Container&
+auto GraphNode::
+    getContainer() const -> const Container&
 {
-    return mContainer;
+    return *mContainerPrt;
 }
 
-GraphNode::GraphNode(const Container& container, GraphData::Uid uid)
+GraphNode::
+    GraphNode(const Container& container,
+              GraphData::Uid uid)
 {
-    mContainer = container;
+    mContainerPrt = std::make_shared<Neon::set::Container>(container);
     mGraphNodeOrganization.setUid(uid);
 }
 
-auto GraphNode::toString() -> std::string
+auto GraphNode::
+    toString()
+        const -> std::string
 {
     return std::string();
 }
 
 
-auto GraphNode::helpGetDotProperties() -> std::string
+auto GraphNode::
+    helpGetDotProperties()
+        const -> std::string
 {
     if (getContainerOperationType() == Neon::set::ContainerOperationType::anchor) {
         return R"(shape=octagon, style="rounded,filled", fillcolor="#fb8072", color="#b11605")";
@@ -74,22 +91,25 @@ auto GraphNode::helpGetDotProperties() -> std::string
     if (getContainerOperationType() == Neon::set::ContainerOperationType::compute) {
         return R"(shape=octagon, style="rounded,filled", fillcolor="#fb8072", color="#b11605")";
     }
-    if (getContainerOperationType() == Neon::set::ContainerOperationType::halo) {
+    if (getContainerOperationType() == Neon::set::ContainerOperationType::communication) {
         return R"(shape=octagon, style="rounded,filled", fillcolor="#fb8072", color="#b11605")";
     }
-    if (getContainerOperationType() == Neon::set::ContainerOperationType::sync) {
+    if (getContainerOperationType() == Neon::set::ContainerOperationType::synchronization) {
         return R"(shape=octagon, style="rounded,filled", fillcolor="#fb8072", color="#b11605")";
     }
     NEON_DEV_UNDER_CONSTRUCTION("");
 }
-auto GraphNode::helpGetDotName() -> std::string
+auto GraphNode::
+    helpGetDotName()
+        const -> std::string
 {
     return getContainer().getName();
 }
-auto GraphNode::helpGetDotInfo() -> std::string
+auto GraphNode::helpGetDotInfo()
+    const -> std::string
 {
     if (getContainerOperationType() == Neon::set::ContainerOperationType::anchor) {
-        return std::string();
+        return {};
     }
     if (getContainerOperationType() == Neon::set::ContainerOperationType::compute) {
         std::stringstream s;
@@ -97,62 +117,73 @@ auto GraphNode::helpGetDotInfo() -> std::string
         s << "DataView = " << Neon::DataViewUtil::toString(getScheduling().getDataView());
         return s.str();
     }
-    if (getContainerOperationType() == Neon::set::ContainerOperationType::halo) {
+    if (getContainerOperationType() == Neon::set::ContainerOperationType::communication) {
         return R"(shape=octagon, style="rounded,filled", fillcolor="#fb8072", color="#b11605")";
     }
-    if (getContainerOperationType() == Neon::set::ContainerOperationType::sync) {
+    if (getContainerOperationType() == Neon::set::ContainerOperationType::synchronization) {
         return R"(shape=octagon, style="rounded,filled", fillcolor="#fb8072", color="#b11605")";
     }
     NEON_DEV_UNDER_CONSTRUCTION("");
 }
 
-auto GraphNode::getContainerOperationType() const -> Neon::set::ContainerOperationType
+auto GraphNode::
+    getContainerOperationType() const -> Neon::set::ContainerOperationType
 {
     return getContainer().getContainerInterface().getContainerOperationType();
 }
 
-auto GraphNode::getContainerpatternType() const -> Neon::set::ContainerPatternType
+auto GraphNode::
+    getContainerpatternType() const -> Neon::set::ContainerPatternType
 {
     return getContainer().getContainerInterface().getContainerPatternType();
 }
 
-auto GraphNode::getLabel(bool debug) -> std::string
+auto GraphNode::
+    getLabel(bool debug)
+        const -> std::string
 {
     auto containerOperationType = getContainerOperationType();
 
-    auto printNodeInformation = [this]() {
-        std::stringstream s;
-
-        auto printPositiveOrNone = [](int val) {
-            if (val >= 0) {
-                return std::to_string(val);
-            }
+    auto printPositiveOrNone = [](int val) {
+        if (val >= 0) {
+            return std::to_string(val);
+        }
+        return std::string("None");
+    };
+    auto printNonEmptyListOrNone = [](const std::vector<int>& ids) {
+        if (ids.size() == 0) {
             return std::string("None");
-        };
-        auto printNonEptyListOrNone = [](const std::vector<int>& ids) {
-            if (ids.size() == 0) {
-                return std::string("None");
-            }
-            std::stringstream tmp;
-            for (size_t i = 0; i < ids.size(); i++) {
-                if (i != 0) {
-                    tmp << " ";
-                }
-                tmp << ids[i];
+        }
+        std::stringstream tmp;
+        for (size_t i = 0; i < ids.size(); i++) {
+            if (i != 0) {
+                tmp << " ";
             }
-            return tmp.str();
-        };
-
-        s << "\\l - UID: " << getContainer().getUid();
-        s << "\\l - Execution: " << getContainer().getContainerExecutionType();
-        s << "\\lGraphData ";
-        s << "\\l - Graph Node id: " << this->getGraphData().getUid();
+            tmp << ids[i];
+        }
+        return tmp.str();
+    };
 
-        s << "\\lScheduling " << getContainer().getName();
+    auto addSchedulingInfo=[this, printNonEmptyListOrNone, printPositiveOrNone](std::stringstream&s ){
+        s << "\\lScheduling ";
         s << "\\l - DataView: " << getScheduling().getDataView();
         s << "\\l - Stream  : " << getScheduling().getStream();
-        s << "\\l - Wait    : " << printNonEptyListOrNone(getScheduling().getDependentEvents());
+        s << "\\l - Wait    : " << printNonEmptyListOrNone(getScheduling().getDependentEvents());
         s << "\\l - Signal  : " << printPositiveOrNone(getScheduling().getEvent());
+        s << "\\l - Exec Ord: " << printPositiveOrNone(getScheduling().getExecutionOrder());
+
+    };
+
+    auto printNodeInformation = [this, addSchedulingInfo]() {
+        std::stringstream s;
+
+        s << "\\l - UID: " << getContainer().getUid();
+        s << "\\l - Execution: " << getContainer().getContainerExecutionType();
+        s << "\\lGraph ";
+        s << "\\l - Node id: " << this->getGraphData().getUid();
+
+        addSchedulingInfo(s);
+
         s << "\\l ---- ";
 
         return s.str();
@@ -175,7 +206,7 @@ auto GraphNode::getLabel(bool debug) -> std::string
             return s.str();
         }
         std::stringstream s;
-        s << "Sporious Anchor ";
+        s << "Spurious Anchor ";
         if (debug) {
             s << printNodeInformation();
         }
@@ -185,33 +216,37 @@ auto GraphNode::getLabel(bool debug) -> std::string
     if (containerOperationType == Neon::set::ContainerOperationType::compute) {
         std::stringstream s;
         if (debug) {
-            s << "Container " << getContainer().getName();
+            s << getContainer().getName();
             s << printNodeInformation();
         } else {
             s << getContainer().getName();
         }
         return s.str();
     }
-    if (containerOperationType == Neon::set::ContainerOperationType::halo) {
+    if (containerOperationType == Neon::set::ContainerOperationType::communication) {
         std::stringstream s;
-        s << "Halo Update "
-             " - Name: "
-          << getContainer().getName();
-        s << " - UID: " << getContainer().getUid();
+        if (debug) {
+            s << getContainer().getName();
+            s << printNodeInformation();
+        } else {
+            s << getContainer().getName();
+        }
         return s.str();
     }
-    if (containerOperationType == Neon::set::ContainerOperationType::sync) {
+    if (containerOperationType == Neon::set::ContainerOperationType::synchronization) {
         std::stringstream s;
-        s << "Sync "
-             " - Name: "
-          << getContainer().getName();
-        s << " - UID: " << getContainer().getUid();
+        if (debug) {
+            s << getContainer().getName();
+            s << printNodeInformation();
+        } else {
+            s << getContainer().getName();
+        }
         return s.str();
     }
     if (containerOperationType == Neon::set::ContainerOperationType::graph) {
         std::stringstream s;
         if (debug) {
-            s << "Graph " << getContainer().getName();
+            s << getContainer().getName();
             s << printNodeInformation();
         } else {
             s << getContainer().getName();
@@ -223,7 +258,9 @@ auto GraphNode::getLabel(bool debug) -> std::string
 }
 
 
-auto GraphNode::getLabelProperty() -> std::string
+auto GraphNode::
+    getLabelProperty()
+        const -> std::string
 {
     auto containerOperationType = getContainerOperationType();
     if (containerOperationType == Neon::set::ContainerOperationType::anchor) {
@@ -233,7 +270,7 @@ auto GraphNode::getLabelProperty() -> std::string
         if (this->getGraphData().endUid == getGraphData().getUid()) {
             return R"(shape=doublecircle, style=filled, fillcolor="#d9d9d9", color="#6c6c6c")";
         }
-        //NEON_THROW_UNSUPPORTED_OPERATION("");
+        // NEON_THROW_UNSUPPORTED_OPERATION("");
         return R"(shape=doublecircle, style=filled, fillcolor="#d9d9d9", color="#6c6c6c")";
     }
     if (containerOperationType == Neon::set::ContainerOperationType::compute) {
@@ -253,11 +290,11 @@ auto GraphNode::getLabelProperty() -> std::string
         NEON_THROW_UNSUPPORTED_OPERATION("");
     }
 
-    if (containerOperationType == Neon::set::ContainerOperationType::halo) {
+    if (containerOperationType == Neon::set::ContainerOperationType::communication) {
         return R"(shape=octagon, style="rounded,filled", fillcolor="#fb8072", color="#b11605")";
     }
 
-    if (containerOperationType == Neon::set::ContainerOperationType::sync) {
+    if (containerOperationType == Neon::set::ContainerOperationType::synchronization) {
         return R"(shape=octagon, style="rounded,filled", fillcolor="#fb8072", color="#b11605")";
     }
     if (containerOperationType == Neon::set::ContainerOperationType::graph) {
diff --git a/libNeonSet/src/set/container/graph/GraphNodeScheduling.cpp b/libNeonSet/src/set/container/graph/GraphNodeScheduling.cpp
index d0fb662f..bed3d61d 100644
--- a/libNeonSet/src/set/container/graph/GraphNodeScheduling.cpp
+++ b/libNeonSet/src/set/container/graph/GraphNodeScheduling.cpp
@@ -25,6 +25,12 @@ auto GraphNodeScheduling::getDependentEvents()
     return mDependentEvents;
 }
 
+auto GraphNodeScheduling::getDependentEvents()
+    const -> const std::vector<int>&
+{
+    return mDependentEvents;
+}
+
 auto GraphNodeScheduling::setStream(int stream)
     -> void
 {
@@ -51,8 +57,21 @@ auto GraphNodeScheduling::reset() -> void
 {
     mStream = -1;
     mEvent = -1;
-    mDataView = DataView::STANDARD;
+    mExecutionOrder = -1;
     mDependentEvents.clear();
 }
 
+auto GraphNodeScheduling::getExecutionOrder()
+    const -> int
+{
+    return mExecutionOrder;
+}
+
+auto GraphNodeScheduling::setExecutionOerder(int order)
+    -> void
+{
+    mExecutionOrder = order;
+}
+
+
 }  // namespace Neon::set::container
diff --git a/libNeonSet/src/set/container/ContainerExecutionType.cpp b/libNeonSet/src/set/container/types/ContainerExecutionType.cpp
similarity index 88%
rename from libNeonSet/src/set/container/ContainerExecutionType.cpp
rename to libNeonSet/src/set/container/types/ContainerExecutionType.cpp
index 60e701b1..93f6f0bf 100644
--- a/libNeonSet/src/set/container/ContainerExecutionType.cpp
+++ b/libNeonSet/src/set/container/types/ContainerExecutionType.cpp
@@ -1,4 +1,4 @@
-#include "Neon/set/container/ContainerExecutionType.h"
+#include "Neon/set/container/types/ContainerExecutionType.h"
 
 /**
  * Abstract interface to hide
@@ -24,6 +24,9 @@ auto ContainerExecutionTypeUtils::toString(ContainerExecutionType option) -> std
         case ContainerExecutionType::graph: {
             return "graph";
         }
+        case ContainerExecutionType::communication: {
+            return "communication";
+        }
         case ContainerExecutionType::none: {
             return "none";
         }
@@ -50,7 +53,8 @@ auto ContainerExecutionTypeUtils::getOptions() -> std::array<ContainerExecutionT
                                                          ContainerExecutionType::deviceManaged,
                                                          ContainerExecutionType::deviceThenHostManaged,
                                                          ContainerExecutionType::hostManaged,
-                                                         ContainerExecutionType::graph};
+                                                         ContainerExecutionType::graph,
+                                                         ContainerExecutionType::communication};
     return opts;
 }
 
diff --git a/libNeonSet/src/set/container/ContainerOperationType.cpp b/libNeonSet/src/set/container/types/ContainerOperationType.cpp
similarity index 82%
rename from libNeonSet/src/set/container/ContainerOperationType.cpp
rename to libNeonSet/src/set/container/types/ContainerOperationType.cpp
index 2f9d00ed..6afce6c4 100644
--- a/libNeonSet/src/set/container/ContainerOperationType.cpp
+++ b/libNeonSet/src/set/container/types/ContainerOperationType.cpp
@@ -1,4 +1,4 @@
-#include "Neon/set/container/ContainerOperationType.h"
+#include "Neon/set/container/types/ContainerOperationType.h"
 
 /**
  * Abstract interface to hide
@@ -15,11 +15,11 @@ auto ContainerOperationTypeUtils::toString(ContainerOperationType option) -> std
         case ContainerOperationType::graph: {
             return "graph";
         }
-        case ContainerOperationType::halo: {
-            return "halo";
+        case ContainerOperationType::communication: {
+            return "communication";
         }
-        case ContainerOperationType::sync: {
-            return "sync";
+        case ContainerOperationType::synchronization: {
+            return "synchronization";
         }
         case ContainerOperationType::anchor: {
             return "anchor";
@@ -45,8 +45,8 @@ auto ContainerOperationTypeUtils::getOptions() -> std::array<ContainerOperationT
 {
     std::array<ContainerOperationType, nOptions> opts = {ContainerOperationType::compute,
                                                          ContainerOperationType::graph,
-                                                         ContainerOperationType::halo,
-                                                         ContainerOperationType::sync,
+                                                         ContainerOperationType::communication,
+                                                         ContainerOperationType::synchronization,
                                                          ContainerOperationType::anchor};
     return opts;
 }
diff --git a/libNeonSet/src/set/container/ContainerPatternType.cpp b/libNeonSet/src/set/container/types/ContainerPatternType.cpp
similarity index 96%
rename from libNeonSet/src/set/container/ContainerPatternType.cpp
rename to libNeonSet/src/set/container/types/ContainerPatternType.cpp
index 5c67aedc..b505a331 100644
--- a/libNeonSet/src/set/container/ContainerPatternType.cpp
+++ b/libNeonSet/src/set/container/types/ContainerPatternType.cpp
@@ -1,4 +1,4 @@
-#include "Neon/set/container/ContainerPatternType.h"
+#include "Neon/set/container/types/ContainerPatternType.h"
 
 /**
  * Abstract interface to hide
diff --git a/libNeonSet/src/set/container/types/SynchronizationContainerType.cpp b/libNeonSet/src/set/container/types/SynchronizationContainerType.cpp
new file mode 100644
index 00000000..89610996
--- /dev/null
+++ b/libNeonSet/src/set/container/types/SynchronizationContainerType.cpp
@@ -0,0 +1,46 @@
+#include "Neon/set/container/types/SynchronizationContainerType.h"
+
+/**
+ * Abstract interface to hide
+ */
+
+namespace Neon::set {
+
+auto SynchronizationContainerTypeUtils::toString(SynchronizationContainerType option) -> std::string
+{
+    switch (option) {
+        case SynchronizationContainerType::hostOmpBarrier: {
+            return "hostOmpBarrier";
+        }
+        case SynchronizationContainerType::none: {
+            return "none";
+        }
+    }
+    NEON_THROW_UNSUPPORTED_OPTION("");
+}
+
+auto SynchronizationContainerTypeUtils::fromString(const std::string& option)
+    -> SynchronizationContainerType
+{
+    auto const options = getOptions();
+
+    for (auto a : options) {
+        if (toString(a) == option) {
+            return a;
+        }
+    }
+    NEON_THROW_UNSUPPORTED_OPTION("");
+}
+
+auto SynchronizationContainerTypeUtils::getOptions() -> std::array<SynchronizationContainerType, nOptions>
+{
+    std::array<SynchronizationContainerType, nOptions> opts = {SynchronizationContainerType::hostOmpBarrier};
+    return opts;
+}
+
+std::ostream& operator<<(std::ostream& os, Neon::set::SynchronizationContainerType const& m)
+{
+    return os << Neon::set::SynchronizationContainerTypeUtils::toString(m);
+}
+
+}  // namespace Neon::set
diff --git a/libNeonSet/src/set/depencencyTools/AccessType.cpp b/libNeonSet/src/set/depencencyTools/AccessType.cpp
new file mode 100644
index 00000000..59365819
--- /dev/null
+++ b/libNeonSet/src/set/depencencyTools/AccessType.cpp
@@ -0,0 +1,34 @@
+#include "Neon/set/dependency/AccessType.h"
+
+namespace Neon::set::dataDependency {
+
+auto AccessTypeUtils::toString(AccessType val) -> std::string
+{
+    switch (val) {
+        case AccessType::READ: {
+            return "READ";
+        }
+        case AccessType::WRITE: {
+            return "WRITE";
+        }
+        case AccessType::NONE: {
+            return "NONE";
+        }
+    }
+    NEON_THROW_UNSUPPORTED_OPTION();
+}
+
+auto AccessTypeUtils::merge(AccessType valA, AccessType valB) -> AccessType
+{
+    if (valA == AccessType::WRITE)
+        return AccessType::WRITE;
+    if (valB == AccessType::WRITE)
+        return AccessType::WRITE;
+    if (valA == AccessType::READ)
+        return AccessType::READ;
+    if (valB == AccessType::READ)
+        return AccessType::READ;
+    return AccessType::NONE;
+}
+
+}  // namespace Neon::set::internal
\ No newline at end of file
diff --git a/libNeonSet/src/set/depencencyTools/ComputeType.cpp b/libNeonSet/src/set/depencencyTools/ComputeType.cpp
new file mode 100644
index 00000000..c32a7041
--- /dev/null
+++ b/libNeonSet/src/set/depencencyTools/ComputeType.cpp
@@ -0,0 +1,21 @@
+#include "Neon/set/dependency/ComputeType.h"
+
+namespace Neon {
+
+auto ComputeUtils::toString(Compute val) -> std::string
+{
+    switch (val) {
+        case Compute::MAP: {
+            return "MAP";
+        }
+        case Compute::STENCIL: {
+            return "STENCIL";
+        }
+        case Compute::REDUCE: {
+            return "REDUCE";
+        }
+    }
+    NEON_THROW_UNSUPPORTED_OPTION();
+}
+
+}  // namespace Neon
\ No newline at end of file
diff --git a/libNeonSet/src/set/depencencyTools/DataDependencyType.cpp b/libNeonSet/src/set/depencencyTools/DataDependencyType.cpp
new file mode 100644
index 00000000..f5a8035a
--- /dev/null
+++ b/libNeonSet/src/set/depencencyTools/DataDependencyType.cpp
@@ -0,0 +1,32 @@
+#include "Neon/set/dependency/DataDependencyType.h"
+
+namespace Neon::set::dataDependency {
+
+auto DataDependencyTypeUtils::toString(DataDependencyType val) -> std::string
+{
+    switch (val) {
+        case DataDependencyType::RAW: {
+            return "RAW";
+        }
+        case DataDependencyType::WAR: {
+            return "WAR";
+        }
+        case DataDependencyType::RAR: {
+            return "RAR";
+        }
+        case DataDependencyType::WAW: {
+            return "WAW";
+        }
+        case DataDependencyType::NONE: {
+            return "NONE";
+        }
+    }
+    NEON_THROW_UNSUPPORTED_OPTION();
+}
+
+std::ostream& operator<<(std::ostream& os, Neon::set::dataDependency::DataDependencyType const& m){
+   os << DataDependencyTypeUtils::toString(m);
+   return os;
+}
+
+}
\ No newline at end of file
diff --git a/libNeonSet/src/set/depencencyTools/DataParsing.cpp b/libNeonSet/src/set/depencencyTools/DataParsing.cpp
deleted file mode 100644
index 375f72c6..00000000
--- a/libNeonSet/src/set/depencencyTools/DataParsing.cpp
+++ /dev/null
@@ -1,92 +0,0 @@
-#include "Neon/set//dependencyTools/DataParsing.h"
-
-namespace Neon {
-namespace set {
-namespace internal {
-namespace dependencyTools {
-
-
-DataToken::DataToken(DataUId_t uid,
-                     Access_e  access,
-                     Compute   compute)
-{
-    update(uid, access, compute);
-    setHaloUpdate(
-        [&](Neon::set::HuOptions&) -> void {
-            NeonException exp("DataToken_t");
-            exp << "This is not a stencil token and this is not a valid operation";
-            NEON_THROW(exp);
-        },
-        [&](Neon::SetIdx, Neon::set::HuOptions&) -> void {
-            NeonException exp("DataToken_t");
-            exp << "This is not a stencil token and this is not a valid operation";
-            NEON_THROW(exp);
-        });
-}
-
-auto DataToken::update(DataUId_t uid,
-                       Access_e  access,
-                       Compute   compute) -> void
-{
-    m_uid = uid;
-    m_access = access;
-    m_compute = compute;
-    setHaloUpdate(
-        [&](Neon::set::HuOptions&) -> void {
-        NeonException exp("DataToken_t");
-        exp << "This is not a stencil token and this is not a valid operation";
-        NEON_THROW(exp); },
-        [&](Neon::SetIdx, Neon::set::HuOptions&) -> void {
-            NeonException exp("DataToken_t");
-            exp << "This is not a stencil token and this is not a valid operation";
-            NEON_THROW(exp);
-        });
-}
-
-auto DataToken::access() const -> Access_e
-{
-    return m_access;
-}
-
-auto DataToken::compute() const -> Compute
-{
-    return m_compute;
-}
-auto DataToken::uid() const -> DataUId_t
-{
-    return m_uid;
-}
-auto DataToken::toString() const -> std::string
-{
-    return " uid " + std::to_string(m_uid) +
-           " [Op " + Access_et::toString(m_access) +
-           " Model " + Neon::ComputeUtils::toString(m_compute) + "]";
-}
-
-
-auto DataToken::setHaloUpdate(std::function<void(Neon::set::HuOptions& opt)>               hu,
-                              std::function<void(Neon::SetIdx, Neon::set::HuOptions& opt)> huPerDevice) -> void
-{
-    m_hu = hu;
-    m_huPerDevice = huPerDevice;
-}
-
-auto DataToken::getHaloUpdate() const
-    -> const std::function<void(Neon::set::HuOptions& opt)>&
-{
-    return m_hu;
-}
-
-auto DataToken::getHaloUpdatePerDevice() const
-    -> const std::function<void(Neon::SetIdx, Neon::set::HuOptions& opt)>&
-{
-    return m_huPerDevice;
-}
-auto DataToken::mergeAccess(Access_et::e tomerge) -> void
-{
-    m_access = Access_et::merge(m_access, tomerge);
-}
-}  // namespace dependencyTools
-}  // namespace internal
-}  // namespace set
-}  // namespace Neon
\ No newline at end of file
diff --git a/libNeonSet/src/set/depencencyTools/Token.cpp b/libNeonSet/src/set/depencencyTools/Token.cpp
new file mode 100644
index 00000000..8e190de4
--- /dev/null
+++ b/libNeonSet/src/set/depencencyTools/Token.cpp
@@ -0,0 +1,74 @@
+#include <utility>
+
+#include "Neon/set//dependency/Token.h"
+#include "Neon/set/Containter.h"
+
+namespace Neon::set::dataDependency {
+
+Token::Token(MultiXpuDataUid uid,
+             AccessType      access,
+             Compute         compute)
+{
+    update(uid, access, compute);
+}
+
+auto Token::update(MultiXpuDataUid uid,
+                   AccessType      access,
+                   Compute         compute) -> void
+{
+    mUid = uid;
+    mAccess = access;
+    mCompute = compute;
+
+    setDataTransferContainer(
+        [&](Neon::set::TransferMode)
+            -> Neon::set::Container {
+        NeonException exp("Token");
+        exp << "This is not a stencil token and this is not a valid operation";
+        NEON_THROW(exp); });
+}
+
+auto Token::access() const -> AccessType
+{
+    return mAccess;
+}
+
+auto Token::compute() const -> Compute
+{
+    return mCompute;
+}
+
+auto Token::uid() const -> MultiXpuDataUid
+{
+    return mUid;
+}
+
+auto Token::
+    toString() const -> std::string
+{
+    return " uid " + std::to_string(mUid) +
+           " [Op " + AccessTypeUtils::toString(mAccess) +
+           " Model " + Neon::ComputeUtils::toString(mCompute) + "]";
+}
+
+auto Token::
+    setDataTransferContainer(std::function<Neon::set::Container(Neon::set::TransferMode transferMode)> huPerDevice)
+        -> void
+{
+    mHaloUpdateExtractor = std::move(huPerDevice);
+}
+
+auto Token::
+    getDataTransferContainer(Neon::set::TransferMode transferMode)
+        const -> Neon::set::Container
+{
+    return mHaloUpdateExtractor(transferMode);
+}
+
+auto Token::
+    mergeAccess(AccessType tomerge) -> void
+{
+    mAccess = AccessTypeUtils::merge(mAccess, tomerge);
+}
+
+}  // namespace Neon::set::dataDependency
\ No newline at end of file
diff --git a/libNeonSet/src/set/depencencyTools/enum.cpp b/libNeonSet/src/set/depencencyTools/enum.cpp
deleted file mode 100644
index 8085649d..00000000
--- a/libNeonSet/src/set/depencencyTools/enum.cpp
+++ /dev/null
@@ -1,74 +0,0 @@
-#include "Neon/set/dependencyTools/enum.h"
-
-namespace Neon {
-namespace set {
-namespace internal {
-namespace dependencyTools {
-
-
-auto Access_et::toString(e val) -> std::string
-{
-    switch (val) {
-        case READ: {
-            return "READ";
-        }
-        case WRITE: {
-            return "WRITE";
-        }
-        case NONE: {
-            return "NONE";
-        }
-    }
-    NEON_THROW_UNSUPPORTED_OPTION();
-}
-
-auto Access_et::merge(e valA, e valB) -> e {
-    if(valA == e::WRITE) return e::WRITE;
-    if(valB == e::WRITE) return e::WRITE;
-    if(valA == e::READ) return e::READ;
-    if(valB == e::READ) return e::READ;
-    return e::NONE;
-}
-
-auto Dependencies_et::toString(e val) -> std::string
-{
-    switch (val) {
-        case RAW: {
-            return "RAW";
-        }
-        case WAR: {
-            return "WAR";
-        }
-        case RAR: {
-            return "RAR";
-        }
-        case WAW: {
-            return "WAW";
-        }
-        case NONE: {
-            return "NONE";
-        }
-    }
-    NEON_THROW_UNSUPPORTED_OPTION();
-}
-}  // namespace dependencyTools
-}  // namespace internal
-}  // namespace set
-
-auto ComputeUtils::toString(Compute val) -> const char*
-{
-    switch (val) {
-        case Compute::MAP: {
-            return "MAP";
-        }
-        case Compute::STENCIL: {
-            return "STENCIL";
-        }
-        case Compute::REDUCE: {
-            return "REDUCE";
-        }
-    }
-    NEON_THROW_UNSUPPORTED_OPTION();
-}
-
-}  // namespace Neon
\ No newline at end of file
diff --git a/libNeonSkeleton/include/Neon/skeleton/Options.h b/libNeonSkeleton/include/Neon/skeleton/Options.h
index 0dd63d38..f8d0131c 100644
--- a/libNeonSkeleton/include/Neon/skeleton/Options.h
+++ b/libNeonSkeleton/include/Neon/skeleton/Options.h
@@ -13,8 +13,6 @@ struct Options
    public:
     /**
      * Constructor that defines options for the skeleton
-     * @param occ
-     * @param transferMode
      */
     explicit Options(Occ occ, Neon::set::TransferMode transferMode = Neon::set::TransferMode::get);
     explicit Options() = default;
diff --git a/libNeonSkeleton/include/Neon/skeleton/Skeleton.h b/libNeonSkeleton/include/Neon/skeleton/Skeleton.h
index ef24afdc..c09fd82c 100644
--- a/libNeonSkeleton/include/Neon/skeleton/Skeleton.h
+++ b/libNeonSkeleton/include/Neon/skeleton/Skeleton.h
@@ -2,9 +2,11 @@
 #include "Neon/set/Backend.h"
 #include "Neon/set/Containter.h"
 #include "Neon/skeleton/Options.h"
-#include "Neon/skeleton/internal/MultiGpuGraph.h"
-#include "Neon/skeleton/internal/StreamScheduler.h"
-
+#include "Neon/skeleton/internal/MultiXpuGraph.h"
+// #include "Neon/skeleton/internal/StreamScheduler.h"
+#ifdef NEON_USE_NVTX
+#include <nvToolsExt.h>
+#endif
 namespace Neon::skeleton {
 
 struct Skeleton
@@ -38,30 +40,35 @@ struct Skeleton
         }
         mOptions = options;
         mMultiGraph.init(mBackend, operations, name, options);
-        // m_multiGraph.io2Dot("DB_multiGpuGraph", "graphname");
-        mStreamScheduler.init(mBackend, mMultiGraph);
+        mMultiGraph.ioToDot("DB_multiGpuGraph", "graphname");
+        // mStreamScheduler.init(mBackend, mMultiGraph);
         // m_streamScheduler.io2Dot("DB_streamScheduler", "graphname");
     }
 
 
-    void ioToDot(std::string fname, std::string graphname = "")
+    void ioToDot(std::string fname,
+                 std::string graphname = "",
+                 bool        debug = false)
     {
-        // m_multiGraph.io2Dot(fname + ".multiGpu.dot", graphname);
-        mMultiGraph.io2DotOriginalApp(fname + ".appGraph.dot", graphname);
-        mStreamScheduler.io2Dot(fname + ".scheduler.dot", graphname);
-        mStreamScheduler.io2DotOrder(fname + ".order.dot", graphname);
+        mMultiGraph.ioToDot(fname, graphname, debug);
     }
 
     void run()
     {
-        mStreamScheduler.run(mOptions);
+#ifdef NEON_USE_NVTX
+        nvtxRangePush("Skeleton");
+#endif
+        mMultiGraph.execute(mOptions);
+#ifdef NEON_USE_NVTX
+        nvtxRangePop();
+#endif
     }
 
    private:
-    Neon::Backend                             mBackend;
-    Options                                   mOptions;
-    Neon::skeleton::internal::MultiGpuGraph   mMultiGraph;
-    Neon::skeleton::internal::StreamScheduler mStreamScheduler;
+    Neon::Backend                           mBackend;
+    Options                                 mOptions;
+    Neon::skeleton::internal::MultiXpuGraph mMultiGraph;
+    //    Neon::skeleton::internal::StreamScheduler mStreamScheduler;
 
     bool m_inited = {false};
 };
diff --git a/libNeonSkeleton/include/Neon/skeleton/internal/MultiGpuGraph.h b/libNeonSkeleton/include/Neon/skeleton/internal/MultiGpuGraph.h
deleted file mode 100644
index 2ba9ca98..00000000
--- a/libNeonSkeleton/include/Neon/skeleton/internal/MultiGpuGraph.h
+++ /dev/null
@@ -1,328 +0,0 @@
-#pragma once
-#include <list>
-#include "Neon/core/types/digraph.h"
-#include "Neon/set//Containter.h"
-#include "Neon/set/Backend.h"
-#include "Neon/skeleton/internal/dependencyTools/UserDataManager.h"
-#include "Neon/skeleton/internal/multiGpuGraph/Edge.h"
-#include "Neon/skeleton/internal/multiGpuGraph/MetaNode.h"
-#include "Neon/skeleton/Options.h"
-namespace Neon::skeleton::internal {
-/**
- * Graph storing dependency between user kernels 
- */
-struct MultiGpuGraph
-{
-   public:
-    using DiGraph = Neon::DiGraph<MetaNode,
-                                  Edge>;
-
-    using DiGraphScheduling = Neon::DiGraph<Empty,
-                                              Empty>;
-
-   public:
-    /**
-     * Default empty constructor
-     */
-    MultiGpuGraph();
-
-    void init(Neon::Backend&                    bk,
-              const std::vector<Neon::set::Container>& operations,
-              std::string                              name,
-              Options                                  options);
-
-    /**
-     * Function to retrieve the container index in the user container list
-     * @param id
-     * @return
-     */
-    auto getContainer(ContainerIdx id) -> Neon::set::Container&;
-    auto getContainer(ContainerIdx id) const -> const Neon::set::Container&;
-
-    /**
-     * Return a reference to the data dependency graph
-     * @return
-     */
-    auto getDiGraph() -> DiGraph&;
-
-    /**
-     * Return a reference to the scheduling dependency graph
-     * @return
-     */
-    auto getSchedulingDiGraph() -> DiGraphScheduling&;
-
-    /**
-     * Export the graph of the user application
-     * @param fname
-     * @param graphName
-     */
-    auto io2DotOriginalApp(const std::string& fname, const std::string& graphName) -> void;
-
-    /**
-     * Export both the data dependency graph and the scheduling graph
-     * @param fname
-     * @param graphName
-     */
-    auto io2Dot(const std::string& fname, const std::string& graphName) -> void;
-
-    /**
-     * Return the ID for the start node
-     * @return
-     */
-    auto rootNodeId() const -> const size_t&;
-
-    /**
-     * Return the ID for the end node
-     * @return
-     */
-    auto finalNodeId() const -> const size_t&;
-
-    /**
-     * Return the counter used to map all nodes to a 1D indexing
-     * @return
-     */
-    auto getLinearContinuousIndexingCounter() -> size_t;
-
-   private:
-    struct Storage
-    {
-        std::vector<Neon::set::Container>                       m_kContainers;
-        UserDataManager                                         m_dataRecords;
-
-        DiGraph           m_userAppGraph;
-        DiGraph           m_graph;
-        DiGraphScheduling m_schedulingGraph;
-
-        size_t m_rootNodeId;
-        size_t m_finalNodeId;
-        int    m_setCardinality = 0;
-        size_t m_resetLinearContinuousIndexingCounter = 0;
-    };
-    std::shared_ptr<Storage> m_storage;
-
-    /**
-     * Access methods to members
-     * @return
-     */
-    inline auto m_kContainers() -> std::vector<Neon::set::Container>&
-    {
-        return m_storage->m_kContainers;
-    }
-
-    inline auto m_kContainers() const -> const std::vector<Neon::set::Container>&
-    {
-        return m_storage->m_kContainers;
-    }
-
-    /**
-     * Access methods to members
-     * @return
-     */
-    inline auto m_dataRecords() -> UserDataManager&
-    {
-        return m_storage->m_dataRecords;
-    }
-
-    /**
-     * Access methods to members
-     * @return
-     */
-    inline auto m_graph() -> DiGraph&
-    {
-        return m_storage->m_graph;
-    }
-
-    /**
-     * Access methods to members
-     * @return
-     */
-    inline auto m_schedulingGraph() -> DiGraphScheduling&
-    {
-        return m_storage->m_schedulingGraph;
-    }
-
-    /**
-     * Access methods to members
-     * @return
-     */
-    inline auto m_rootNodeId() const -> const size_t&
-    {
-        return m_storage->m_rootNodeId;
-    }
-
-    inline auto m_setRootNodeId(const size_t& rootNodeId) -> void
-    {
-        m_storage->m_rootNodeId = rootNodeId;
-    }
-
-
-    /**
-     * Access methods to members
-     * @return
-     */
-    inline auto m_finalNodeId() const -> const size_t&
-    {
-        return m_storage->m_finalNodeId;
-    }
-
-    /**
-     * set final node
-     * @return
-     */
-    inline auto m_setFinalNodeId(const size_t& finalNode) -> void
-    {
-        m_storage->m_finalNodeId = finalNode;
-    }
-
-    /**
-     * Access methods to members
-     * @return
-     */
-    inline auto m_setCardinality() -> int&
-    {
-        return m_storage->m_setCardinality;
-    }
-
-
-    enum heloUpdate
-    {
-        PUT,
-        GET
-    };
-
-    /**
-     * Parser method
-     * @param setCardinalty
-     * @param operations
-     */
-    void parse(int setCardinalty, const std::vector<Neon::set::Container>&& operations);
-
-    /**
-     *
-     * @param options
-     */
-    auto optimizations(const Neon::skeleton::Options& options)
-        -> void;
-
-    /**
-     * Helper function to add a new kernel to the graph
-     * The dependencies are extracted from the kernel container
-     * @param container
-     */
-    auto h_parseContainer(const Neon::set::Container&              inContainer,
-                          std::vector<size_t>&                     containerId2gNodeId,
-                          std::vector<std::tuple<size_t, Edge>>& specialClosureNodes)
-        -> void;
-
-    /**
-     * helper function to close the graph with a strart and end node
-     * @param specialClosureNodes
-     */
-    auto h_closure(const std::vector<std::tuple<size_t, Edge>>& specialClosureNodes)
-        -> void;
-
-    /**
-     * Parsing of a container of the task list
-     * @param kernelContainerIdx
-     * @return
-     */
-    auto h_parse(ContainerIdx kernelContainerIdx)
-        -> std::vector<DataToken_t>;
-
-    /**
-     * helper function to export a dot file
-     * @param fname
-     * @param graphName
-     */
-    auto h_io2Dot([[maybe_unused]] const std::string& fname,
-                  [[maybe_unused]] const std::string& graphName) -> void;
-
-
-   private:
-    auto h_trackNewContainer(const Neon::set::Container& container,
-                             std::vector<size_t>&        containerId2gNodeId) -> ContainerIdx;
-
-    auto h_removeRedundantDependencies() -> void;
-
-    /**
-     * Creates 2 nodes for
-     * @param uid
-     * @param edge
-     * @param infoIdx
-     * @param transferModeE
-     * @return
-     */
-    auto h_add_hUpdateSyncNodes(size_t                          t0Node,
-                                size_t                          t1Node,
-                                const internal::Edge::Info& info,
-                                Neon::set::TransferMode transferModeE = Neon::set::TransferMode::put)
-        -> void;
-
-    auto optimizeStandardOCC(const Neon::skeleton::Options&) -> void;
-
-    auto optimizeExtendedOCC(const Neon::skeleton::Options&) -> void;
-
-    auto optimizeTwoWayExtendedOCC(const Neon::skeleton::Options&) -> void;
-
-    /**
-     * Breadth First Traversal
-     * @param f
-     * @return
-     */
-    auto
-    h_BFT(std::function<void(int                     level,
-                             const std::set<size_t>& nodes)> f) -> void;
-
-    auto h_getBFSIndexes() -> std::unordered_map<size_t, int>;
-
-    //    auto fuseMaps(const Neon::skeleton::Options_t& options) -> void
-    //    {
-    //        // BFS visit
-    //        std::vector<int> frontiar;
-    //        m_graph.forEachOutEdge(m_rootNodeId, [&](const std::pair<size_t, size_t>& edge) {
-    //            frontiar.push_back(edge.second);
-    //        });
-    //
-    //        size_t frontiarParserIdx = 0;
-    //
-    //        /**
-    //         * Return -1 if there are no condition for a fusion
-    //         * Otherwise, it returns the node to fuse with
-    //         */
-    //        auto h_conditionForFusion = [&](const size_t n0) -> int64_t {
-    //            if (m_graph.outEdgesCount(n0) != 1) {
-    //                return -1;
-    //            }
-    //            const size_t n1 = m_graph.outEdges(n0).begin()->second;
-    //            if (m_graph.inEdgesCount(n1) != 1) {
-    //                return -1;
-    //            }
-    //            if(m_graph.getVertexProperty(n1).isStencil()){
-    //                return -1;
-    //            }
-    //            return n1;
-    //        };
-    //
-    //        auto h_fuse= [&](const size_t n0, const size_t n1){
-    //            //1. create a fused kernel container
-    //        };
-    //
-    //        while (frontiarParserIdx < frontiar.size()) {
-    //            size_t nodeId = frontiar[frontiarParserIdx];
-    //            if (m_graph.outEdges(nodeId).size() == 1 &&) {
-    //                // a. Fuse
-    //
-    //                // b. update nodeId to the new node
-    //            }
-    //            // c. continue with BFS
-    //        }
-    //    }
-
-    auto addSyncAndMemoryTransfers(const Neon::skeleton::Options& options) -> void;
-
-    auto checkCoherency() -> void;
-
-
-    auto resetLinearContinuousIndexing() -> void;
-};
-}  // namespace Neon::skeleton::internal
diff --git a/libNeonSkeleton/include/Neon/skeleton/internal/MultiXpuGraph.h b/libNeonSkeleton/include/Neon/skeleton/internal/MultiXpuGraph.h
new file mode 100644
index 00000000..14d85207
--- /dev/null
+++ b/libNeonSkeleton/include/Neon/skeleton/internal/MultiXpuGraph.h
@@ -0,0 +1,166 @@
+#pragma once
+#include <list>
+#include "Neon/core/types/digraph.h"
+#include "Neon/set//Containter.h"
+#include "Neon/set/Backend.h"
+#include "Neon/set/container/Graph.h"
+#include "Neon/skeleton/Options.h"
+#include "Neon/skeleton/internal/dependencyTools/UserDataManager.h"
+
+namespace Neon::skeleton::internal {
+/**
+ * Graph storing dependency between user kernels
+ */
+struct MultiXpuGraph
+{
+
+   public:
+    /**
+     * Default empty constructor
+     */
+    MultiXpuGraph();
+
+    void init(Neon::Backend&                           bk,
+              const std::vector<Neon::set::Container>& operations,
+              std::string                              name,
+              Options                                  options);
+
+    /**
+     * Export the graph of the user application
+     * @param fname
+     * @param graphName
+     */
+    auto io2DotOriginalApp(const std::string& fname,
+                           const std::string& graphName,
+                           bool               debug = false)
+        -> void;
+
+    /**
+     * Export both the data dependency graph and the scheduling graph
+     * @param fname
+     * @param graphName
+     */
+    auto ioToDot(const std::string& fname,
+                 const std::string& graphName,
+                 bool               debug = false)
+        -> void;
+
+    auto execute(const Neon::skeleton::Options& options)
+        -> void;
+
+   private:
+
+
+    /**
+     * Access methods to members
+     * @return
+     */
+    inline auto getContainers()
+        -> std::vector<Neon::set::Container>&
+    {
+        return mStorage->mContainers;
+    }
+
+    inline auto getContainers()
+        const -> const std::vector<Neon::set::Container>&
+    {
+        return mStorage->mContainers;
+    }
+
+    /**
+     * Access methods to members
+     * @return
+     */
+    inline auto getDataRecords()
+        -> UserDataManager&
+    {
+        return mStorage->mDataRecords;
+    }
+
+    inline auto getGraph()
+        -> Neon::set::container::Graph&
+    {
+        return mStorage->mGraph;
+    }
+
+    /**
+     * Access methods to members
+     * @return
+     */
+    inline auto getSetCardinality()
+        -> int&
+    {
+        return mStorage->mSetCardinality;
+    }
+
+
+    enum heloUpdate
+    {
+        PUT,
+        GET
+    };
+
+    /**
+     * Parser method
+     * @param setCardinalty
+     * @param operations
+     */
+    auto parse(int                                       setCardinalty,
+               const std::vector<Neon::set::Container>&& operations)
+        -> void;
+
+    /**
+     *
+     * @param options
+     */
+    auto optimizations(const Neon::skeleton::Options& options)
+        -> void;
+
+    /**
+     * Helper function to add a new kernel to the graph
+     * The dependencies are extracted from the kernel container
+     */
+    auto helpParseNewContainer(const Neon::set::Container& inContainer)
+        -> void;
+
+    /**
+     * Parsing of a container of the task list
+     */
+    auto helpParseContainer(Neon::set::Container& kernelContainerIdx)
+        -> std::vector<Neon::set::dataDependency::Token>;
+
+    auto computeScheduling()
+        -> void;
+
+
+
+   private:
+    auto helpAddNewContainerToGraph(const Neon::set::Container& container)
+        -> Neon::set::container::GraphInfo::NodeUid;
+
+    auto optimizeStandardOCC(const Neon::skeleton::Options&)
+        -> void;
+
+    auto optimizeExtendedOCC(const Neon::skeleton::Options&)
+        -> void;
+
+    auto optimizeTwoWayExtendedOCC(const Neon::skeleton::Options&)
+        -> void;
+
+    auto communications(const Neon::skeleton::Options& skeletonOptions)
+        -> void;
+
+    auto fixingDependenciesWithBeginNode()
+        -> void;
+
+    struct Storage
+    {
+        std::vector<Neon::set::Container> mContainers;
+        UserDataManager                   mDataRecords;
+        int                               mSetCardinality = 0;
+        Neon::set::container::Graph       mGraph;
+    };
+
+    std::shared_ptr<Storage> mStorage;
+};
+}  // namespace Neon::skeleton::internal
diff --git a/libNeonSkeleton/include/Neon/skeleton/internal/StreamScheduler.h b/libNeonSkeleton/include/Neon/skeleton/internal/StreamScheduler.h
deleted file mode 100644
index 4f8a6bbf..00000000
--- a/libNeonSkeleton/include/Neon/skeleton/internal/StreamScheduler.h
+++ /dev/null
@@ -1,175 +0,0 @@
-#pragma once
-#include <unordered_set>
-#include "Neon/skeleton/internal/MultiGpuGraph.h"
-
-namespace Neon::skeleton::internal {
-
-class StreamScheduler
-{
-   public:
-    using DiGraph = MultiGpuGraph::DiGraph;
-
-    using Level = std::vector<MetaNodeExtendedIdx>;
-    struct MetaNodeExtended
-    {
-        struct SchedulingInfo
-        {
-            SchedulingInfo();
-            SchedulingInfo(size_t nodeId, size_t extendedNodeIdx, ContainerIdx cIdx);
-            NodeId                       nodeId;
-            MetaNodeExtendedIdx          metaNodeExtendedIdx;
-            ContainerIdx                 containerIdx;
-            StreamIdx                    streamIdx = {-1};
-            std::unordered_set<EventIdx> waitEventIdxList;
-            EventIdx                     setEventIdx = {-1};
-            EventIdx                     barrierLR = {-1};
-            bool                         isHaloUpdateNode = false;
-            int                          schedulingOrder{-1};
-        };
-
-        int            blockingDependencies{-1};
-        SchedulingInfo schedulingInfo;
-    };
-
-
-    auto io2Dot(const std::string& nodeId, const std::string& graphName) -> void;
-    auto io2DotOrder(const std::string& nodeId, const std::string& graphName) -> void;
-
-   private:
-    struct Storage
-    {
-       public:
-        std::vector<Level>  m_levels;
-        std::vector<int>    m_streamFlags;
-        MultiGpuGraph&      m_graph;
-        bool                m_initDone = {false};
-        Neon::Backend       m_bk;
-        std::vector<NodeId> m_executionOrder;
-        std::vector<NodeId> m_linearization;
-
-        Storage(Neon::Backend& bk, MultiGpuGraph& graph)
-            : m_graph(graph), m_bk(bk)
-        {
-        }
-        std::vector<MetaNodeExtended> m_metaNodeExtendedList;
-        bool                          useFullBarrierOnAllStreamsAtTheEnd = true;
-        bool                          canEndNodeLastBarrierBeOptimizedOut = false;
-    };
-
-    std::shared_ptr<Storage> m_storage;
-
-   public:
-    auto init(Neon::Backend& bk, MultiGpuGraph& multiGpuGraph) -> void;
-
-    /**
-     * Returns number of levels
-     * @return
-     */
-    auto nLevels() -> int;
-
-    /**
-     *
-     * @return
-     */
-    auto addNewLevel() -> LevelIdx;
-
-    auto getLevel(int levelIdx) -> Level&;
-
-    auto resetLevels() -> void;
-
-    /**
-     *
-     */
-    auto getStreamFlags() -> std::vector<int>&;
-
-    /**
-     * Counting the number of streams required
-     * @return
-     */
-    auto initStreamFlags() -> int;
-
-    /**
-     *
-     * @return
-     */
-    auto resetStreamFlags() -> void;
-
-    /**
-     *
-     * @param containerIdx
-     * @return
-     */
-    auto registerNodeToLastLevel(size_t nodeId) -> void;
-
-    /**
-     * Creating the level for the scheduling
-     */
-    auto initCreateLevels() -> void;
-    /**
-     * Schedule a stream for each node
-     */
-    auto initScheduleStreams() -> void;
-
-    /**
-     * Schedule required events for each node
-     */
-    auto initScheduleEvents() -> void;
-
-    /**
-     * Create a linearizex indexing
-     */
-    auto initLinearisationList() -> void;
-
-    /**
-     * Remove redundant synchronizations
-     */
-    auto initCleanRedundantSync() -> void;
-
-    /**
-     * Remove redundant events
-     */
-    auto initCleanRedundantEvents() -> void;
-
-    /**
-     * Define the execution order for each task
-     */
-    auto initExecutionOrder() -> void;
-
-    /**
-     * Execute the graph
-     */
-    auto run(const Neon::skeleton::Options& options) -> void;
-
-   private:
-    auto h_getMetaNodeExtended(NodeId id) -> MetaNodeExtended&;
-    auto h_getMetaNodeExtended(MetaNode& id) -> MetaNodeExtended&;
-    auto h_getMetaNode(NodeId id) -> MetaNode&;
-
-    auto helpRunOmpAtGraphLevel() -> void;
-    auto helpRunOmpAtNodeLevel() -> void;
-
-    template <typename Graph>
-    auto h_dissolveDataDependencies(Graph& graph, NodeId nodeId) -> void
-    {
-        // helper function to update the dependency count of child nodes
-        auto outNeighbours = graph.outNeighbors(nodeId);
-        for (const auto& ngh : outNeighbours) {
-            auto& metaNodeExtended = h_getMetaNodeExtended(ngh);
-            // std::cout << "NodeGeneric " << nodeId << " dissolve " << ngh << " from " << metaNodeExtended.blockingDependencies << " to " << metaNodeExtended.blockingDependencies - 1 << std::endl;
-            metaNodeExtended.blockingDependencies--;
-        }
-        //        for (auto huNode : h_getMetaNodeExtended(nodeId).childHaloNodes) {
-        //            h_dissolveDataDependencies(huNode);
-        //        }
-    };
-
-    auto helpRun(NodeId nodeId, StreamIdx streamIdx) -> void;
-    auto helpRun(Neon::SetIdx setIdx, NodeId nodeId, StreamIdx streamIdx) -> void;
-    auto helpNvtxName(NodeId nodeId) -> std::string;
-    auto helpWaitForEventCompletion(StreamIdx streamIdx, EventIdx eventIdx) -> void;
-    auto helpWaitForEventCompletion(Neon::SetIdx setIdx, StreamIdx streamIdx, EventIdx eventIdx) -> void;
-    auto helpEnqueueEvent(StreamIdx streamIdx, EventIdx eventIdx) -> void;
-    auto helpEnqueueEvent(Neon::SetIdx setIdx, StreamIdx streamIdx, EventIdx eventIdx) -> void;
-};
-
-}  // namespace Neon::skeleton::internal
diff --git a/libNeonSkeleton/include/Neon/skeleton/internal/dependencyTools/Alias.h b/libNeonSkeleton/include/Neon/skeleton/internal/dependencyTools/Alias.h
deleted file mode 100644
index 2893e2d6..00000000
--- a/libNeonSkeleton/include/Neon/skeleton/internal/dependencyTools/Alias.h
+++ /dev/null
@@ -1,29 +0,0 @@
-#pragma once
-#include "Neon/set/Backend.h"
-#include "Neon/set/dependencyTools/Alias.h"
-#include "Neon/set/dependencyTools/DataParsing.h"
-#include "Neon/set/dependencyTools/enum.h"
-
-namespace Neon::skeleton::internal {
-
-/**
- * Index of a KernelContainer
- */
-using ContainerIdx = int64_t;
-using DataUId_t = Neon::set::internal::dependencyTools::DataUId_t;
-using DataIdx_t = Neon::set::internal::dependencyTools::DataIdx_t;
-
-using Dependencies_e = Neon::set::internal::dependencyTools::Dependencies_e;
-using Dependencies_et = Neon::set::internal::dependencyTools::Dependencies_et;
-
-using Access_e = Neon::set::internal::dependencyTools::Access_e;
-using Access_et = Neon::set::internal::dependencyTools::Access_et;
-
-using DataToken_t = Neon::set::internal::dependencyTools::DataToken;
-
-
-using NodeId = size_t;              /** id for DiGraph */
-using MetaNodeExtendedIdx = size_t; /** index for the extended node information */
-using LevelIdx = int;               /** level index */
-
-}  // namespace Neon
\ No newline at end of file
diff --git a/libNeonSkeleton/include/Neon/skeleton/internal/dependencyTools/DataDependency.h b/libNeonSkeleton/include/Neon/skeleton/internal/dependencyTools/DataDependency.h
new file mode 100644
index 00000000..922a7618
--- /dev/null
+++ b/libNeonSkeleton/include/Neon/skeleton/internal/dependencyTools/DataDependency.h
@@ -0,0 +1,73 @@
+#pragma once
+#include "Neon/set/Backend.h"
+#include "Neon/set/container/Graph.h"
+#include "Neon/set/container/graph/GraphInfo.h"
+#include "Neon/set/dependency/DataDependencyType.h"
+
+namespace Neon::skeleton::internal {
+
+
+struct DataDependency
+{
+   private:
+    Neon::set::container::GraphInfo::NodeUid      mT0 = 0;
+    Neon::set::container::GraphInfo::NodeUid      mT1 = 0;
+    Neon::set::dataDependency::DataDependencyType mType = Neon::set::dataDependency::DataDependencyType::NONE;
+    Neon::set::dataDependency::MultiXpuDataUid    mDataUid = 0;
+
+   public:
+    /**
+     * Empty constructor
+     */
+    DataDependency() = default;
+
+    /**
+     * Defines a dependency of type e between kernel A and B.
+     * Note, the order is important.
+     *
+     * Example: a read after write where kernel B reads results from kernel A
+     *          Dependency_t(B, RAW, A)
+     */
+    DataDependency(Neon::set::container::GraphInfo::NodeUid      t1,
+                   Neon::set::dataDependency::DataDependencyType type,
+                   Neon::set::dataDependency::MultiXpuDataUid    m_uid,
+                   Neon::set::container::GraphInfo::NodeUid      t0);
+
+    /**
+     * true the object has been initialized with a valid dependency
+     * @return
+     */
+    bool isValid();
+
+    /**
+     * Convert the dependency into a string
+     * @return
+     */
+    auto toString() -> std::string;
+
+    /**
+     * Returns the dependency type
+     * @return
+     */
+    auto type() -> Neon::set::dataDependency::DataDependencyType;
+
+    /**
+     * Returns the "before" kernel id
+     * @return
+     */
+    auto t0() -> Neon::set::container::GraphInfo::NodeUid;
+
+    /**
+     * Returns the "after" kernel id
+     * @return
+     */
+    auto t1() -> Neon::set::container::GraphInfo::NodeUid;
+
+    /**
+     * Static method to build an empty dependency
+     * @return
+     */
+    static DataDependency getEmpty();
+};
+
+}  // namespace Neon::skeleton::internal
\ No newline at end of file
diff --git a/libNeonSkeleton/include/Neon/skeleton/internal/dependencyTools/Dependency.h b/libNeonSkeleton/include/Neon/skeleton/internal/dependencyTools/Dependency.h
deleted file mode 100644
index 6cb08e41..00000000
--- a/libNeonSkeleton/include/Neon/skeleton/internal/dependencyTools/Dependency.h
+++ /dev/null
@@ -1,71 +0,0 @@
-#pragma once
-#include "Neon/set/Backend.h"
-#include "Neon/set/dependencyTools/enum.h"
-#include "Neon/skeleton/internal//dependencyTools/Alias.h"
-
-namespace Neon::skeleton::internal {
-
-
-struct Dependency
-{
-   private:
-    ContainerIdx   m_t0 = 0;
-    ContainerIdx   m_t1 = 0;
-    Dependencies_e m_type = Dependencies_e::NONE;
-    DataUId_t      m_uid = 0;
-
-   public:
-    /**
-     * Empty constructor
-     */
-    Dependency() = default;
-
-    /**
-     * Defines a dependency of type e between kernel A and B.
-     * Note, the order is important.
-     *
-     * Example: a read after write where kernel B reads results from kernel A
-     *          Dependency_t(B, RAW, A)
-     * @param A
-     * @param B
-     */
-    Dependency(ContainerIdx t1, Dependencies_e type, DataUId_t m_uid, ContainerIdx t0);
-
-    /**
-     * true the object has been initialized with a valid dependency
-     * @return
-     */
-    bool isValid();
-
-    /**
-     * Convert the dependency into a string
-     * @return
-     */
-    auto toString() -> std::string;
-
-    /**
-     * Returns the dependency type
-     * @return
-     */
-    auto type() -> Dependencies_e;
-
-    /**
-     * Returns the "before" kernel id
-     * @return
-     */
-    auto t0() -> ContainerIdx;
-
-    /**
-     * Returns the "after" kernel id
-     * @return
-     */
-    auto t1() -> ContainerIdx;
-
-    /**
-     * Static method to build an empty dependency
-     * @return
-     */
-    static Dependency getEmpty();
-};
-
-}
\ No newline at end of file
diff --git a/libNeonSkeleton/include/Neon/skeleton/internal/dependencyTools/DependencyAnalyser.h b/libNeonSkeleton/include/Neon/skeleton/internal/dependencyTools/DependencyAnalyser.h
index 1d8fb6c9..f51ff252 100644
--- a/libNeonSkeleton/include/Neon/skeleton/internal/dependencyTools/DependencyAnalyser.h
+++ b/libNeonSkeleton/include/Neon/skeleton/internal/dependencyTools/DependencyAnalyser.h
@@ -1,8 +1,6 @@
 #pragma once
 #include "Neon/set/Backend.h"
-#include "Neon/skeleton/internal/dependencyTools/Alias.h"
-#include "Neon/skeleton/internal/dependencyTools/Dependency.h"
-#include "Neon/set/dependencyTools/enum.h"
+#include "Neon/skeleton/internal/dependencyTools/DataDependency.h"
 
 namespace Neon::skeleton::internal {
 
@@ -11,20 +9,23 @@ namespace Neon::skeleton::internal {
  * Stores type of operations on data for each kernels while user code is "parsed"
  * It is used to construct the user kernel dependency graph
  */
-// TODO rename DataDependencyAnalizer_t
 struct DependencyAnalyser
 {
    private:
-    std::vector<ContainerIdx> m_parsedR{};
-    std::vector<ContainerIdx> m_parsedW{};
+    std::vector<Neon::set::container::GraphInfo::NodeUid> mParsedR{};
+    std::vector<Neon::set::container::GraphInfo::NodeUid> mParsedW{};
 
-    DataUId_t m_uid;
-    DataIdx_t m_idx;
+    Neon::set::dataDependency::MultiXpuDataUid mUid;
+    Neon::set::dataDependency::MultiXpuDataIdx mIdx;
 
    public:
     DependencyAnalyser() = delete;
-    DependencyAnalyser(DataUId_t, DataIdx_t);
-    auto update(ContainerIdx newKernel, Access_e newOp) -> std::vector<Dependency>;
+    DependencyAnalyser(Neon::set::dataDependency::MultiXpuDataUid,
+                       Neon::set::dataDependency::MultiXpuDataIdx);
+
+    auto update(Neon::set::container::GraphInfo::NodeUid       newKernel,
+                Neon::set::dataDependency::AccessType newOp)
+        -> std::vector<DataDependency>;
 };
 
-}
\ No newline at end of file
+}  // namespace Neon::skeleton::internal
\ No newline at end of file
diff --git a/libNeonSkeleton/include/Neon/skeleton/internal/dependencyTools/UserDataManager.h b/libNeonSkeleton/include/Neon/skeleton/internal/dependencyTools/UserDataManager.h
index 9b12bc8d..c4f97c14 100644
--- a/libNeonSkeleton/include/Neon/skeleton/internal/dependencyTools/UserDataManager.h
+++ b/libNeonSkeleton/include/Neon/skeleton/internal/dependencyTools/UserDataManager.h
@@ -1,8 +1,9 @@
 #pragma once
 #include <map>
 #include "Neon/set/Backend.h"
-#include "Neon/set/dependencyTools/Alias.h"
-#include "Neon/set/dependencyTools/enum.h"
+#include "Neon/set/container/Graph.h"
+
+#include "Neon/set/dependency/DataDependencyType.h"
 #include "Neon/skeleton/internal/dependencyTools/DependencyAnalyser.h"
 
 namespace Neon::skeleton::internal {
@@ -12,15 +13,17 @@ namespace Neon::skeleton::internal {
  * Keep track of all the data used by all kernels
  *
  * Each field is track by a local indexing.
- * The indexing is determined by the map m_uid2Idx
+ * The indexing is determined by the map mUid2Idx
  *
- * The local index (DataIdx_t) is used to access information on the user data
- * that is stored in the vector m_depAnalyserVec.
+ * The local index (DataIdx) is used to access information on the user data
+ * that is stored in the vector mDepAnalyserVec.
  */
 struct UserDataManager
 {
-    std::vector<DependencyAnalyser> m_depAnalyserVec;
-    std::map<DataUId_t, DataIdx_t>    m_uid2Idx;
+    std::vector<DependencyAnalyser> mDepAnalyserVec;
+    std::map<Neon::set::dataDependency::MultiXpuDataUid,
+             Neon::set::dataDependency::MultiXpuDataIdx>
+        mUid2Idx;
 
    private:
     /**
@@ -28,7 +31,8 @@ struct UserDataManager
      * @param uid
      * @return
      */
-    auto helpGetIdx(DataUId_t uid) -> DataIdx_t;
+    auto helpGetIdx(Neon::set::dataDependency::MultiXpuDataUid uid)
+        -> Neon::set::dataDependency::MultiXpuDataIdx;
 
    public:
     /**
@@ -40,9 +44,9 @@ struct UserDataManager
      * @param uid
      * @return
      */
-    auto updateStatus(ContainerIdx newKernel,
-                      Access_e     op,
-                      DataUId_t    uid) -> std::vector<Dependency>;
+    auto updateStatus(Neon::set::container::GraphInfo::NodeUid       newKernel,
+                      Neon::set::dataDependency::AccessType op,
+                      Neon::set::dataDependency::MultiXpuDataUid uid) -> std::vector<DataDependency>;
 };
 
-}  // namespace internal
+}  // namespace Neon::skeleton::internal
diff --git a/libNeonSkeleton/include/Neon/skeleton/internal/multiGpuGraph/Edge.h b/libNeonSkeleton/include/Neon/skeleton/internal/multiGpuGraph/Edge.h
deleted file mode 100644
index a9c5048c..00000000
--- a/libNeonSkeleton/include/Neon/skeleton/internal/multiGpuGraph/Edge.h
+++ /dev/null
@@ -1,135 +0,0 @@
-#pragma once
-#include "Neon/set/dependencyTools/DataParsing.h"
-#include "Neon/skeleton/internal/dependencyTools/Alias.h"
-
-namespace Neon {
-namespace skeleton {
-namespace internal {
-
-/**
- * Information stored for each Edge in the user graph
- */
-struct Edge
-{
-    struct Info
-    {
-        Info(DataToken_t    t,
-               Dependencies_e d,
-               bool           haloUp = false)
-            : token(t), dependency(d), haloUpdate(haloUp)
-        {
-            if (haloUp && token.compute() != Neon::Compute::STENCIL) {
-                NEON_THROW_UNSUPPORTED_OPTION("");
-            }
-        }
-
-        DataToken_t token;
-        // This flag is true when a stencil dependency does need
-        // halo update as the previous map is running on internals
-        bool           flag_discardStencilDep = {false};
-        Dependencies_e dependency;
-        bool           haloUpdate = false;
-
-        /**
-         * Returns true if this is a stencil edge
-         * @return
-         */
-        bool isStencil() const
-        {
-            return (token.compute() == Neon::Compute::STENCIL) && !flag_discardStencilDep;
-        }
-
-        /**
-         * Returns true if this is halo edge
-         * @return
-         */
-        bool isHu() const
-        {
-            return haloUpdate;
-        }
-
-        auto toString() const -> std::string
-        {
-            using namespace set::internal::dependencyTools;
-            if (!haloUpdate) {
-                //                return " UID " + std::to_string(token.uid()) +
-                return "- Type: " + Dependencies_et::toString(dependency) + "\\l";  //"- UID: " + std::to_string(token.uid()) + "\\l";
-                //                       "\\l-Operation: " + Access_et::toString(token.access()) +
-                //                       "\\l-Pattern:  " + Compute_et::toString(token.compute())+
-
-            } else {
-                //                return " UID " + std::to_string(token.uid()) +
-                return "- Type: " + Dependencies_et::toString(dependency) + " HU\\l";
-                //                       "\\l-Operation: " + Access_et::toString(token.access()) +
-                //                       "\\l-Pattern: " + Compute_et::toString(token.compute())+
-                //                       " HU\\l";
-            }
-        }
-    };
-
-    size_t              m_edgeId;
-    std::vector<Info> m_dependencies;
-    bool                m_isSchedulingEdge = false;
-    /**
-     * Private constructor.
-     * Only the container method can be used to create Edge elements.
-     *
-     * @param edgeId
-     * @param op
-     * @param uid
-     */
-    Edge(size_t             edgeId,
-           const DataToken_t& dataToken,
-           Dependencies_e     dependency,
-           bool               haloUp = false);
-
-    Edge(size_t edgeId,
-           bool   isSchedulingEdge);
-
-   public:
-    Edge() = default;
-
-    /**
-     * Factory method to create an Edge object.
-     * This methos is not thread safe
-     *
-     * @param op
-     * @return
-     */
-    static auto
-    factory(const DataToken_t& dataToken,
-            Dependencies_e     dependency,
-            bool               haloUp = false) -> Edge;
-
-    static auto
-    factorySchedulingEdge() -> Edge;
-
-    auto clone() const -> Edge;
-
-    auto edgeId() const -> size_t;
-
-    auto
-    nDependencies()
-        const -> size_t;
-
-    auto
-    info()
-        const -> const std::vector<Info>&;
-
-    auto
-    infoMutable()
-        -> std::vector<Info>&;
-
-
-    auto
-    append(const DataToken_t& dataToken,
-           Dependencies_e     dType) -> void;
-
-    auto
-    toString()
-        const -> std::string;
-};
-
-}  // namespace internal
-}  // namespace skeleton
-}  // namespace Neon
\ No newline at end of file
diff --git a/libNeonSkeleton/include/Neon/skeleton/internal/multiGpuGraph/MetaNode.h b/libNeonSkeleton/include/Neon/skeleton/internal/multiGpuGraph/MetaNode.h
deleted file mode 100644
index 4b6b1055..00000000
--- a/libNeonSkeleton/include/Neon/skeleton/internal/multiGpuGraph/MetaNode.h
+++ /dev/null
@@ -1,143 +0,0 @@
-#pragma once
-#include "Neon/domain/internal/haloUpdateType.h"
-#include "Neon/set/DevSet.h"
-#include "Neon/skeleton/internal/dependencyTools/Alias.h"
-namespace Neon {
-namespace skeleton {
-namespace internal {
-
-struct MetaNodeType_te
-{
-    MetaNodeType_te() = delete;
-    MetaNodeType_te(const MetaNodeType_te&) = delete;
-    enum e
-    {
-        SYNC_LEFT_RIGHT,
-        BARRIER,
-        HALO_UPDATE,
-        CONTAINER,
-        HELPER,
-        UNDEFINED
-    };
-
-    static auto
-    toString(MetaNodeType_te::e type) -> std::string;
-};
-using MetaNodeType_e = MetaNodeType_te::e;
-
-
-struct MetaNode
-{
-   private:
-    MetaNode(size_t                nodeId,
-             const std::string&    name,
-             MetaNodeType_e        nodeType,
-             ContainerIdx          kernelContainerIdx,
-             const Neon::DataView& dataView = Neon::DataView::STANDARD);
-
-   private:
-    size_t         m_nodeId;
-    std::string    m_name;
-    MetaNodeType_e m_nodeType;
-    ContainerIdx   m_kernelContainerIdx;
-    Neon::DataView m_dataView{Neon::DataView::STANDARD};
-    Neon::Compute  m_compute{Neon::Compute::MAP};
-
-    Neon::set::TransferMode         m_transferMode{Neon::set::TransferMode::get};
-    Neon::set::MultiDeviceObjectUid m_uid;
-
-    size_t m_linearContinuousIndex = 0; /** this index is created when any change to the graph has been completed.
-                                         * It provides a way to associate data to nodes by the means of vectors
-                                         */
-
-    bool m_hasCoherentInput = false;
-
-    std::function<void(Neon::set::HuOptions& opt)>               m_hu;
-    std::function<void(Neon::SetIdx, Neon::set::HuOptions& opt)> m_huPerDevice;
-
-    struct cudaGraphHandles_t
-    {
-        std::vector<Neon::set::DataSet<cudaGraphNode_t>> m_data;
-        int                                              m_first = 3;
-        int                                              m_last = 3;
-
-        auto init(MetaNodeType_e m_nodeType, int numDevices) -> void;
-        auto first() -> Neon::set::DataSet<cudaGraphNode_t>&;
-        auto last() -> Neon::set::DataSet<cudaGraphNode_t>&;
-
-    } m_cudaGraphHandles;
-
-   public:
-    /**
-     *
-     * @return
-     */
-    static auto
-    factory(MetaNodeType_e        nodeType,
-            const std::string&    name,
-            ContainerIdx          kernelContainerIdx,
-            const Neon::DataView& dataView = Neon::DataView::STANDARD) -> MetaNode;
-
-    /**
-     * Create a clone of the node.
-     * The new node will have a different id
-     * @return
-     */
-    auto clone() const -> MetaNode;
-
-    static auto
-    haloUpdateFactory(Neon::set::TransferMode,
-                      const Neon::set::MultiDeviceObjectUid&                              dataUids,
-                      std::function<void(Neon::set::HuOptions& opt)>                      hu,
-                      const std::function<void(Neon::SetIdx, Neon::set::HuOptions& opt)>& huPerDevice) -> MetaNode;
-
-    static auto
-    syncLeftRightFactory(const Neon::set::MultiDeviceObjectUid& dataUids) -> MetaNode;
-
-    auto
-    nodeId() const -> NodeId;
-
-
-    auto
-    name() const -> const std::string&;
-
-    auto setAsCoherent() -> void;
-
-    auto nodeType() const -> MetaNodeType_e;
-
-    auto getContainerId() const -> ContainerIdx;
-
-    auto toString() const -> std::string;
-
-    auto setDataView(const Neon::DataView&) -> void;
-
-    auto getDataView() const -> Neon::DataView;
-
-    auto setCompute(const Neon::Compute&) -> void;
-
-    auto getCompute() const -> Neon::Compute;
-
-    auto isStencil() const -> bool;
-
-    auto isReduce() const -> bool;
-
-    auto isMap() const -> bool;
-
-    auto isSync() const -> bool;
-
-    auto isHu() const -> bool;
-
-    auto hu(Neon::set::HuOptions& opt) -> void;
-
-    auto hu(Neon::SetIdx setIdx, Neon::set::HuOptions& opt) -> void;
-
-    auto transferMode() const -> Neon::set::TransferMode;
-
-    auto setLinearContinuousIndex(size_t id) -> void;
-
-    auto getLinearContinuousIndex() const -> size_t;
-};
-
-}  // namespace internal
-}  // namespace skeleton
-}  // namespace Neon
\ No newline at end of file
diff --git a/libNeonSkeleton/src/skeleton/depencencyTools/Dependency.cpp b/libNeonSkeleton/src/skeleton/depencencyTools/Dependency.cpp
index 08e83641..a11467ca 100644
--- a/libNeonSkeleton/src/skeleton/depencencyTools/Dependency.cpp
+++ b/libNeonSkeleton/src/skeleton/depencencyTools/Dependency.cpp
@@ -1,48 +1,49 @@
-#include "Neon/skeleton/internal/dependencyTools/Dependency.h"
+#include "Neon/skeleton/internal/dependencyTools/DataDependency.h"
 
 namespace Neon::skeleton::internal {
 
-Dependency::Dependency(ContainerIdx   t1,
-                       Dependencies_e type,
-                       DataUId_t      uid,
-                       ContainerIdx   t0)
+DataDependency::DataDependency(Neon::set::container::GraphInfo::NodeUid               t1,
+                               Neon::set::dataDependency::DataDependencyType type,
+                               Neon::set::dataDependency::MultiXpuDataUid uid,
+                               Neon::set::container::GraphInfo::NodeUid               t0)
 {
-    m_t1 = t1;
-    m_type = type;
-    m_uid = uid;
-    m_t0 = t0;
+    mT1 = t1;
+    mType = type;
+    mDataUid = uid;
+    mT0 = t0;
 }
 
-bool Dependency::isValid()
+bool DataDependency::isValid()
 {
-    return m_type != Dependencies_e::NONE;
+    return mType != Neon::set::dataDependency::DataDependencyType::NONE;
 }
 
-auto Dependency::toString() -> std::string
+auto DataDependency::toString() -> std::string
 {
-    return std::to_string(m_t1) +
-           " -> (" + Dependencies_et::toString(m_type) +
-           " [" + std::to_string(m_uid) +
-           "]) -> " + std::to_string(m_t0);
+    return std::to_string(mT1) +
+           " -> (" + Neon::set::dataDependency::DataDependencyTypeUtils::toString(mType) +
+           " [" + std::to_string(mDataUid) +
+           "]) -> " + std::to_string(mT0);
 }
 
-auto Dependency::type() -> Dependencies_e
+auto DataDependency::type() -> Neon::set::dataDependency::DataDependencyType
 {
-    return m_type;
+    return mType;
 }
 
-Dependency Dependency::getEmpty()
+DataDependency DataDependency::getEmpty()
 {
-    return Dependency();
+    return {};
 }
-auto Dependency::t0() -> ContainerIdx
+
+auto DataDependency::t0() -> Neon::set::container::GraphInfo::NodeUid
 {
-    return m_t0;
+    return mT0;
 }
 
-auto Dependency::t1() -> ContainerIdx
+auto DataDependency::t1() -> Neon::set::container::GraphInfo::NodeUid
 {
-    return m_t1;
+    return mT1;
 }
 
 }  // namespace Neon::skeleton::internal
\ No newline at end of file
diff --git a/libNeonSkeleton/src/skeleton/depencencyTools/DependencyAnalyser.cpp b/libNeonSkeleton/src/skeleton/depencencyTools/DependencyAnalyser.cpp
index 91e1a211..b13a224f 100644
--- a/libNeonSkeleton/src/skeleton/depencencyTools/DependencyAnalyser.cpp
+++ b/libNeonSkeleton/src/skeleton/depencencyTools/DependencyAnalyser.cpp
@@ -4,80 +4,140 @@
 namespace Neon::skeleton::internal {
 
 
-DependencyAnalyser::DependencyAnalyser(DataUId_t uid, DataIdx_t idx)
+DependencyAnalyser::
+    DependencyAnalyser(Neon::set::dataDependency::MultiXpuDataUid uid,
+                       Neon::set::dataDependency::MultiXpuDataIdx idx)
 {
-    m_uid = uid;
-    m_idx = idx;
+    mUid = uid;
+    mIdx = idx;
 }
 
-auto DependencyAnalyser::update(ContainerIdx newKernel, Access_e newOp)
-    -> std::vector<Dependency>
+auto DependencyAnalyser::
+    update(Neon::set::container::GraphInfo::NodeUid newKernel,
+           Neon::set::dataDependency::AccessType    newOp)
+        -> std::vector<DataDependency>
 {
     switch (newOp) {
-        case Access_e::READ: {
-            if (m_parsedW.size() == 0) {
-                // Parsing a Read operation with no write before
-                // We are at the beginning of the dependencies
-                // a. just add the kernel in the parsed read kernels
-                m_parsedR.push_back(newKernel);
-                return std::vector<Dependency>(0);
+        case Neon::set::dataDependency::AccessType::READ: {
+            if (mParsedW.size() == 0) {
+                // We are parsing a READ with no previous WRITE
+                // STEPS:
+                // a. Register the current kernel in the READ state machine
+                // b. Returns no dependencies
+
+                // Executing step a.
+                mParsedR.push_back(newKernel);
+                // Executing step b.
+                return std::vector<DataDependency>(0);
             }
-            if (m_parsedW.size() == 1) {
-                // Parsing a Read operation with one write before
-                // We have a RaW dependency
-                // a. add the new kernel to the read queue
-                // b. return a RaW between the new R and the old W
-                m_parsedR.push_back(newKernel);
-                auto       t0W = m_parsedW[0];
-                auto       t1R = newKernel;
-                Dependency d(t1R, Dependencies_e::RAW, m_uid, t0W);
-                return {d};
+            if (mParsedW.size() == 1) {
+                std::vector<DataDependency> output;
+                // Parsing a READ after a WRITE
+                // STEPS:
+                // a. Return a RaW between the new READing kernel and the old WRITing kernel
+                // b. Register the current kernel in the READ state machine
+                //------
+
+
+                {  // Executing a.
+                    auto t0W = mParsedW[0];
+                    auto t1R = newKernel;
+                    if (t0W != t1R) {
+                        DataDependency d(t1R, Neon::set::dataDependency::DataDependencyType::RAW, mUid, t0W);
+                        output.push_back(d);
+                    }
+                }
+
+                {  // Executing b.
+                    mParsedR.push_back(newKernel);
+                }
+                return output;
+
             } else {
-                // Violation of the state machine integrity
-                NEON_THROW_UNSUPPORTED_OPERATION("");
+                NEON_THROW_UNSUPPORTED_OPERATION("A Violation of the state machine integrity was detected");
             }
             break;
         }
-        case Access_e::WRITE: {
-            if (m_parsedR.size() == 0 && m_parsedW.size() == 0) {
-                // Parsing a kernel for the first time and it is a W
-                // Return an empty dependency
-                m_parsedW.push_back(newKernel);
-                return std::vector<Dependency>(0);
+        case Neon::set::dataDependency::AccessType::WRITE: {
+            if (mParsedR.empty() && mParsedW.empty()) {
+                // Parsing a WRITE as the first operation in the Container sequence.
+                //
+                // STEPS:
+                // a. Record the Write operation in the state machine
+                // b. Return no dependency
+                //------
+
+                {  // Executing a.
+                    mParsedW.push_back(newKernel);
+                }
+
+                {  // Executing b.
+                    return std::vector<DataDependency>(0);
+                }
             }
-            if (m_parsedR.size() != 0 && m_parsedW.size() <= 1) {
-                // Parsing a W kernel after
-                // .. none or one W old kernel
-                // .. one or more R old kernels
-
-                // Fire a WaR dependency between the new W and the old Rs
-                std::vector<Dependency> res;
-                for (auto t0R : m_parsedR) {
-                    auto t1W = newKernel;
-                    if (t1W == t0R) {
-                        continue;
+
+            if (!mParsedR.empty() && mParsedW.empty()) {
+                std::vector<DataDependency> output;
+                // Parsing a WRITE after some READs
+                //
+
+                // STEPS:
+                // a. creation the vector of WAR dependencies to be returned
+                // b. clear state machine state, cleaning previous read token and storing the new write token
+
+                {  // Executing a.
+                    for (const auto token_t0_READ : mParsedR) {
+                        const auto token_t1_WRITE = newKernel;
+                        if (token_t1_WRITE != token_t0_READ) {
+                            DataDependency d(token_t1_WRITE, Neon::set::dataDependency::DataDependencyType::WAR, mUid, token_t0_READ);
+                            output.push_back(d);
+                        }
                     }
-                    Dependency d(t1W, Dependencies_e::WAR, m_uid, t0R);
-                    res.push_back(d);
                 }
-                m_parsedR.clear();
-                m_parsedW = std::vector<ContainerIdx>(1, newKernel);
-                return res;
+
+                {  // Executing b.
+                    mParsedR.clear();
+                    mParsedW = std::vector<Neon::set::container::GraphInfo::NodeUid>(1, newKernel);
+                }
+
+                return output;
             }
 
-            if (m_parsedR.size() == 0 && m_parsedW.size() <= 1) {
-                // Parsing a W kernel after a W old kernel
+            if (!mParsedW.empty()) {
+                std::vector<DataDependency> output;
+                // STEPS:
+                // a. flag a WaW dependency
+                // b. flag possible WaR dependencies
+                // b. clear state machine state, cleaning previous read token and storing the new write token
+
                 NEON_WARNING("Skeleton: WaW dependency detected.");
-                auto       t0W = m_parsedW[0];
-                auto       t1W = newKernel;
-                Dependency d(t1W, Dependencies_e::WAW, m_uid, t0W);
-                m_parsedW = std::vector<ContainerIdx>(1, newKernel);
-                return std::vector<Dependency>(1, d);
-                ;
+                {  // Executing Step a.
+                    auto token_t0_WRITE = mParsedW[0];
+                    auto token_t1_WRITE = newKernel;
+                    if (token_t0_WRITE != token_t1_WRITE) {
+                        DataDependency d(token_t1_WRITE, Neon::set::dataDependency::DataDependencyType::WAW, mUid, token_t0_WRITE);
+                        output.push_back(d);
+                    }
+                }
+                {  // Executing Step b.
+                    for (const auto token_t0_READ : mParsedR) {
+                        const auto token_t1_WRITE = newKernel;
+                        if (token_t1_WRITE != token_t0_READ) {
+                            DataDependency d(token_t1_WRITE, Neon::set::dataDependency::DataDependencyType::WAR, mUid, token_t0_READ);
+                            output.push_back(d);
+                        }
+                    }
+                }
+                {  // Executing c.
+
+                    mParsedR.clear();
+                    mParsedW = std::vector<Neon::set::container::GraphInfo::NodeUid>(1, newKernel);
+                }
+                return output;
             }
             break;
         }
-        case Access_e::NONE: {
+        case Neon::set::dataDependency::AccessType::NONE: {
             // Error
             NEON_THROW_UNSUPPORTED_OPTION("");
         }
diff --git a/libNeonSkeleton/src/skeleton/depencencyTools/UserDataManager.cpp b/libNeonSkeleton/src/skeleton/depencencyTools/UserDataManager.cpp
index 92a4806c..1044af02 100644
--- a/libNeonSkeleton/src/skeleton/depencencyTools/UserDataManager.cpp
+++ b/libNeonSkeleton/src/skeleton/depencencyTools/UserDataManager.cpp
@@ -2,24 +2,26 @@
 
 namespace Neon::skeleton::internal {
 
-auto UserDataManager::helpGetIdx(DataUId_t uid) -> DataIdx_t
+auto UserDataManager::helpGetIdx(Neon::set::dataDependency::MultiXpuDataUid uid)
+    -> Neon::set::dataDependency::MultiXpuDataIdx
 {
-    auto count = m_uid2Idx.count(uid);
+    auto count = mUid2Idx.count(uid);
     if (count == 0) {
-        DataIdx_t idx = m_depAnalyserVec.size();
-        m_depAnalyserVec.emplace_back(uid, idx);
-        m_uid2Idx[uid] = idx;
+        Neon::set::dataDependency::MultiXpuDataIdx idx = mDepAnalyserVec.size();
+        mDepAnalyserVec.emplace_back(uid, idx);
+        mUid2Idx[uid] = idx;
         return idx;
     }
-    return m_uid2Idx[uid];
+    return mUid2Idx[uid];
 }
 
-auto UserDataManager::updateStatus(ContainerIdx newKernel,
-                                   Access_e     op,
-                                   DataUId_t    uid) -> std::vector<Dependency>
+auto UserDataManager::updateStatus(Neon::set::container::GraphInfo::NodeUid nodeUid,
+                                   Neon::set::dataDependency::AccessType                           op,
+                                   Neon::set::dataDependency::MultiXpuDataUid dataUid)
+    -> std::vector<DataDependency>
 {
-    auto idx = helpGetIdx(uid);
-    auto depVec = m_depAnalyserVec[idx].update(newKernel, op);
+    auto idx = helpGetIdx(dataUid);
+    auto depVec = mDepAnalyserVec[idx].update(nodeUid, op);
     return depVec;
 }
 
diff --git a/libNeonSkeleton/src/skeleton/internal/multiGpuGraph.cpp b/libNeonSkeleton/src/skeleton/internal/multiGpuGraph.cpp
index c67db3e7..e4e86fd1 100644
--- a/libNeonSkeleton/src/skeleton/internal/multiGpuGraph.cpp
+++ b/libNeonSkeleton/src/skeleton/internal/multiGpuGraph.cpp
@@ -1,460 +1,109 @@
-#include "Neon/skeleton/internal/MultiGpuGraph.h"
 #include <list>
+#include "Neon/skeleton/internal/MultiXpuGraph.h"
 
 namespace Neon::skeleton::internal {
 
-
-// auto UserGraph_t::h_newHaloNode()
-//{
-//     auto node = Node_t::factory(NodeType_e::HELPER, -1);
-//     m_graph().addVertex(node.nodeId(), node);
-//     return node.nodeId();
-// }
-//
-// auto UserGraph_t::h_newNeonNode() -> size_t
-//{
-//     auto node = Node_t::factory(NodeType_e::HELPER, -1);
-//     m_graph().addVertex(node.nodeId(), node);
-//     return node.nodeId();
-// }
-void MultiGpuGraph::init(Neon::Backend&                           bk,
+void MultiXpuGraph::init(Neon::Backend&                           bk,
                          const std::vector<Neon::set::Container>& operations,
-                         std::string                              name,
-                         Options                                  options)
+                         std::string /*name*/,
+                         Options options)
 {
-    parse(bk.devSet().setCardinality(), std::forward<const std::vector<Neon::set::Container>&&>(operations));
-    m_storage->m_userAppGraph = m_graph();
-    h_removeRedundantDependencies();
-    h_io2Dot("t0_" + name + ".dot", "i");
+    getGraph() = Neon::set::container::Graph(bk);
+    parse(bk.devSet().setCardinality(),
+          std::forward<const std::vector<Neon::set::Container>&&>(operations));
+    getGraph().removeRedundantDependencies();
+
+    // Stencil dependencies with the beginNode are not detected by the data dependency analysis.
+    // We fix them manually after all redundant dependencies are cleaned.
+    fixingDependenciesWithBeginNode();
+
+    // h_ioToDot("t0_" + name + ".dot", "i");
     optimizations(options);
-    h_io2Dot("t1_" + name + ".dot", "i");
-    addSyncAndMemoryTransfers(options);
-    h_removeRedundantDependencies();
-    checkCoherency();
-    h_io2Dot("t2_" + name + ".dot", "i");
-    resetLinearContinuousIndexing();
+    // h_ioToDot("t1_" + name + ".dot", "i");
+    communications(options);
+    getGraph().removeRedundantDependencies();
+
+
+    // h_ioToDot("t2_" + name + ".dot", "i");
+    this->computeScheduling();
+    // h_ioToDot("final" + name + ".dot", "i");
 }
 
-void MultiGpuGraph::parse(int setCardinalty, const std::vector<Neon::set::Container>&& operations)
+void MultiXpuGraph::parse(int                                       setCardinalty,
+                          const std::vector<Neon::set::Container>&& operations)
 {
-    m_setCardinality() = setCardinalty;
+    getSetCardinality() = setCardinalty;
 
-    std::vector<size_t>                   containerId2gNodeId;
-    std::vector<std::tuple<size_t, Edge>> specialClosureNodes;
-    int                                   i = 0;
     for (auto&& k : operations) {
-        h_parseContainer(k,
-                         containerId2gNodeId,
-                         specialClosureNodes);
-        i++;
+        helpParseNewContainer(k);
     }
-    h_closure(specialClosureNodes);
 }
 
-void MultiGpuGraph::h_parseContainer(const Neon::set::Container&            inContainer,
-                                     std::vector<size_t>&                   containerId2gNodeId,
-                                     std::vector<std::tuple<size_t, Edge>>& specialClosureNodes)
+void MultiXpuGraph::
+    helpParseNewContainer(const Neon::set::Container& inContainer)
 {
+
     // Register and retrieve the id for the new container
     // add a node
-    ContainerIdx containerIdx = h_trackNewContainer(inContainer, containerId2gNodeId);
+    Neon::set::container::GraphInfo::NodeUid graphNodeUid;
+    graphNodeUid = helpAddNewContainerToGraph(inContainer);
 
     // Parsing all the data toke used by the kernel container
-    std::vector<DataToken_t> tokens = h_parse(containerIdx);
-    int                      detectedDependencies = 0;
+    std::vector<Neon::set::dataDependency::Token> tokens;
+    tokens = helpParseContainer(getGraph().helpGetGraphNode(graphNodeUid).getContainer());
+
+    // Tokens are based on the multi-GPU data loaded by Containers
     for (auto& token : tokens) {
-        // TODO@Max(if the kernelData is used for stencil store it for future halo update)
-        if (token.compute() == Neon::Compute::REDUCE) {
-            const NodeId nodeId = containerId2gNodeId[containerIdx];
-            auto&        nodeMeta = m_graph().getVertexProperty(nodeId);
-            if (nodeMeta.isStencil()) {
-                NEON_THROW_UNSUPPORTED_OPTION("The skeleton does not suport container with both reduce and stencil operations.");
-            }
-            nodeMeta.setCompute(Neon::Compute::REDUCE);
-        }
-        // update the dependency state machine with the new toke.
+        // update the dependency state machine with the new token.
         // newDependencies are the detected dependencies
-        auto newDependencies = m_dataRecords().updateStatus(containerIdx, token.access(), token.uid());
-        if (newDependencies.size() == 0 &&
-            token.compute() == Neon::Compute::STENCIL) {
 
-            const size_t stencilNode = containerId2gNodeId[containerIdx];
-            auto&        nodeMeta = m_graph().getVertexProperty(stencilNode);
-            nodeMeta.setCompute(Neon::Compute::STENCIL);
+        auto newDependencies = getDataRecords().updateStatus(graphNodeUid,
+                                                             token.access(),
+                                                             token.uid());
 
-            auto newEdge = Edge::factory(token, Dependencies_e::RAW);
-            specialClosureNodes.push_back({stencilNode, newEdge});
-
-            detectedDependencies++;
-        }
         for (auto& dep : newDependencies) {
-            detectedDependencies++;
-
-            const size_t nodeid_t0 = containerId2gNodeId[dep.t0()];
-            const size_t nodeid_t1 = containerId2gNodeId[dep.t1()];
-
-            if (!m_graph().hasEdge(nodeid_t0, nodeid_t1)) {
-                auto newEdge = Edge::factory(token, dep.type());
-                m_graph().addEdge(nodeid_t0, nodeid_t1, newEdge);
-            } else {
-                auto& edgeVal = m_graph().getEdgeProperty({nodeid_t0, nodeid_t1});
-                edgeVal.append(token, dep.type());
-            }
-            if (token.compute() == Neon::Compute::STENCIL) {
-                auto& node = m_graph().getVertexProperty(nodeid_t1);
-                node.setCompute(Neon::Compute::STENCIL);
-            }
+            const auto& n0 = getGraph().helpGetGraphNode(dep.t0());
+            const auto& n1 = getGraph().helpGetGraphNode(dep.t1());
+            getGraph().addDependency(n0, n1, token);
         }
     }
 }
 
-auto MultiGpuGraph::getContainer(ContainerIdx id)
-    -> Neon::set::Container&
-{
-    return m_kContainers()[id];
-}
-
-auto MultiGpuGraph::getContainer(ContainerIdx id) const
-    -> const Neon::set::Container&
-{
-    return m_kContainers()[id];
-}
-
-
-/**
- * Helper function to close the graph with a begin and end emtpy nodes
- * @param specialClosureNodes
- */
-auto MultiGpuGraph::h_closure(const std::vector<std::tuple<size_t, Edge>>& specialClosureNodes)
-    -> void
+auto MultiXpuGraph::
+    helpParseContainer(Neon::set::Container& container)
+        -> std::vector<Neon::set::dataDependency::Token>
 {
-    // using NodeType_e = internal::userGraph::NodeType_e;
-
-    // Adding the kernel container into the graph
-    auto node = MetaNode::factory(MetaNodeType_e::HELPER, "Begin", -1);
-    m_graph().addVertex(node.nodeId(), node);
-    m_setRootNodeId(node.nodeId());
-
-    // Adding the kernel container into the graph
-    node = MetaNode::factory(MetaNodeType_e::HELPER, "End", -1);
-    m_graph().addVertex(node.nodeId(), node);
-    m_setFinalNodeId(node.nodeId());
-
-    m_graph().forEachVertex([&](size_t nodeId) {
-        if (m_graph().inEdges(nodeId).size() == 0) {
-            if (nodeId != m_rootNodeId() && nodeId != m_finalNodeId()) {
-                m_graph().addEdge(m_rootNodeId(), nodeId);
-            }
-        }
-        if (m_graph().outEdges(nodeId).size() == 0) {
-            if (nodeId != m_rootNodeId() && nodeId != m_finalNodeId()) {
-                m_graph().addEdge(nodeId, m_finalNodeId());
-            }
-        }
-    });
-
-    for (auto& specialClosureNode : specialClosureNodes) {
-        size_t node_t0 = m_rootNodeId();
-        size_t node_t1 = std::get<size_t>(specialClosureNode);
-        auto&  edgeMetaData = std::get<Edge>(specialClosureNode);
-        if (m_graph().hasEdge({node_t0, node_t1})) {
-            Edge& edge = m_graph().getEdgeProperty({node_t0, node_t1});
-            edge = edgeMetaData;
-        }
-    }
-    this->h_io2Dot("DB.dot", "");
-
-    // h_io2Dot("test.dot", "g");
-}
-
-
-auto MultiGpuGraph::h_parse(ContainerIdx kernelContainerIdx)
-    -> std::vector<DataToken_t>
-{
-    auto& container = getContainer(kernelContainerIdx);
     auto& kcInterface = container.getContainerInterface();
     auto& tokens = kcInterface.parse();
     return tokens;
 }
 
-auto MultiGpuGraph::h_io2Dot([[maybe_unused]] const std::string& fname,
-                             [[maybe_unused]] const std::string& graphName) -> void
+auto MultiXpuGraph::
+    ioToDot(const std::string& fname,
+            const std::string& graphName,
+            bool               debug) -> void
 {
-    // io2Dot(fname, graphName);
-    return;
+    getGraph().ioToDot(fname, graphName, debug);
 }
 
-auto MultiGpuGraph::io2Dot(const std::string& fname, const std::string& graphName) -> void
+auto MultiXpuGraph::
+    io2DotOriginalApp(const std::string& fname,
+                      const std::string& graphName,
+                      bool               debug) -> void
 {
-    // http://www.graphviz.org/doc/info/shapes.html
-    auto clone = m_graph();
-    m_schedulingGraph().forEachEdge([&](const DiGraphScheduling::Edge& edge) {
-        auto edgeMeta = Edge::factorySchedulingEdge();
-        clone.addEdge(edge.first, edge.second, edgeMeta);
-    });
-
-    auto vertexLabel = [&](size_t v) -> std::string {
-        if (v == m_finalNodeId()) {
-            return std::string("END");  //+ "DEBUG" + std::to_string(m_graph().getVertexProperty(v).nodeId());
-        }
-        if (v == m_rootNodeId()) {
-            return std::string("BEGIN");  // + "DEBUG" + std::to_string(m_graph().getVertexProperty(v).nodeId());
-        }
-        return clone.getVertexProperty(v).toString();
-    };
-
-    auto edgeLabel = [&](const std::pair<size_t, size_t>& edge)
-        -> std::string {
-        const auto& metaEdge = clone.getEdgeProperty(edge);
-        if (metaEdge.m_isSchedulingEdge) {
-            return "";
-        }
-        if (metaEdge.nDependencies() > 0) {
-            return metaEdge.toString();
-        }
-        return "";
-    };
-
-    auto edgeLabelProperty = [&](const std::pair<size_t, size_t>& edge)
-        -> std::string {
-        const auto& metaEdge = clone.getEdgeProperty(edge);
-        if (metaEdge.m_isSchedulingEdge) {
-            // return "style=dashed, color=\"#2A9D8F\"";
-            return "style=dashed, color=\"#F4A261\", penwidth=7";
-        }
-        return "color=\"#d9d9d9\", penwidth=7";
-    };
-
-    auto vertexLabelProperty = [&](const size_t& v) {
-        if (v == m_finalNodeId() || (v == m_rootNodeId())) {
-            return R"(shape=doublecircle, style=filled, fillcolor="#d9d9d9", color="#6c6c6c")";
-        }
-        const auto& metaNode = clone.getVertexProperty(v);
-        if (metaNode.isHu()) {
-            return R"(shape=octagon, style="rounded,filled", fillcolor="#fb8072", color="#b11605")";
-        }
-        if (metaNode.isSync()) {
-            return R"(shape=octagon, style="rounded,filled", fillcolor="#fb8072", color="#b11605")";
-        }
-
-        if (metaNode.isMap()) {
-            return R"(style=filled, fillcolor="#b3de69", color="#5f861d")";
-        }
-        if (metaNode.isReduce()) {
-            return R"(style=filled, fillcolor="#80b1d3", color="#2b5c7d")";
-        }
-        if (metaNode.isStencil()) {
-            return R"(style=filled, fillcolor="#bebada", color="#4e4683")";
-        }
-        return "";
-    };
-
-    clone.exportDotFile(fname, graphName, vertexLabel, edgeLabel, vertexLabelProperty, edgeLabelProperty);
-}
-
-auto MultiGpuGraph::io2DotOriginalApp(const std::string& fname, const std::string& graphName) -> void
-{
-    // http://www.graphviz.org/doc/info/shapes.html
-    auto& clone = m_storage->m_userAppGraph;
-
-    auto vertexLabel = [&](size_t v) -> std::string {
-        if (v == m_finalNodeId()) {
-            return std::string("END");  // + "DEBUG" + std::to_string(m_graph().getVertexProperty(v).nodeId());
-        }
-        if (v == m_rootNodeId()) {
-            return std::string("BEGIN");  // + "DEBUG" + std::to_string(m_graph().getVertexProperty(v).nodeId());
-        }
-        return clone.getVertexProperty(v).toString();
-    };
-
-    auto edgeLabel = [&](const std::pair<size_t, size_t>& edge)
-        -> std::string {
-        const auto& metaEdge = clone.getEdgeProperty(edge);
-        if (metaEdge.m_isSchedulingEdge) {
-            return "";
-        }
-        if (metaEdge.nDependencies() > 0) {
-            return metaEdge.toString();
-        }
-        return "";
-    };
-
-    auto edgeLabelProperty = [&](const std::pair<size_t, size_t>& edge)
-        -> std::string {
-        const auto& metaEdge = clone.getEdgeProperty(edge);
-        if (metaEdge.m_isSchedulingEdge) {
-            // return "style=dashed, color=\"#2A9D8F\"";
-            return "style=dashed, color=\"#F4A261\", penwidth=7";
-        }
-        return "color=\"#d9d9d9\", penwidth=7";
-    };
-
-    auto vertexLabelProperty = [&](const size_t& v) {
-        if (v == m_finalNodeId() || (v == m_rootNodeId())) {
-            return R"(shape=doublecircle, style=filled, fillcolor="#d9d9d9", color="#6c6c6c")";
-        }
-        const auto& metaNode = clone.getVertexProperty(v);
-        if (metaNode.isHu()) {
-            return R"(shape=octagon, style="rounded,filled", fillcolor="#fb8072", color="#b11605")";
-        }
-        if (metaNode.isSync()) {
-            return R"(shape=octagon, style="rounded,filled", fillcolor="#fb8072", color="#b11605")";
-        }
-
-        if (metaNode.isMap()) {
-            return R"(style=filled, fillcolor="#b3de69", color="#5f861d")";
-        }
-        if (metaNode.isReduce()) {
-            return R"(style=filled, fillcolor="#80b1d3", color="#2b5c7d")";
-        }
-        if (metaNode.isStencil()) {
-            return R"(style=filled, fillcolor="#bebada", color="#4e4683")";
-        }
-        return "";
-    };
-
-    clone.exportDotFile(fname, graphName, vertexLabel, edgeLabel, vertexLabelProperty, edgeLabelProperty);
+    getGraph().ioToDot(fname, graphName, debug);
 }
 
-auto MultiGpuGraph::h_trackNewContainer(const Neon::set::Container& container,
-                                        std::vector<size_t>&        containerId2gNodeId) -> ContainerIdx
+auto MultiXpuGraph::helpAddNewContainerToGraph(const Neon::set::Container& container) -> Neon::set::container::GraphInfo::NodeUid
 {
-    ContainerIdx kernelContainerIdx = m_kContainers().size();
-    m_kContainers().push_back(container);
-
-    // Adding the kernel container into the graph
-    auto node = MetaNode::factory(MetaNodeType_e::CONTAINER, container.getName(), kernelContainerIdx);
-    m_graph().addVertex(node.nodeId(), node);
-
-    containerId2gNodeId.push_back(node.nodeId());
-
-    return kernelContainerIdx;
+    const auto&                              graphNode = getGraph().addNode(container);
+    Neon::set::container::GraphInfo::NodeUid uid;
+    uid = graphNode.getGraphData().getUid();
+    return uid;
 }
 
-auto MultiGpuGraph::h_removeRedundantDependencies() -> void
-{
-    std::vector<std::pair<size_t, size_t>> edgesToBeRemoved;
-    m_graph().forEachVertex([&](size_t node) {
-        // Looping over all nodes
-        const auto& children = m_graph().outNeighbors(node);
-        // Checking sons. If no more than one, move to the next node
-        if (children.size() <= 1) {
-            return;
-        }
-        for (const auto& child : children) {
-            if (m_graph().inEdges(child).size() <= 1) {
-                // This child can only be reach by once father
-                // No redundant path here
-                continue;
-            }
-            bool foundRedundant = false;
-            for (const auto& sibling : children) {
-                if (sibling == child) {
-                    continue;
-                }
-                auto frontiar = m_graph().outNeighbors(sibling);
-                while (frontiar.size() != 0) {
-                    auto nextFrontiar = std::set<size_t>();
-
-                    for (const auto& eInFrintier : frontiar) {
-                        if (eInFrintier == child) {
-                            foundRedundant = true;
-                            break;
-                        } else {
-                            for (auto nextE : m_graph().outNeighbors(eInFrintier)) {
-                                nextFrontiar.insert(nextE);
-                            }
-                        }
-                    }  // end FOF
-                    if (foundRedundant) {
-                        break;
-                    }
-                    frontiar = nextFrontiar;
-                }
-                if (foundRedundant)
-                    break;
-            }
-            if (foundRedundant) {
-                edgesToBeRemoved.push_back({node, child});
-            }
-        }
-    });
-    for (const auto& toBeRemoved : edgesToBeRemoved) {
-        m_graph().removeEdge(toBeRemoved);
-    }
-}
 
-/**
- * Creates 2 nodes for
- * @param uid
- * @param edge
- * @param infoIdx
- * @param transferModeE
- * @return
- */
-auto MultiGpuGraph::h_add_hUpdateSyncNodes(size_t                      t0Node,
-                                           size_t                      t1Node,
-                                           const internal::Edge::Info& info,
-                                           Neon::set::TransferMode     transferModeE)
-    -> void
-{
-    auto getNewEdge = [&]() {
-        const bool haloUpdate = true;
-        return internal::Edge::factory(info.token, info.dependency, haloUpdate);
-    };
-
-    auto hupNode = MetaNode::haloUpdateFactory(transferModeE,
-                                               info.token.uid(),
-                                               info.token.getHaloUpdate(),
-                                               info.token.getHaloUpdatePerDevice());
-
-    m_graph().addVertex(hupNode.nodeId(), hupNode);
-
-    auto syncNode = MetaNode::syncLeftRightFactory(info.token.uid());
-    m_graph().addVertex(syncNode.nodeId(), syncNode);
-
-    size_t syncNodet0;
-    size_t syncNodet1;
-
-    if (transferModeE == Neon::set::TransferMode::put) {
-        syncNodet0 = hupNode.nodeId();
-        syncNodet1 = syncNode.nodeId();
-    } else {
-        syncNodet0 = syncNode.nodeId();
-        syncNodet1 = hupNode.nodeId();
-    }
-
-    {  // linking the two halo and sync nodes
-        auto hpSycInternlaEdge = getNewEdge();
-        m_graph().addEdge(syncNodet0, syncNodet1, hpSycInternlaEdge);
-    }
-
-    {
-        {
-            auto fromT0 = getNewEdge();
-            m_graph().addEdge(t0Node, syncNodet0, fromT0);
-        }
-        {
-            auto toT1 = getNewEdge();
-            m_graph().addEdge(syncNodet1, t1Node, toT1);
-        }
-    }
-
-    const auto& inNgh = m_schedulingGraph().inNeighbors(t1Node);
-    if (!inNgh.empty()) {
-        m_schedulingGraph().addVertex(syncNodet0);
-    }
-    for (const auto& toBeFirst : inNgh) {
-        m_schedulingGraph().addEdge(toBeFirst, syncNodet0);
-    }
-
-    for (const auto& toBeFirst : inNgh) {
-        m_schedulingGraph().removeEdge(toBeFirst, t1Node);
-    }
-    return;
-}
-
-auto MultiGpuGraph::optimizations(const Neon::skeleton::Options& options) -> void
+auto MultiXpuGraph::optimizations(const Neon::skeleton::Options& options) -> void
 {
     switch (options.occ()) {
         case Neon::skeleton::Occ::none:
@@ -468,703 +117,278 @@ auto MultiGpuGraph::optimizations(const Neon::skeleton::Options& options) -> voi
     }
 }
 
-auto MultiGpuGraph::optimizeStandardOCC(const Neon::skeleton::Options&) -> void
+auto MultiXpuGraph::optimizeStandardOCC(const Neon::skeleton::Options&) -> void
 {
-    /**
-     * Objective:
-     * a. detect all stencil nodes
-     * b. each stencil node is slipped into internal and boundary
-     * c. all the dependency must be cloned too
-     */
-    using Compute_e = Neon::Compute;
-
-    // Detects all stencil nodes
-    std::vector<size_t> stencilNodes;
-    m_graph().forEachVertex([&](size_t nodeId) {
-        const auto& node = m_graph().getVertexProperty(nodeId);
-        if (node.getCompute() == Compute_e::STENCIL) {
-            if (node.getDataView() != Neon::DataView::INTERNAL) {
-                stencilNodes.push_back(nodeId);
+    std::vector<Neon::set::container::GraphData::Uid> stencilNodeUidList;
+    getGraph().forEachNode([&](const Neon::set::container::GraphNode& graphNode) {
+        const auto type =
+            graphNode.getContainer().getContainerInterface().getContainerPatternType();
+        if (Neon::set::ContainerPatternType::stencil == type) {
+            if (Neon::DataView::STANDARD == graphNode.getScheduling().getDataView()) {
+                Neon::set::container::GraphData::Uid nodeUid = graphNode.getGraphData().getUid();
+                stencilNodeUidList.push_back(nodeUid);
             }
         }
     });
-    // Cloning each stencil node
-    for (auto&& stencilNode : stencilNodes) {
-        // Data used by the helper functions
-        const auto inEdges = m_graph().inEdges(stencilNode);
-        const auto outEdges = m_graph().outEdges(stencilNode);
-        // HELPER //////////////////////////////////////////////////////////////////////////
-        auto h_cloneStencilNode = [&](const Neon::DataView& dataView) -> size_t {
-            const auto& toBeCloned = m_graph().getVertexProperty(stencilNode);
-            auto        clone = toBeCloned.clone();
-            clone.setDataView(dataView);
-            m_graph().addVertex(clone.nodeId(), clone);
-            return clone.nodeId();
-        };
-        // HELPER //////////////////////////////////////////////////////////////////////////
-        auto h_cloneIncomingConnections = [&](size_t clone) -> void {
-            std::for_each(outEdges.begin(), outEdges.end(),
-                          [&](const DiGraph::Edge& edge) {
-                              auto clonedEdge = m_graph().getEdgeProperty(edge).clone();
-                              m_graph().addEdge(clone, edge.second, clonedEdge);
-                          });
-        };
-        // HELPER //////////////////////////////////////////////////////////////////////////
-        auto h_cloneOutgoingConnections = [&](size_t clone) -> void {
-            std::for_each(inEdges.begin(), inEdges.end(),
-                          [&](const DiGraph::Edge& edge) {
-                              auto clonedEdge = m_graph().getEdgeProperty(edge).clone();
-                              m_graph().addEdge(edge.first, clone, clonedEdge);
-                          });
-        };
-        // HELPER //////////////////////////////////////////////////////////////////////////
-        auto cloningProcess = [&](const Neon::DataView& dataView) -> NodeId {
-            NodeId cloneId = h_cloneStencilNode(dataView);
-            h_cloneIncomingConnections(cloneId);
-            h_cloneOutgoingConnections(cloneId);
-            return cloneId;
-        };
-        ////////////////////////////////////////////////////////////////////////////
-        NodeId internalNode = cloningProcess(Neon::DataView::INTERNAL);
-        NodeId boundaryNode = cloningProcess(Neon::DataView::BOUNDARY);
-        for (auto& node : {internalNode, boundaryNode}) {
-            m_schedulingGraph().hasVertex(node);
-            m_schedulingGraph().addVertex(node);
-        }
 
-        if (!m_schedulingGraph().hasEdge({boundaryNode, internalNode})) {
-            m_schedulingGraph().addEdge(internalNode, boundaryNode);
-        }
-    }
+    for (auto stencilNodeUid : stencilNodeUidList) {
+        auto& boundary_sten = getGraph().helpGetGraphNode(stencilNodeUid);
+        auto& internal_sten = getGraph().cloneNode(boundary_sten);
+
+        internal_sten.getScheduling().setDataView(Neon::DataView::INTERNAL);
+        boundary_sten.getScheduling().setDataView(Neon::DataView::BOUNDARY);
 
-    for (auto&& stencilNode : stencilNodes) {
-        m_graph().removeVertex(stencilNode);
+        getGraph().addDependency(internal_sten, boundary_sten, Neon::GraphDependencyType::scheduling);
     }
 }
 
-auto MultiGpuGraph::optimizeExtendedOCC(const Neon::skeleton::Options&) -> void
+auto MultiXpuGraph::optimizeExtendedOCC(const Neon::skeleton::Options&) -> void
 {
-
-    // Detects all stencil nodes
-    std::vector<size_t> potentialStencilNodes;
-    m_graph().forEachVertex([&](size_t nodeId) {
-        const auto& node = m_graph().getVertexProperty(nodeId);
-        if (node.getCompute() == Neon::Compute::STENCIL) {
-            if (node.getDataView() == Neon::DataView::STANDARD) {
-                potentialStencilNodes.push_back(nodeId);
+    std::vector<Neon::set::container::GraphData::Uid> stencilNodeUidList;
+    getGraph().forEachNode([&](const Neon::set::container::GraphNode& graphNode) {
+        const auto type =
+            graphNode.getContainer().getContainerInterface().getContainerPatternType();
+        if (Neon::set::ContainerPatternType::stencil == type) {
+            if (Neon::DataView::STANDARD == graphNode.getScheduling().getDataView()) {
+                Neon::set::container::GraphData::Uid nodeUid = graphNode.getGraphData().getUid();
+                stencilNodeUidList.push_back(nodeUid);
             }
         }
     });
-    std::vector<size_t> targetStencilNodes;
-
-    for (auto& potentialStencilNode : potentialStencilNodes) {
-        bool attachedToRoot = false;
-        bool proceedByMap = false;
-        m_graph().forEachInEdge(potentialStencilNode, [&](const std::pair<size_t, size_t>& edge) {
-            if (edge.first == m_rootNodeId()) {
-                attachedToRoot = true;
+
+    auto proceedingNodesAreMapOnly = [&](const Neon::set::container::GraphNode& node)
+        -> std::vector<Neon::set::container::GraphNode*> {
+        auto proceeding = this->getGraph().getProceedingGraphNodes(node);
+        for (auto preNodePtr : proceeding) {
+            if (preNodePtr->getContainer().getContainerInterface().getContainerPatternType() !=
+                Neon::set::ContainerPatternType::map) {
+                return {};
             }
-            if (!m_graph().getVertexProperty(edge.first).isStencil()) {
-                proceedByMap = true;
+            if (preNodePtr->getScheduling().getDataView() != Neon::DataView::STANDARD) {
+                return {};
             }
-        });
-        if (!attachedToRoot && proceedByMap) {
-            targetStencilNodes.push_back(potentialStencilNode);
         }
-    }
-    // HELPER //////////////////////////////////////////////////////////////////////////
-    auto h_cloneKernelNodeNode = [&](size_t node, const Neon::DataView& dataView) -> size_t {
-        const auto& toBeCloned = m_graph().getVertexProperty(node);
-        auto        clone = toBeCloned.clone();
-        clone.setDataView(dataView);
-        m_graph().addVertex(clone.nodeId(), clone);
-        return clone.nodeId();
+        return proceeding;
     };
 
-    // HELPER //////////////////////////////////////////////////////////////////////////
-    auto h_cloneOutgoingConnections = [&](std::set<std::pair<size_t, size_t>> outEdges, size_t clone) -> void {
-        std::for_each(outEdges.begin(), outEdges.end(),
-                      [&](const DiGraph::Edge& edge) {
-                          auto clonedEdge = m_graph().getEdgeProperty(edge).clone();
-                          m_graph().addEdge(clone, edge.second, clonedEdge);
-                      });
-    };
+    for (auto stencilNodeUid : stencilNodeUidList) {
+        auto proceedingNodes = proceedingNodesAreMapOnly(getGraph().helpGetGraphNode(stencilNodeUid));
 
-    // HELPER //////////////////////////////////////////////////////////////////////////
-    auto h_cloneIncomingConnections = [&](std::set<std::pair<size_t, size_t>> inEdges, size_t clone) -> void {
-        std::for_each(inEdges.begin(), inEdges.end(),
-                      [&](const DiGraph::Edge& edge) {
-                          auto clonedEdge = m_graph().getEdgeProperty(edge).clone();
-                          m_graph().addEdge(edge.first, clone, clonedEdge);
-                      });
-    };
-
-    // HELPER //////////////////////////////////////////////////////////////////////////
-    auto h_cloningProcess = [&](size_t st1, std::vector<size_t> mt0s) -> void {
-        /**
-         * st1: stencil node
-         * mt0s: set of map nodes at the previous level
-         *
-         * st1 stencil t1
-         * mto are map at t0
-         */
-        this->h_io2Dot("A.dot", "A");
-        // Cloning the stencil node
-        size_t st1_internal = h_cloneKernelNodeNode(st1, Neon::DataView::INTERNAL);
-        size_t st1_boundary = h_cloneKernelNodeNode(st1, Neon::DataView::BOUNDARY);
-        m_schedulingGraph().addVertex(st1_internal);
-        m_schedulingGraph().addVertex(st1_boundary);
-        m_schedulingGraph().addEdge(st1_internal, st1_boundary);
-
-        this->h_io2Dot("B.dot", "B");
-
-        {
-            auto inE = m_graph().inEdges(st1);
-            h_cloneIncomingConnections(inE, st1_internal);
-            h_cloneIncomingConnections(inE, st1_boundary);
-        }
-        {
-            auto outE = m_graph().outEdges(st1);
-            h_cloneOutgoingConnections(outE, st1_internal);
-            h_cloneOutgoingConnections(outE, st1_boundary);
+        if (proceedingNodes.empty()) {
+            continue;
         }
-        this->h_io2Dot("C.dot", "B");
-
-        for (auto& mt0 : mt0s) {
-            // cloning map node into boundary and internal
-            size_t mapInternal = h_cloneKernelNodeNode(mt0, Neon::DataView::INTERNAL);
-            size_t mapBoundary = h_cloneKernelNodeNode(mt0, Neon::DataView::BOUNDARY);
-            m_schedulingGraph().addVertex(mapInternal);
-            m_schedulingGraph().addVertex(mapBoundary);
-            m_schedulingGraph().addEdge(mapBoundary, mapInternal);
-
-            {
-                auto inE = m_graph().inEdges(mt0);
-                h_cloneIncomingConnections(inE, mapInternal);
-                h_cloneIncomingConnections(inE, mapBoundary);
-            }
-            this->h_io2Dot("D.dot", "B");
 
-            {
-                auto outE = m_graph().outEdges(mt0);
-                h_cloneOutgoingConnections(outE, mapInternal);
-                h_cloneOutgoingConnections(outE, mapBoundary);
-            }
+        for (auto mapNodePtr : proceedingNodes) {
+            auto& boundary_map = *mapNodePtr;
+            auto& internal_map = getGraph().cloneNode(boundary_map);
 
-            {  // the stencil arc from map_internal and stencil{internal/boundary} mast be set to map
-                for (auto& st1Target : {st1_internal, st1_boundary}) {
-                    auto& edge = m_graph().getEdgeProperty({mapInternal, st1Target});
-                    auto& infos = edge.infoMutable();
-                    for (auto& info : infos) {
-                        info.flag_discardStencilDep = true;
-                    }
-                }
-            }
+            internal_map.getScheduling().setDataView(Neon::DataView::INTERNAL);
+            boundary_map.getScheduling().setDataView(Neon::DataView::BOUNDARY);
 
-            this->h_io2Dot("E.dot", "B");
-            //            //m_graph().removeEdge({internal, st1_boundary});
-            //            //m_graph().removeEdge({boundary, st1_internal});
-            this->h_io2Dot("F.dot", "B");
-        }
-        m_graph().removeVertex(st1);
-        this->h_io2Dot("G.dot", "B");
-        for (auto& mt0 : mt0s) {
-            m_graph().removeVertex(mt0);
+            getGraph().addDependency(boundary_map, internal_map, Neon::GraphDependencyType::scheduling);
         }
-        this->h_io2Dot("H.dot", "B");
-    };
 
-    ////////////////////////////////////////////////////////////////////////////
-    auto node2Level = h_getBFSIndexes();
-    for (auto&& stencilNode : targetStencilNodes) {
-        int                 stencilNodeLevel = node2Level[stencilNode];
-        std::vector<size_t> toClone;
-        auto                inNodes = m_graph().inNeighbors(stencilNode);
-        for (const auto& inNode : inNodes) {
-            if (node2Level[inNode] == stencilNodeLevel - 1) {
-                toClone.push_back(inNode);
-            }
-        }
-        h_cloningProcess(stencilNode, toClone);
+        auto& boundary_sten = getGraph().helpGetGraphNode(stencilNodeUid);
+        auto& internal_sten = getGraph().cloneNode(boundary_sten);
+
+        internal_sten.getScheduling().setDataView(Neon::DataView::INTERNAL);
+        boundary_sten.getScheduling().setDataView(Neon::DataView::BOUNDARY);
+
+        getGraph().addDependency(internal_sten, boundary_sten, Neon::GraphDependencyType::scheduling);
     }
 }
 
-auto MultiGpuGraph::optimizeTwoWayExtendedOCC(const Neon::skeleton::Options&) -> void
+auto MultiXpuGraph::optimizeTwoWayExtendedOCC(const Neon::skeleton::Options&) -> void
 {
-
-    // Detects all stencil nodes
-    std::vector<size_t> potentialStencilNodes;
-    m_graph().forEachVertex([&](size_t nodeId) {
-        const auto& node = m_graph().getVertexProperty(nodeId);
-        if (node.getCompute() == Neon::Compute::STENCIL) {
-            if (node.getDataView() == Neon::DataView::STANDARD) {
-                potentialStencilNodes.push_back(nodeId);
+    std::vector<Neon::set::container::GraphData::Uid> stencilNodeUidList;
+    getGraph().forEachNode([&](const Neon::set::container::GraphNode& graphNode) {
+        const auto type =
+            graphNode.getContainer().getContainerInterface().getContainerPatternType();
+        if (Neon::set::ContainerPatternType::stencil == type) {
+            if (Neon::DataView::STANDARD == graphNode.getScheduling().getDataView()) {
+                Neon::set::container::GraphData::Uid nodeUid = graphNode.getGraphData().getUid();
+                stencilNodeUidList.push_back(nodeUid);
             }
         }
     });
-    std::vector<size_t> targetStencilNodes;
-
-    for (auto& potentialStencilNode : potentialStencilNodes) {
-        bool attachedToRoot = false;
-        bool attachedToFinal = false;
-        bool proceedByMap = false;
-        bool followedByMapOrDot = false;
 
-        m_graph().forEachInEdge(potentialStencilNode, [&](const std::pair<size_t, size_t>& edge) {
-            if (edge.first == m_rootNodeId()) {
-                attachedToRoot = true;
-            }
-            // only MAP front kernels can be splitted
-            if (m_graph().getVertexProperty(edge.first).isMap()) {
-                proceedByMap = true;
+    auto proceedingNodesAreMapOnly = [&](const Neon::set::container::GraphNode& node)
+        -> std::vector<Neon::set::container::GraphNode*> {
+        auto proceeding = this->getGraph().getProceedingGraphNodes(node);
+        for (auto preNodePtr : proceeding) {
+            if (preNodePtr->getContainer().getContainerInterface().getContainerPatternType() !=
+                Neon::set::ContainerPatternType::map) {
+                return {};
             }
-        });
-        m_graph().forEachOutEdge(potentialStencilNode, [&](const std::pair<size_t, size_t>& edge) {
-            if (edge.second == m_finalNodeId()) {
-                attachedToFinal = true;
+            if (preNodePtr->getScheduling().getDataView() != Neon::DataView::STANDARD) {
+                return {};
             }
-
-            // only MAP or DOT (-> not STENCIL) back kernels can be splitted
-            if (!m_graph().getVertexProperty(edge.second).isStencil()) {
-                followedByMapOrDot = true;
-            }
-        });
-        if (!attachedToRoot && !attachedToFinal && proceedByMap && followedByMapOrDot) {
-            targetStencilNodes.push_back(potentialStencilNode);
         }
-    }
-    // HELPER //////////////////////////////////////////////////////////////////////////
-    auto h_cloneKernelNodeNode = [&](size_t node, const Neon::DataView& dataView) -> size_t {
-        const auto& toBeCloned = m_graph().getVertexProperty(node);
-        auto        clone = toBeCloned.clone();
-        clone.setDataView(dataView);
-        m_graph().addVertex(clone.nodeId(), clone);
-        return clone.nodeId();
-    };
-
-    // HELPER //////////////////////////////////////////////////////////////////////////
-    auto h_cloneOutgoingConnections = [&](std::set<std::pair<size_t, size_t>> outEdges, size_t clone) -> void {
-        std::for_each(outEdges.begin(), outEdges.end(),
-                      [&](const DiGraph::Edge& edge) {
-                          auto clonedEdge = m_graph().getEdgeProperty(edge).clone();
-                          m_graph().addEdge(clone, edge.second, clonedEdge);
-                      });
-    };
-
-    // HELPER //////////////////////////////////////////////////////////////////////////
-    auto h_cloneIncomingConnections = [&](std::set<std::pair<size_t, size_t>> inEdges, size_t clone) -> void {
-        std::for_each(inEdges.begin(), inEdges.end(),
-                      [&](const DiGraph::Edge& edge) {
-                          auto clonedEdge = m_graph().getEdgeProperty(edge).clone();
-                          m_graph().addEdge(edge.first, clone, clonedEdge);
-                      });
+        return proceeding;
     };
-
-    // HELPER //////////////////////////////////////////////////////////////////////////
-    auto h_cloningProcess = [&](const std::set<size_t>& frontNodes,
-                                size_t                  StencilNode,
-                                const std::set<size_t>& backNodes) -> void {
-        std::set<size_t> backNodesInternal;
-        std::set<size_t> backNodesBoundary;
-        std::set<size_t> frontMapInternal;
-
-        /**
-         * st1: stencil node
-         * mt0s: set of map nodes at the previous level
-         *
-         * st1 stencil t1
-         * mto are map at t0
-         */
-        this->h_io2Dot("A.dot", "A");
-
-        // Cloning from the back toward the front
-        for (auto& mapBack : backNodes) {
-            // cloning map node into boundary and internal
-            size_t mapInternal = h_cloneKernelNodeNode(mapBack, Neon::DataView::INTERNAL);
-            size_t mapBoundary = h_cloneKernelNodeNode(mapBack, Neon::DataView::BOUNDARY);
-
-            backNodesInternal.insert(mapInternal);
-            backNodesBoundary.insert(mapBoundary);
-
-            m_schedulingGraph().addVertex(mapInternal);
-            m_schedulingGraph().addVertex(mapBoundary);
-
-            const auto& metaNode = m_graph().getVertexProperty(mapBack);
-            if (metaNode.isReduce()) {
-                m_graph().addEdge(mapInternal, mapBoundary);
-            } else {
-                m_schedulingGraph().addEdge(mapInternal, mapBoundary);
+    auto subsequentNodesAreMapOnly = [&](const Neon::set::container::GraphNode& node)
+        -> std::vector<Neon::set::container::GraphNode*> {
+        auto subsequent = this->getGraph().getSubsequentGraphNodes(node);
+        for (auto postNodePtr : subsequent) {
+            if (postNodePtr->getContainer().getContainerInterface().getContainerPatternType() !=
+                    Neon::set::ContainerPatternType::map &&
+                postNodePtr->getContainer().getContainerInterface().getContainerPatternType() !=
+                    Neon::set::ContainerPatternType::reduction) {
+                return {};
             }
-
-
-            {
-                auto inE = m_graph().inEdges(mapBack);
-                h_cloneIncomingConnections(inE, mapInternal);
-                h_cloneIncomingConnections(inE, mapBoundary);
+            if (postNodePtr->getScheduling().getDataView() != Neon::DataView::STANDARD) {
+                return {};
             }
-            this->h_io2Dot("D.cloning.back.dot", "B");
-
-            {
-                auto outE = m_graph().outEdges(mapBack);
-                h_cloneOutgoingConnections(outE, mapInternal);
-                h_cloneOutgoingConnections(outE, mapBoundary);
-            }
-
-            this->h_io2Dot("E.cloning.back.dot", "B");
         }
+        return subsequent;
+    };
 
-        for (auto& mapBack : backNodes) {
-            m_graph().removeVertex(mapBack);
-        }
-
-
-        for (auto& mapFront : frontNodes) {
-            // cloning map node into boundary and internal
-            size_t mapBoundary = h_cloneKernelNodeNode(mapFront, Neon::DataView::BOUNDARY);
-            size_t mapInternal = h_cloneKernelNodeNode(mapFront, Neon::DataView::INTERNAL);
-
-            frontMapInternal.insert(mapInternal);
+    for (auto stencilNodeUid : stencilNodeUidList) {
+        auto proceedingNodes = proceedingNodesAreMapOnly(getGraph().helpGetGraphNode(stencilNodeUid));
+        auto subsequentNodes = subsequentNodesAreMapOnly(getGraph().helpGetGraphNode(stencilNodeUid));
 
-            m_schedulingGraph().addVertex(mapInternal);
-            m_schedulingGraph().addVertex(mapBoundary);
-            m_schedulingGraph().addEdge(mapBoundary, mapInternal);
+        if (proceedingNodes.empty() || subsequentNodes.empty()) {
+            continue;
+        }
 
-            {
-                auto inE = m_graph().inEdges(mapFront);
-                h_cloneIncomingConnections(inE, mapInternal);
-                h_cloneIncomingConnections(inE, mapBoundary);
-            }
-            this->h_io2Dot("D.cloning.front.dot", "B");
+        for (auto mapNodePtr : proceedingNodes) {
+            auto& boundary_map = *mapNodePtr;
+            auto& internal_map = getGraph().cloneNode(boundary_map);
 
-            {
-                auto outE = m_graph().outEdges(mapFront);
-                h_cloneOutgoingConnections(outE, mapInternal);
-                h_cloneOutgoingConnections(outE, mapBoundary);
-            }
+            internal_map.getScheduling().setDataView(Neon::DataView::INTERNAL);
+            boundary_map.getScheduling().setDataView(Neon::DataView::BOUNDARY);
 
-            this->h_io2Dot("E.cloning.front.dot", "B");
-        }
-        for (auto& mapFront : frontNodes) {
-            m_graph().removeVertex(mapFront);
+            getGraph().addDependency(boundary_map, internal_map, Neon::GraphDependencyType::scheduling);
         }
 
-        // Cloning the stencil node
-        size_t st1_internal = h_cloneKernelNodeNode(StencilNode, Neon::DataView::INTERNAL);
-        size_t st1_boundary = h_cloneKernelNodeNode(StencilNode, Neon::DataView::BOUNDARY);
-        m_schedulingGraph().addVertex(st1_internal);
-        m_schedulingGraph().addVertex(st1_boundary);
-        m_schedulingGraph().addEdge(st1_internal, st1_boundary);
+        auto& boundary_stencil = getGraph().helpGetGraphNode(stencilNodeUid);
+        auto& internal_stencil = getGraph().cloneNode(boundary_stencil);
 
-        this->h_io2Dot("B.dot", "B");
+        internal_stencil.getScheduling().setDataView(Neon::DataView::INTERNAL);
+        boundary_stencil.getScheduling().setDataView(Neon::DataView::BOUNDARY);
 
-        {
-            auto inE = m_graph().inEdges(StencilNode);
-            h_cloneIncomingConnections(inE, st1_internal);
-            h_cloneIncomingConnections(inE, st1_boundary);
-        }
-        {
-            auto outE = m_graph().outEdges(StencilNode);
-            h_cloneOutgoingConnections(outE, st1_internal);
-            h_cloneOutgoingConnections(outE, st1_boundary);
-        }
+        getGraph().addDependency(internal_stencil, boundary_stencil, Neon::GraphDependencyType::scheduling);
 
-        for (auto& backNodeIternal : backNodesInternal) {
-            m_schedulingGraph().addVertex(backNodeIternal);
-            m_schedulingGraph().addVertex(st1_boundary);
-            m_schedulingGraph().addEdge(backNodeIternal, st1_boundary);
-        }
-        this->h_io2Dot("C.dot", "B");
+        for (auto mapOrReduceNodePtr : subsequentNodes) {
+            if (mapOrReduceNodePtr->getContainer().getContainerInterface().getContainerPatternType() == Neon::set::ContainerPatternType::map) {
+                auto& boundary_map = *mapOrReduceNodePtr;
+                auto& internal_map = getGraph().cloneNode(boundary_map);
 
-        m_graph().removeVertex(StencilNode);
+                internal_map.getScheduling().setDataView(Neon::DataView::INTERNAL);
+                boundary_map.getScheduling().setDataView(Neon::DataView::BOUNDARY);
 
+                getGraph().addDependency(internal_map, boundary_stencil, Neon::GraphDependencyType::scheduling);
 
-        for (const auto& node : backNodesBoundary) {
-            m_graph().removeEdge(st1_internal, node);
-        }
-        for (const auto& node : backNodesInternal) {
-            m_graph().removeEdge(st1_boundary, node);
-        }
-        {  // the stencil arc from map_internal and stencil{internal/boundary} mast be set to map
-            for (auto& st1Target : {st1_internal, st1_boundary}) {
-                for (auto& mapInternal : frontMapInternal) {
-                    auto& edge = m_graph().getEdgeProperty({mapInternal, st1Target});
-                    auto& infos = edge.infoMutable();
-                    for (auto& info : infos) {
-                        info.flag_discardStencilDep = true;
-                    }
-                }
+                getGraph().removeDependency(getGraph().getDependency(internal_stencil, boundary_map));
+                getGraph().removeDependency(getGraph().getDependency(boundary_stencil, internal_map));
             }
-        }
+            if (mapOrReduceNodePtr->getContainer().getContainerInterface().getContainerPatternType() == Neon::set::ContainerPatternType::reduction) {
+                auto& boundary_red = *mapOrReduceNodePtr;
+                auto& internal_red = getGraph().cloneNode(boundary_red);
 
+                internal_red.getScheduling().setDataView(Neon::DataView::INTERNAL);
+                boundary_red.getScheduling().setDataView(Neon::DataView::BOUNDARY);
 
-        this->h_io2Dot("HHH.dot", "B");
-    };
+                getGraph().addDependency(internal_red, boundary_stencil, Neon::GraphDependencyType::scheduling);
 
-    ////////////////////////////////////////////////////////////////////////////
-    auto node2Level = h_getBFSIndexes();
-    for (auto&& stencilNode : targetStencilNodes) {
-        int              stencilNodeLevel = node2Level[stencilNode];
-        std::set<size_t> frontToClone;
-        std::set<size_t> backToClone;
-
-        auto inNodes = m_graph().inNeighbors(stencilNode);
-        for (const auto& inNode : inNodes) {
-            if (node2Level[inNode] == stencilNodeLevel - 1) {
-                frontToClone.insert(inNode);
-            }
-        }
+                getGraph().removeDependency(getGraph().getDependency(internal_stencil, boundary_red));
+                getGraph().removeDependency(getGraph().getDependency(boundary_stencil, internal_red));
 
-        auto outNodes = m_graph().outNeighbors(stencilNode);
-        for (const auto& outNode : outNodes) {
-            if (outNode != m_finalNodeId()) {
-                backToClone.insert(outNode);
+                getGraph().addDependency(internal_red, boundary_red, Neon::GraphDependencyType::data);
             }
         }
-        h_cloningProcess(frontToClone, stencilNode, backToClone);
     }
 }
 
-/**
- * Breadth First Traversal
- * @param f
- * @return
- */
-auto MultiGpuGraph::h_BFT(std::function<void(int                     level,
-                                             const std::set<size_t>& nodes)> f)
-    -> void
-{
-    std::set<size_t>              visited;
-    std::vector<std::set<size_t>> levels;
-    levels.push_back(std::set<size_t>());
-
-    size_t level = 0;
-    levels[level].insert(m_rootNodeId());
 
-    auto h_recordNewNode = [&](size_t node, size_t nodeLevel) -> bool {
-        if (!visited.insert(node).second) {
-            return false;
-        }
-        levels.at(nodeLevel).insert(node);
-        return true;
-    };
+auto MultiXpuGraph::communications(const Neon::skeleton::Options& skeletonOptions) -> void
+{
+    if (getSetCardinality() == 1) {
+        return;
+    }
 
-    while (level < levels.size() && levels[level].size() > 0) {
-        levels.push_back(std::set<size_t>());
-        for (const auto& n : levels[level]) {
-            auto nghSet = m_graph().neighbors(n);
-            for (const auto& ngh : nghSet) {
-                h_recordNewNode(ngh, level + 1);
+    // List all dependencies related to stencil operations
+    std::vector<const Neon::set::container::GraphDependency*> stencilTypeDependencies;
+    getGraph().forEachDependency([&](const Neon::set::container::GraphDependency& dep) {
+        if (dep.getType() != Neon::GraphDependencyType::scheduling) {
+            if (dep.hasStencilDependency()) {
+                auto dw = dep.getDestinationNode(getGraph()).getScheduling().getDataView();
+                if (Neon::DataView::INTERNAL != dw) {
+                    stencilTypeDependencies.push_back(&dep);
+                }
             }
         }
-        level++;
-    }
-
-    // Reset level for visiting
-    level = 0;
-    while (level < levels.size() && levels[level].size() > 0) {
-        f(int(level), levels[level]);
-        level++;
-    }
-    return;
-}
+    });
 
-auto MultiGpuGraph::h_getBFSIndexes() -> std::unordered_map<size_t, int>
-{
-    std::unordered_map<size_t, int> map;
+    std::vector<const Neon::set::container::GraphDependency*> toBeRemoved;
 
-    h_BFT([&](int                     level,
-              const std::set<size_t>& nodes) {
-        for (const auto& n : nodes) {
-            map[n] = level;
-        }
-    });
 
-    return map;
-}
+    for (auto depPtr : stencilTypeDependencies) {
+        const auto& dep = *depPtr;
+        const auto  rawEdge = dep.getRawEdge();
+        auto        nodeA = getGraph().helpGetGraphNode(rawEdge.first);
+        auto        nodeB = getGraph().helpGetGraphNode(rawEdge.second);
 
-auto MultiGpuGraph::getDiGraph() -> DiGraph&
-{
-    return m_graph();
-}
-auto MultiGpuGraph::getSchedulingDiGraph() -> DiGraphScheduling&
-{
-    return m_schedulingGraph();
-}
-//    auto fuseMaps(const Neon::skeleton::Options_t& options) -> void
-//    {
-//        // BFS visit
-//        std::vector<int> frontiar;
-//        m_graph().forEachOutEdge(m_rootNodeId, [&](const std::pair<size_t, size_t>& edge) {
-//            frontiar.push_back(edge.second);
-//        });
-//
-//        size_t frontiarParserIdx = 0;
-//
-//        /**
-//         * Return -1 if there are no condition for a fusion
-//         * Otherwise, it returns the node to fuse with
-//         */
-//        auto h_conditionForFusion = [&](const size_t n0) -> int64_t {
-//            if (m_graph().outEdgesCount(n0) != 1) {
-//                return -1;
-//            }
-//            const size_t n1 = m_graph().outEdges(n0).begin()->second;
-//            if (m_graph().inEdgesCount(n1) != 1) {
-//                return -1;
-//            }
-//            if(m_graph().getVertexProperty(n1).isStencil()){
-//                return -1;
-//            }
-//            return n1;
-//        };
-//
-//        auto h_fuse= [&](const size_t n0, const size_t n1){
-//            //1. create a fused kernel container
-//        };
-//
-//        while (frontiarParserIdx < frontiar.size()) {
-//            size_t nodeId = frontiar[frontiarParserIdx];
-//            if (m_graph().outEdges(nodeId).size() == 1 &&) {
-//                // a. Fuse
-//
-//                // b. update nodeId to the new node
-//            }
-//            // c. continue with BFS
-//        }
-//    }
-
-auto MultiGpuGraph::addSyncAndMemoryTransfers(const Neon::skeleton::Options& options) -> void
-{
-    if (m_setCardinality() == 1) {
-        return;
-    }
+        const Neon::set::container::GraphDependency::Tokens& tokens = dep.getTokens();
+        int                                                  numNewNodes = 0;
 
-    // Detects all stencil nodes
-    std::vector<size_t> stencilNodes;
-    m_graph().forEachVertex([&](size_t nodeId) {
-        const auto& node = m_graph().getVertexProperty(nodeId);
-        if (node.getCompute() == Neon::Compute::STENCIL) {
-            if (node.getDataView() != Neon::DataView::INTERNAL) {
-                stencilNodes.push_back(nodeId);
+        for (const auto& token : tokens) {
+            if (token.compute() == Neon::Compute::STENCIL) {
+                auto container = token.getDataTransferContainer(skeletonOptions.transferMode());
+                numNewNodes += getGraph().expandAndMerge(nodeA, container, nodeB, true);
             }
         }
-    });
-    for (auto&& stencilNode : stencilNodes) {
-
-        const auto             inEdges = m_graph().inEdges(stencilNode);
-        int                    detectedStencilEdges = 0;
-        [[maybe_unused]] auto& nodeInfo = m_graph().getVertexProperty(stencilNode);
-
-
-        // m_graph().forEachInEdge(stencilNode,
-        // We are using a copy of the inEdges,
-        // so we can modify the graph without any issue
-        std::for_each(inEdges.begin(), inEdges.end(),
-                      [&](const DiGraph::Edge& edge) {
-                          bool  visited = false;
-                          auto& edgeP = m_graph().getEdgeProperty(edge);
-                          auto& targetProperty = edgeP.infoMutable();
-
-                          // remove_if only  move elements at the end of the vector
-                          auto end = std::remove_if(targetProperty.begin(),
-                                                    targetProperty.end(),
-                                                    [&](Edge::Info& info) -> bool {
-                                                        if (info.token.compute() == Neon::Compute::STENCIL && !info.flag_discardStencilDep) {
-                                                            visited = true;
-                                                            detectedStencilEdges++;
-                                                            h_add_hUpdateSyncNodes(edge.first,
-                                                                                   edge.second,
-                                                                                   info,
-                                                                                   options.transferMode());
-
-                                                            return true;
-                                                        } else {
-                                                            visited = true;
-                                                            return false;
-                                                        }
-                                                    });
-
-                          targetProperty.erase(end, targetProperty.end());
-                          if (detectedStencilEdges > 0 && m_graph().getEdgeProperty(edge).nDependencies() == 0) {
-                              m_graph().removeEdge(edge);
-                          }
-                      });
-
-        if (detectedStencilEdges != 1) {
-            NEON_THROW_UNSUPPORTED_OPTION("Only one stencil in field is supported for now");
+
+        auto schedulingDepOfB = this->getGraph().getProceedingGraphNodes(nodeB, {GraphDependencyType::scheduling});
+        for (auto nodePtr : schedulingDepOfB) {
+            const auto& dependency = getGraph().getDependency(*nodePtr, nodeB);
+            toBeRemoved.push_back(&dependency);
         }
     }
+
+    for (auto depPtr : toBeRemoved) {
+        getGraph().removeDependency(*depPtr);
+    }
 }
 
-auto MultiGpuGraph::checkCoherency() -> void
+auto MultiXpuGraph::fixingDependenciesWithBeginNode() -> void
 {
-    // Detects all stencil nodes
-    std::vector<size_t> stencilNodes;
-    m_graph().forEachVertex([&](size_t nodeId) {
-        const auto& node = m_graph().getVertexProperty(nodeId);
-        if (node.getCompute() == Neon::Compute::STENCIL) {
-            if (m_setCardinality() == 1) {
-                m_graph().getVertexProperty(nodeId).setAsCoherent();
-                return;
-            }
+    auto& beginNode = getGraph().getBeginNode();
+    auto  nodesAfterBeginPtrVec = getGraph().getSubsequentGraphNodes(beginNode);
 
-            if (node.getDataView() == Neon::DataView::INTERNAL) {
-                m_graph().getVertexProperty(nodeId).setAsCoherent();
-            } else {
-                stencilNodes.push_back(nodeId);
+    for (auto nodePtr : nodesAfterBeginPtrVec) {
+        const auto& tokens = nodePtr->getContainer().getContainerInterface().getTokens();
+        for (const auto& token : tokens) {
+            const auto computeType = token.compute();
+            if (Neon::Compute::STENCIL == computeType) {
+                // 1. remove current dependency between begin and target node
+                auto& dep = getGraph().getMutableDependency(beginNode, *nodePtr);
+                dep.addToken(token);
             }
         }
-    });
-    for (auto&& stencilNode : stencilNodes) {
-        bool isMemoryCoherent = true;
-        m_graph().forEachInEdge(stencilNode, [&](const DiGraph::Edge& edge) -> void {
-            const auto& e = m_graph().getEdgeProperty(edge);
-            for (const auto& i : e.info()) {
-                if (i.isStencil() && !i.isHu()) {
-                    isMemoryCoherent = false;
-                }
-            }
-        });
-        if (isMemoryCoherent) {
-            m_graph().getVertexProperty(stencilNode).setAsCoherent();
-        }
     }
 }
 
-auto MultiGpuGraph::resetLinearContinuousIndexing() -> void
+MultiXpuGraph::
+    MultiXpuGraph()
 {
-    m_storage->m_resetLinearContinuousIndexingCounter = 0;
-    m_graph().forEachVertex([&](size_t nodeId) {
-        auto& node = m_graph().getVertexProperty(nodeId);
-        node.setLinearContinuousIndex(m_storage->m_resetLinearContinuousIndexingCounter);
-        m_storage->m_resetLinearContinuousIndexingCounter++;
-    });
+    mStorage = std::make_shared<Storage>();
 }
 
-auto MultiGpuGraph::getLinearContinuousIndexingCounter() -> size_t
+auto MultiXpuGraph::
+    computeScheduling() -> void
 {
-    return m_storage->m_resetLinearContinuousIndexingCounter;
+    getGraph().runtimePreSet(Neon::Backend::mainStreamIdx);
 }
 
-/**
- * Access methods to members
- * @return
- */
-auto MultiGpuGraph::rootNodeId() const -> const size_t&
+auto MultiXpuGraph::
+    execute(const Neon::skeleton::Options& options)
+        -> void
 {
-    return m_rootNodeId();
-}
-
-/**
- * Access methods to members
- * @return
- */
-auto MultiGpuGraph::finalNodeId() const -> const size_t&
-{
-    return m_finalNodeId();
-}
-MultiGpuGraph::MultiGpuGraph()
-{
-    m_storage = std::make_shared<Storage>();
+    if (options.executor() == Neon::skeleton::Executor::ompAtNodeLevel) {
+        this->getGraph().helpExecuteWithOmpAtNodeLevel(Neon::Backend::mainStreamIdx);
+    } else {
+        NEON_DEV_UNDER_CONSTRUCTION("");
+    };
 }
 }  // namespace Neon::skeleton::internal
\ No newline at end of file
diff --git a/libNeonSkeleton/src/skeleton/internal/multiGpuGraph/edge.cpp b/libNeonSkeleton/src/skeleton/internal/multiGpuGraph/edge.cpp
deleted file mode 100644
index f12c1580..00000000
--- a/libNeonSkeleton/src/skeleton/internal/multiGpuGraph/edge.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-#include "Neon/skeleton/internal/multiGpuGraph/Edge.h"
-
-#include <memory>
-namespace Neon {
-namespace skeleton {
-namespace internal {
-
-
-std::atomic<uint64_t> edgeCounter_g{0};
-
-Edge::Edge(size_t             edgeId,
-               const DataToken_t& dataToken,
-               Dependencies_e     dependency,
-               bool               haloUp)
-    : m_edgeId(edgeId)
-{
-    m_dependencies.emplace_back(dataToken, dependency, haloUp);
-}
-
-Edge::Edge(size_t edgeId,
-               bool   isSchedulingEdge)
-    : m_edgeId(edgeId), m_isSchedulingEdge(isSchedulingEdge)
-{
-    if(isSchedulingEdge == false){
-        NEON_THROW_UNSUPPORTED_OPTION("");
-    }
-}
-
-auto Edge::factory(const DataToken_t& dataToken,
-                     Dependencies_e     type,
-                     bool               haloUp) -> Edge
-{
-    size_t id = (edgeCounter_g++);
-    Edge   edge(id, dataToken, type, haloUp);
-    return edge;
-}
-
-auto Edge::factorySchedulingEdge() -> Edge
-{
-    size_t id = (edgeCounter_g++);
-    Edge   edge(id, true);
-    return edge;
-}
-
-auto Edge::edgeId() const -> size_t
-{
-    return m_edgeId;
-}
-auto Edge::nDependencies() const -> size_t
-{
-    return m_dependencies.size();
-}
-
-auto Edge::info() const -> const std::vector<Info>&
-{
-    return m_dependencies;
-}
-auto Edge::infoMutable() -> std::vector<Info>&
-{
-    return m_dependencies;
-}
-
-auto Edge::append(const DataToken_t& dataToken,
-                    Dependencies_e     dType) -> void
-{
-    m_dependencies.push_back({dataToken, dType});
-}
-auto Edge::toString() const -> std::string
-{
-    std::string intro = "Dependencies: \\l";  // + std::to_string(nDependencies());
-    for (auto& i : info()) {
-        intro = intro + i.toString();
-    }
-    return intro;
-}
-auto Edge::clone() const -> Edge
-{
-    size_t id = (edgeCounter_g++);
-    Edge   clone(*this);
-    clone.m_edgeId = id;
-    return clone;
-}
-
-}  // namespace internal
-}  // namespace skeleton
-}  // namespace Neon
\ No newline at end of file
diff --git a/libNeonSkeleton/src/skeleton/internal/multiGpuGraph/node.cpp b/libNeonSkeleton/src/skeleton/internal/multiGpuGraph/node.cpp
deleted file mode 100644
index e6714edb..00000000
--- a/libNeonSkeleton/src/skeleton/internal/multiGpuGraph/node.cpp
+++ /dev/null
@@ -1,279 +0,0 @@
-#include "Neon/skeleton/internal/multiGpuGraph/MetaNode.h"
-
-namespace Neon {
-namespace skeleton {
-namespace internal {
-
-std::atomic<uint64_t> nodeCounter_g{0};
-
-auto MetaNodeType_te::toString(MetaNodeType_te::e type) -> std::string
-{
-    switch (type) {
-        case SYNC_LEFT_RIGHT: {
-            return "SYNC_LEFT_RIGHT";
-        }
-        case BARRIER: {
-            return "BARRIER";
-        }
-        case HALO_UPDATE: {
-            return "HALO_UPDATE";
-        }
-        case CONTAINER: {
-            return "KERNEL_CONTAINER";
-        }
-        case HELPER: {
-            return "HELPER";
-        }
-        case UNDEFINED: {
-            return "UNDEFINED";
-        }
-        default: {
-            NEON_THROW_UNSUPPORTED_OPTION("");
-        }
-    }
-}
-
-namespace depTools = Neon::set::internal::dependencyTools;
-MetaNode::MetaNode(size_t                         nodeId,
-                   const std::string&             name,
-                   MetaNodeType_e                 nodeType,
-                   depTools::KernelContainerIdx_t kernelContainerIdx,
-                   const Neon::DataView&          dataView)
-    : m_nodeId(nodeId),
-      m_name(name),
-      m_nodeType(nodeType),
-      m_kernelContainerIdx(kernelContainerIdx),
-      m_dataView(dataView)
-{
-}
-
-auto MetaNode::factory(MetaNodeType_e                 nodeType,
-                       const std::string&             name,
-                       depTools::KernelContainerIdx_t kernelContainerIdx,
-                       const Neon::DataView&          dataView) -> MetaNode
-{
-    MetaNode node(++nodeCounter_g, name, nodeType, kernelContainerIdx, dataView);
-    return node;
-}
-
-auto MetaNode::nodeId()
-    const -> NodeId
-{
-    return m_nodeId;
-}
-
-auto MetaNode::name()
-    const -> const std::string&
-{
-    return m_name;
-}
-
-auto MetaNode::nodeType()
-    const -> MetaNodeType_e
-{
-    return m_nodeType;
-}
-
-auto MetaNode::getContainerId()
-    const -> depTools::KernelContainerIdx_t
-{
-    return m_kernelContainerIdx;
-}
-
-auto MetaNode::toString() const -> std::string
-{
-    switch (m_nodeType) {
-        case MetaNodeType_e::SYNC_LEFT_RIGHT: {
-            std::string res =  //"NodeGeneric ID " + std::to_string(nodeId()) +
-                std::string("Left-Right Sync\n\n");
-            //            std::string ret = "LR_SYNC";
-            //            ret += " " + std::to_string(m_uid);
-            //            ret += " DEBUG " + std::to_string(m_nodeId);
-            return res;
-        }
-        case MetaNodeType_e::BARRIER: {
-            return "BARRIER";
-        }
-
-        case MetaNodeType_e::HALO_UPDATE: {
-            std::string res =  //"NodeGeneric ID " + std::to_string(nodeId()) +
-                std::string("Halo Update") +
-                "\n\nTransferMode: " + Neon::set::TransferModeUtils::toString(m_transferMode) + "\\l";
-            //                              std::string ret = "HU " +
-            //                                                Neon::set::Transfer_t::toString(m_transferMode) +
-            //                                                " " + std::to_string(m_uid);
-            //            ret += " DEBUG " + std::to_string(m_nodeId);
-
-            return res;
-        }
-        case MetaNodeType_e::CONTAINER: {
-            std::string res = "" + name() +
-                              //"\n\nNode ID " + std::to_string(nodeId()) +
-                              "\\n\\nPattern: " + Neon::ComputeUtils::toString(m_compute) +
-                              "\\lDataView: " + Neon::DataViewUtil::toString(m_dataView) + "\\l";
-            //            if (isStencil() && m_hasCoherentInput) {
-            //                res += "\\l coherent";
-            //            }
-            //            if (isStencil() && !m_hasCoherentInput) {
-            //                res += "\\l NOT coherent";
-            //            }
-            //            res += "\\l";
-            //            res += " DEBUG " + std::to_string(m_nodeId);
-
-            return res;
-        }
-        case MetaNodeType_e::HELPER: {
-            return "HELPER";
-        }
-        case MetaNodeType_e::UNDEFINED: {
-            return "UNDEFINED";
-        }
-        default: {
-            NEON_THROW_UNSUPPORTED_OPTION("");
-        }
-    }
-}  // namespace userGraph
-
-auto MetaNode::setDataView(const Neon::DataView& dv) -> void
-{
-    m_dataView = dv;
-}
-
-auto MetaNode::getDataView() const -> Neon::DataView
-{
-    return m_dataView;
-}
-
-auto MetaNode::setCompute(const Neon::Compute& c) -> void
-{
-    m_compute = c;
-}
-
-auto MetaNode::getCompute() const -> Neon::Compute
-{
-    return m_compute;
-}
-
-auto MetaNode::haloUpdateFactory(Neon::set::TransferMode                                             tm,
-                                 const Neon::set::MultiDeviceObjectUid&                              dataUids,
-                                 std::function<void(Neon::set::HuOptions& opt)>                      hu,
-                                 const std::function<void(Neon::SetIdx, Neon::set::HuOptions& opt)>& huPerDevice) -> MetaNode
-{
-    MetaNode node(++nodeCounter_g, "HaloUpdate", MetaNodeType_e::HALO_UPDATE, -1);
-    node.m_transferMode = tm;
-    node.m_uid = dataUids;
-    node.m_hu = hu;
-    node.m_huPerDevice = huPerDevice;
-    return node;
-}
-
-auto MetaNode::syncLeftRightFactory(const Neon::set::MultiDeviceObjectUid& dataUids) -> MetaNode
-{
-    MetaNode node(++nodeCounter_g, "syncLeftRigh", MetaNodeType_e::SYNC_LEFT_RIGHT, -1);
-    node.m_uid = dataUids;
-    return node;
-}
-
-auto MetaNode::setAsCoherent() -> void
-{
-    m_hasCoherentInput = true;
-}
-auto MetaNode::isStencil() const -> bool
-{
-    return m_nodeType == MetaNodeType_e::CONTAINER && m_compute == Neon::Compute::STENCIL;
-}
-auto MetaNode::isMap() const -> bool
-{
-    return m_nodeType == MetaNodeType_e::CONTAINER && m_compute == Neon::Compute::MAP;
-}
-
-auto MetaNode::isSync() const -> bool
-{
-    return m_nodeType == MetaNodeType_e::SYNC_LEFT_RIGHT;
-}
-
-auto MetaNode::isHu() const -> bool
-{
-    return m_nodeType == MetaNodeType_e::HALO_UPDATE;
-}
-
-auto MetaNode::isReduce() const -> bool
-{
-    return m_nodeType == MetaNodeType_e::CONTAINER && m_compute == Neon::Compute::REDUCE;
-}
-
-auto MetaNode::clone() const -> MetaNode
-{
-    MetaNode clone(*this);
-    clone.m_nodeId = ++nodeCounter_g;
-    return clone;
-}
-
-auto MetaNode::cudaGraphHandles_t::init(MetaNodeType_e nodeType, int numDevices) -> void
-{
-    m_data = std::vector<Neon::set::DataSet<cudaGraphNode_t>>(2);
-
-    m_data[0] = Neon::set::DataSet<cudaGraphNode_t>(numDevices);
-    m_data[1] = Neon::set::DataSet<cudaGraphNode_t>(numDevices);
-
-    switch (nodeType) {
-        case MetaNodeType_e::CONTAINER:
-        case MetaNodeType_e::HELPER:
-            // NodeGeneric that is papped to only one CUDA graph node
-            m_first = 0;
-            m_last = 0;
-            return;
-        case MetaNodeType_e::HALO_UPDATE:
-        case MetaNodeType_e::SYNC_LEFT_RIGHT:
-            // NodeGeneric that is papped to a sequence of nodes.
-            // We track only the first and the last.
-            // first() is used to creates dependencies BEFORE this node
-            // last() is used to create dependencies AFTER this node
-            m_first = 0;
-            m_last = 1;
-            return;
-        default: {
-            return;
-        }
-    }
-}
-
-auto MetaNode::cudaGraphHandles_t::first() -> Neon::set::DataSet<cudaGraphNode_t>&
-{
-    return m_data.at(m_first);
-}
-
-auto MetaNode::cudaGraphHandles_t::last() -> Neon::set::DataSet<cudaGraphNode_t>&
-{
-    return m_data.at(m_last);
-}
-
-
-auto MetaNode::hu(Neon::set::HuOptions& opt) -> void
-{
-    m_hu(opt);
-}
-
-auto MetaNode::hu(Neon::SetIdx setIdx, Neon::set::HuOptions& opt) -> void
-{
-    m_huPerDevice(setIdx, opt);
-}
-
-auto MetaNode::transferMode() const
-    -> Neon::set::TransferMode
-{
-    return m_transferMode;
-}
-
-auto MetaNode::setLinearContinuousIndex(size_t id) -> void
-{
-    m_linearContinuousIndex = id;
-}
-auto MetaNode::getLinearContinuousIndex() const -> size_t
-{
-    return m_linearContinuousIndex;
-}
-
-}  // namespace internal
-}  // namespace skeleton
-}  // namespace Neon
\ No newline at end of file
diff --git a/libNeonSkeleton/src/skeleton/internal/streamScheduler.cpp b/libNeonSkeleton/src/skeleton/internal/streamScheduler.cpp
deleted file mode 100644
index dfbb868b..00000000
--- a/libNeonSkeleton/src/skeleton/internal/streamScheduler.cpp
+++ /dev/null
@@ -1,1146 +0,0 @@
-#include "Neon/skeleton/internal/StreamScheduler.h"
-#include <unordered_set>
-#include "Neon/set/syncrhonizations/event_LR_barrier.h"
-
-namespace Neon::skeleton::internal {
-
-#ifdef NEON_USE_NVTX
-#include <nvToolsExt.h>
-#endif
-
-StreamScheduler::MetaNodeExtended::SchedulingInfo::SchedulingInfo(size_t       nodeId_,
-                                                                  size_t       extendedNodeIdx_,
-                                                                  ContainerIdx cIdx)
-{
-    nodeId = nodeId_;
-    metaNodeExtendedIdx = extendedNodeIdx_;
-    containerIdx = cIdx;
-}
-
-StreamScheduler::MetaNodeExtended::SchedulingInfo::SchedulingInfo()
-{
-    nodeId = 0;
-    metaNodeExtendedIdx = 0;
-    containerIdx = 0;
-    streamIdx = -1;
-    setEventIdx = -1;
-}
-
-auto StreamScheduler::init(Neon::Backend& bk, MultiGpuGraph& multiGpuGraph) -> void
-{
-    m_storage = std::make_shared<Storage>(bk, multiGpuGraph);
-    m_storage->m_metaNodeExtendedList = std::vector<MetaNodeExtended>(
-        multiGpuGraph.getLinearContinuousIndexingCounter());
-
-    initCleanRedundantSync();
-    initCreateLevels();
-    initScheduleStreams();
-    initScheduleEvents();
-    initCleanRedundantEvents();
-    initLinearisationList();
-    initExecutionOrder();
-}
-
-auto StreamScheduler::initCleanRedundantSync() -> void
-{
-    if (m_storage->useFullBarrierOnAllStreamsAtTheEnd) {
-        {  // Removing events from root nodes as we have a full barrier at the end
-            NodeId           root = m_storage->m_graph.rootNodeId();
-            auto&            diGraph = m_storage->m_graph.getDiGraph();
-            std::set<size_t> rootChildList = diGraph.outNeighbors(root);
-
-            for (auto& rootChild : rootChildList) {
-                const auto& rootChildMeta = h_getMetaNode(rootChild);
-                if (rootChildMeta.isSync()) {
-                    auto& schedulingrGraph = m_storage->m_graph.getSchedulingDiGraph();
-                    if (diGraph.outNeighbors(rootChild).size() != 1) {
-                        continue;
-                    }
-                    NodeId      huNode = *diGraph.outNeighbors(rootChild).begin();
-                    const auto& huMeta = diGraph.getVertexProperty(huNode);
-                    if (!huMeta.isHu()) {
-                        continue;
-                    }
-                    // we are in a sutuation of a SYNC follow by a HALO Up.
-                    if (schedulingrGraph.hasVertex(rootChild)) {
-                        if (!schedulingrGraph.hasVertex(huNode)) {
-                            schedulingrGraph.addVertex(huNode);
-                        }
-                        const auto& inSchedulingEdges = schedulingrGraph.inEdges(rootChild);
-                        for (auto& inSchedulingEdge : inSchedulingEdges) {
-                            schedulingrGraph.addEdge(inSchedulingEdge.first, huNode);
-                        }
-                        schedulingrGraph.removeVertex(rootChild);
-                    }
-                    for (auto& neighbour : diGraph.neighbors(rootChild)) {
-                        diGraph.addEdge(root, neighbour);
-                    }
-                    diGraph.removeVertex(rootChild);
-                }
-            }
-        }
-    }
-}
-
-auto StreamScheduler::initCleanRedundantEvents() -> void
-{
-    if (m_storage->useFullBarrierOnAllStreamsAtTheEnd) {
-        {  // Removing events from root nodes as we have a full barrier at the end
-            NodeId root = m_storage->m_graph.rootNodeId();
-            auto&  metaNodeExtendedRoot = h_getMetaNodeExtended(root);
-            metaNodeExtendedRoot.schedulingInfo.setEventIdx = -1;
-
-            auto&            diGraph = m_storage->m_graph.getDiGraph();
-            std::set<size_t> rootChildList = diGraph.outNeighbors(root);
-
-            for (auto& rootChild : rootChildList) {
-                auto& metaNodeExtended = h_getMetaNodeExtended(rootChild);
-                metaNodeExtended.schedulingInfo.waitEventIdxList = std::unordered_set<EventIdx>();
-            }
-        }
-    }
-
-    // Checking if we can remove the last sync all
-    NodeId           endNode = m_storage->m_graph.finalNodeId();
-    auto&            diGraph = m_storage->m_graph.getDiGraph();
-    std::set<size_t> endNodeChildList = diGraph.inNeighbors(endNode);
-    if (endNodeChildList.size() == 1) {
-        bool allReduceNodes = true;
-        for (auto& endNodeChild : endNodeChildList) {
-            const auto& metaNode = m_storage->m_graph.getDiGraph().getVertexProperty(endNodeChild);
-            if (!metaNode.isReduce()) {
-                allReduceNodes = false;
-            } else {
-                auto& metaNodeExtendedChild = h_getMetaNodeExtended(endNodeChild);
-                metaNodeExtendedChild.schedulingInfo.setEventIdx = -1;
-            }
-        }
-        if (allReduceNodes) {
-            m_storage->canEndNodeLastBarrierBeOptimizedOut = true;
-        }
-    }
-}
-
-
-/**
- * Returns number of levels
- * @return
- */
-auto StreamScheduler::nLevels() -> int
-{
-    return static_cast<int>(m_storage->m_levels.size());
-}
-
-/**
- *
- * @return
- */
-auto StreamScheduler::addNewLevel() -> LevelIdx
-{
-    m_storage->m_levels.emplace_back();
-    return LevelIdx(m_storage->m_levels.size() - 1);
-}
-
-auto StreamScheduler::getLevel(int levelIdx) -> Level&
-{
-    return m_storage->m_levels.at(levelIdx);
-}
-
-auto StreamScheduler::resetLevels() -> void
-{
-    m_storage->m_levels.clear();
-}
-
-/**
- *
- */
-auto StreamScheduler::getStreamFlags() -> std::vector<int>&
-{
-    return m_storage->m_streamFlags;
-}
-
-/**
- *
- * @return
- */
-auto StreamScheduler::resetStreamFlags() -> void
-{
-    for (auto& flag : m_storage->m_streamFlags) {
-        flag = 0;
-    }
-}
-
-auto StreamScheduler::h_getMetaNodeExtended(size_t id) -> MetaNodeExtended&
-{
-    auto& meta = m_storage->m_graph.getDiGraph().getVertexProperty(id);
-    return m_storage->m_metaNodeExtendedList.at(meta.getLinearContinuousIndex());
-};
-
-auto StreamScheduler::h_getMetaNode(NodeId id) -> MetaNode&
-{
-    auto& meta = m_storage->m_graph.getDiGraph().getVertexProperty(id);
-    return meta;
-};
-
-auto StreamScheduler::h_getMetaNodeExtended(MetaNode& id) -> MetaNodeExtended&
-{
-    return m_storage->m_metaNodeExtendedList.at(id.getLinearContinuousIndex());
-}
-
-/**
- *
- * @param nodeId
- */
-auto StreamScheduler::registerNodeToLastLevel(NodeId nodeId) -> void
-{
-    const size_t levelTarget = m_storage->m_levels.size() - 1;
-    this->m_storage->m_levels.at(levelTarget).push_back(nodeId);
-}
-
-auto StreamScheduler::initCreateLevels() -> void
-{
-    auto& diGraph = m_storage->m_graph.getDiGraph();
-
-    // Set the dependency counter of each node
-    diGraph.forEachVertex([&](NodeId nodeId) {
-        auto&     metaNodeExtended = h_getMetaNodeExtended(nodeId);
-        const int nDependencies = int(diGraph.inEdgesCount(nodeId));
-        metaNodeExtended.blockingDependencies = nDependencies;
-    });
-
-    std::unordered_set<NodeId> frontier;
-    const NodeId               beginning = m_storage->m_graph.rootNodeId();
-    frontier.insert(beginning);
-    // h_dissolveDataDependencies(beginning);
-
-    // Walking the graph following a BFS with constraints
-    int level = -1;
-    while (!frontier.empty()) {
-        addNewLevel();
-        level++;
-        // printf("Level %d \n", level);
-        std::unordered_set<NodeId> nextFrontier;
-        std::unordered_set<NodeId> nodeToApplyDissolveTo;
-        for (auto& frontierNodeId : frontier) {
-            {  // 2. If the node has still some dependencies that are not satisfy,
-                // don't process the node now ad add it to the next frontier
-                // printf("frontierNodeId %ld \n", frontierNodeId);
-                auto& frontierMetaNode = h_getMetaNode(frontierNodeId);
-                auto  frontierMetaNodeExtended = h_getMetaNodeExtended(frontierMetaNode);
-                if (frontierMetaNodeExtended.blockingDependencies != 0) {
-                    // There are some data dependencies still active before processing this node
-                    // Moving the node to the next frontier.
-                    nextFrontier.insert(frontierNodeId);
-                    // std:: cout<< "frontierMetaNode " << frontierNodeId <<" postpone" <<std::endl;
-                    continue;
-                }
-            }
-            {  // 3. Populating the next frontier
-                std::set<size_t> childList = diGraph.outNeighbors(frontierNodeId);
-                for (auto& child : childList) {
-                    nextFrontier.insert(child);
-                }
-            }
-            {  // 4. Upgrade information in the metaNodeExtended
-                auto& metaNode = h_getMetaNode(frontierNodeId);
-                auto& metaNodeExtended = h_getMetaNodeExtended(frontierNodeId);
-                metaNodeExtended.schedulingInfo = MetaNodeExtended::SchedulingInfo(frontierNodeId,
-                                                                                   metaNode.getLinearContinuousIndex(),
-                                                                                   metaNode.getContainerId());
-            }
-            {  // 5. Register the target frontier node to the last level
-                registerNodeToLastLevel(frontierNodeId);
-                nodeToApplyDissolveTo.insert(frontierNodeId);
-            }
-        }
-
-        // Update all the dependencies
-        for (auto& frontierNode : nodeToApplyDissolveTo) {
-            h_dissolveDataDependencies(diGraph, frontierNode);
-        }
-        // h_print_depcountALL();
-        frontier = nextFrontier;
-    }
-}
-
-auto StreamScheduler::initStreamFlags() -> int
-{
-    int maxNstream = 0;
-    for (int i = 0; i < nLevels(); i++) {
-        Level& level = getLevel(i);
-        maxNstream = int(level.size()) > maxNstream ? int(level.size()) : maxNstream;
-    }
-    m_storage->m_streamFlags = std::vector<int>(maxNstream, 0);
-    m_storage->m_bk.setAvailableStreamSet(maxNstream);
-    return maxNstream;
-}
-
-auto StreamScheduler::initScheduleStreams() -> void
-{
-    auto& diGraph = m_storage->m_graph.getDiGraph();
-
-    NodeId startNodeId = m_storage->m_graph.rootNodeId();
-    NodeId endNodeId = m_storage->m_graph.finalNodeId();
-
-    auto h_setStream = [this](NodeId nodeId, int streamId) {
-        auto& metaNode = h_getMetaNodeExtended(nodeId);
-        metaNode.schedulingInfo.streamIdx = streamId;
-    };
-
-    initStreamFlags();
-    auto& streamFlags = getStreamFlags();
-
-    for (int i = 0; i < nLevels(); i++) {
-        resetStreamFlags();
-        Level&              level = getLevel(i);
-        std::vector<NodeId> leftToMatch;
-        //
-        for (auto it = level.begin(), end = level.end(); it != end; ++it) {
-            NodeId nodeId = *it;
-
-            if (nodeId == endNodeId || nodeId == startNodeId) {
-                h_setStream(nodeId, 0);
-                continue;
-            }
-
-            if (h_getMetaNodeExtended(nodeId).schedulingInfo.isHaloUpdateNode) {
-                // Halo nodes are associated to the same stream as the parent node
-                continue;
-            }
-            auto parents = diGraph.inNeighbors(nodeId);
-            bool matchDone = false;
-            // Try to match the stream id with one of the parent nodes
-            for (auto& parent : parents) {
-                const auto& parentMetaNodeExtended = h_getMetaNodeExtended(parent);
-                int         parentStreamId = parentMetaNodeExtended.schedulingInfo.streamIdx;
-
-                // checking if at this level the stream of the parent is still available
-                const bool available = (streamFlags[parentStreamId] == 0);
-                if (available) {
-                    streamFlags[parentStreamId] = 1;
-                    h_setStream(nodeId, parentStreamId);
-                    matchDone = true;
-                    break;
-                }
-            }
-            if (matchDone)
-                continue;
-            // nodes left to match
-            // no halo node is added to this vector
-            leftToMatch.push_back(nodeId);
-        }
-        for (auto& toMatch : leftToMatch) {
-            bool matchFound = false;
-            for (int streamIdx = 0; streamIdx < static_cast<int>(streamFlags.size()); streamIdx++) {
-                const bool available = streamFlags[streamIdx] == 0;
-                if (available) {
-                    streamFlags[streamIdx] = 1;
-                    h_setStream(toMatch, streamIdx);
-                    matchFound = true;
-                    break;
-                }
-            }
-            if (!matchFound) {
-                NEON_THROW_UNSUPPORTED_OPTION("");
-            }
-        }
-    }
-}
-
-auto StreamScheduler::initScheduleEvents() -> void
-{
-    int eventCounter = 0;
-
-    auto h_waitEvent = [this, &eventCounter](NodeId nodeId) -> EventIdx {
-        auto& metaNode = h_getMetaNodeExtended(nodeId);
-        if (metaNode.schedulingInfo.setEventIdx == -1) {
-            metaNode.schedulingInfo.setEventIdx = eventCounter;
-            eventCounter++;
-        }
-        return metaNode.schedulingInfo.setEventIdx;
-    };
-
-    auto h_barrierLREvent = [&eventCounter](MetaNodeExtended& metaNodeExtended) -> void {
-        if (metaNodeExtended.schedulingInfo.barrierLR == -1) {
-            metaNodeExtended.schedulingInfo.barrierLR = eventCounter;
-            eventCounter++;
-        }
-    };
-
-    auto h_setEvent = [this](NodeId nodeId, EventIdx eventIdx) -> void {
-        auto& metaNode = h_getMetaNodeExtended(nodeId);
-        metaNode.schedulingInfo.waitEventIdxList.insert(eventIdx);
-    };
-
-    auto h_addEventsIfNeeded = [this, &h_waitEvent, &h_setEvent, &h_barrierLREvent](NodeId nodeId) -> void {
-        const auto&           diGraph = m_storage->m_graph.getDiGraph();
-        auto&                 metaNodeExtended = h_getMetaNodeExtended(nodeId);
-        const Neon::StreamIdx nodeStreamIdx = metaNodeExtended.schedulingInfo.streamIdx;
-        auto&                 parentNodeIdSet = diGraph.inNeighbors(nodeId);
-
-        for (auto& parentNodeId : parentNodeIdSet) {
-            auto                  parentMetaNode = h_getMetaNodeExtended(parentNodeId);
-            const Neon::StreamIdx parentStreamIdx = parentMetaNode.schedulingInfo.streamIdx;
-            if (parentStreamIdx != nodeStreamIdx) {
-                EventIdx eventIdx = h_waitEvent(parentNodeId);
-                h_setEvent(nodeId, eventIdx);
-            }
-        }
-        {  // If the hode is a LR barrier, then we need to book an extra event
-            auto nodeMeta = h_getMetaNode(nodeId);
-            if (nodeMeta.nodeType() == MetaNodeType_te::SYNC_LEFT_RIGHT) {
-                h_barrierLREvent(metaNodeExtended);
-            }
-            if (nodeMeta.nodeType() == MetaNodeType_te::BARRIER) {
-                NEON_THROW_UNSUPPORTED_OPTION("");
-            }
-        }
-    };
-
-    for (int i = 0; i < nLevels(); i++) {
-        Level& level = getLevel(i);
-        for (auto it = level.begin(), end = level.end(); it != end; ++it) {
-            NodeId nodeId = *it;
-            h_addEventsIfNeeded(nodeId);
-        }
-    }
-
-    m_storage->m_bk.setAvailableUserEvents(eventCounter);
-}
-
-auto StreamScheduler::initLinearisationList() -> void
-{
-
-    std::vector<NodeId>& linear = m_storage->m_linearization;
-    for (int i = 0; i < nLevels(); i++) {
-        Level& level = getLevel(i);
-        for (auto it = level.begin(), end = level.end(); it != end; ++it) {
-            NodeId            nodeId = *it;
-            MetaNodeExtended& metaNodeExtended = h_getMetaNodeExtended(nodeId);
-            int               schedulingOrder = int(linear.size());
-            metaNodeExtended.schedulingInfo.schedulingOrder = schedulingOrder;
-            linear.push_back(nodeId);
-        }
-    }
-}
-
-#if 0
-    auto StreamScheduler::initExecutionOrder() -> void
-    {
-        // Extract a linear indexing of all the nodes
-        const std::vector<NodeId>& linear = m_storage->m_linearization;
-        // Aliasing m_executionOrder with variable order
-        std::vector<NodeId>& order = m_storage->m_executionOrder;
-
-        // A bool map to track nodes that were already processed
-        std::vector<bool> alreadyProceed(linear.size(), false);
-
-        // Aliasing: the scheduling graph from m_graph
-        const auto& schedulingGraph = m_storage->m_graph.getSchedulingDiGraph();
-
-        // Lambda to extract all nodes that come before nodeId
-        // in the SCHEDULING graph
-        auto findSchedulingExecutionDep = [schedulingGraph](NodeId nodeId) -> std::set<NodeId> {
-            if (schedulingGraph.hasVertex(nodeId)) {
-                const auto& inNhg = schedulingGraph.inNeighbors(nodeId);
-                return inNhg;
-            }
-            return std::set<NodeId>();
-        };
-
-        // Looping over all the nodes based on a linearized index.
-        // There is no specific order in the indexing
-        for (size_t i = 0; i < linear.size(); i++) {
-            NodeId   nodeId = linear[i];
-            MetaNode metaNode = h_getMetaNode(nodeId);
-            if (alreadyProceed[metaNode.getLinearContinuousIndex()]) {
-                continue;
-            }
-            const auto& SchedulingDeps = findSchedulingExecutionDep(nodeId);
-            for (const auto& schedulingDepNode : SchedulingDeps) {
-                const auto& depMeta = h_getMetaNode(schedulingDepNode);
-                if (!alreadyProceed[depMeta.getLinearContinuousIndex()]) {
-                    order.push_back(schedulingDepNode);
-                    alreadyProceed[depMeta.getLinearContinuousIndex()] = true;
-                }
-            }
-            order.push_back(nodeId);
-            alreadyProceed[metaNode.getLinearContinuousIndex()] = true;
-        }
-
-        if (linear.size() != order.size()) {
-            NEON_THROW_UNSUPPORTED_OPTION("");
-        }
-
-        for (size_t i = 0; i < order.size(); i++) {
-            NodeId            nodeId = order[i];
-            MetaNodeExtended& metaNodeExtended = h_getMetaNodeExtended(nodeId);
-            metaNodeExtended.schedulingInfo.schedulingOrder = static_cast<int>(i);
-        }
-    }
-#else
-
-
-auto StreamScheduler::initExecutionOrder() -> void
-{
-    // Extract a linear indexing of all the nodes
-    // const std::vector<NodeId>& linear = m_storage->m_linearization;
-    // Aliasing m_executionOrder with variable order
-    std::vector<NodeId>& order = m_storage->m_executionOrder;
-
-
-    auto dataAndSchedulingGraph = m_storage->m_graph.getDiGraph();
-    {
-        const auto& schedulingGraph = m_storage->m_graph.getSchedulingDiGraph();
-        for (auto& edge : schedulingGraph.edges()) {
-            if (!dataAndSchedulingGraph.hasEdge(edge)) {
-                dataAndSchedulingGraph.addEdge(edge.first, edge.second);
-            }
-        }
-    }
-
-    // Set the dependency counter of each node
-    dataAndSchedulingGraph.forEachVertex([&](NodeId nodeId) {
-        auto&     metaNodeExtended = h_getMetaNodeExtended(nodeId);
-        const int nDependencies = int(dataAndSchedulingGraph.inEdgesCount(nodeId));
-        metaNodeExtended.blockingDependencies = nDependencies;
-    });
-
-    std::unordered_set<NodeId> frontier;
-    const NodeId               beginning = m_storage->m_graph.rootNodeId();
-    frontier.insert(beginning);
-
-    // Reseting Levels;
-    resetLevels();
-
-    // Walking the graph following a BFS with constraints
-    int level = -1;
-    while (!frontier.empty()) {
-        addNewLevel();
-        level++;
-        // printf("Level %d \n", level);
-        std::unordered_set<NodeId> nextFrontier;
-        std::unordered_set<NodeId> nodeToApplyDissolveTo;
-        for (auto& frontierNodeId : frontier) {
-            {  // 2. If the node has still some dependencies that are not satisfy,
-                // don't process the node now ad add it to the next frontier
-                // printf("frontierNodeId %ld \n", frontierNodeId);
-                auto& frontierMetaNode = h_getMetaNode(frontierNodeId);
-                auto  frontierMetaNodeExtended = h_getMetaNodeExtended(frontierMetaNode);
-                if (frontierMetaNodeExtended.blockingDependencies != 0) {
-                    // There are some data dependencies still active before processing this node
-                    // Moving the node to the next frontier.
-                    nextFrontier.insert(frontierNodeId);
-                    // std:: cout<< "frontierMetaNode " << frontierNodeId <<" postpone" <<std::endl;
-                    continue;
-                }
-            }
-            {  // 3. Populating the next frontier
-                std::set<size_t> childList = dataAndSchedulingGraph.outNeighbors(frontierNodeId);
-                for (auto& child : childList) {
-                    nextFrontier.insert(child);
-                }
-            }
-            {  // 5. Register the target frontier node to the last level
-                registerNodeToLastLevel(frontierNodeId);
-                nodeToApplyDissolveTo.insert(frontierNodeId);
-            }
-        }
-
-        // Update all the dependencies
-        for (auto& frontierNode : nodeToApplyDissolveTo) {
-            h_dissolveDataDependencies(dataAndSchedulingGraph, frontierNode);
-        }
-        // h_print_depcountALL();
-        frontier = nextFrontier;
-    }
-    for (int i = 0; i < nLevels(); i++) {
-        Level& lev = getLevel(i);
-        for (auto it = lev.begin(), end = lev.end(); it != end; ++it) {
-            NodeId nodeId = *it;
-            order.push_back(nodeId);
-        }
-    }
-}
-
-#endif
-
-
-auto StreamScheduler::helpRunOmpAtNodeLevel() -> void
-{
-    for (auto& nodeId : m_storage->m_executionOrder) {
-#ifdef NEON_USE_NVTX
-        const auto nvtxName = helpNvtxName(nodeId);
-        nvtxRangePush(nvtxName.c_str());
-#endif
-        MetaNodeExtended      metaNodeExtended = h_getMetaNodeExtended(nodeId);
-        const Neon::StreamIdx streamIdx = metaNodeExtended.schedulingInfo.streamIdx;
-        const EventIdx        eventIdx = metaNodeExtended.schedulingInfo.setEventIdx;
-        for (const auto& eventToBeWaited : metaNodeExtended.schedulingInfo.waitEventIdxList) {
-            if (nodeId == m_storage->m_graph.finalNodeId()) {
-                continue;
-            }
-            helpWaitForEventCompletion(streamIdx, eventToBeWaited);
-        }
-
-        helpRun(nodeId, streamIdx);
-        if (eventIdx != -1 && nodeId != m_storage->m_graph.finalNodeId()) {
-            helpEnqueueEvent(streamIdx, eventIdx);
-        }
-        if (nodeId == m_storage->m_graph.finalNodeId()) {
-            if (!m_storage->canEndNodeLastBarrierBeOptimizedOut) {
-                m_storage->m_bk.syncAll();
-            }
-        }
-#ifdef NEON_USE_NVTX
-        nvtxRangePop();
-#endif
-    }
-}
-
-auto StreamScheduler::helpRunOmpAtGraphLevel() -> void
-{
-    const int nNodes = int(m_storage->m_executionOrder.size());
-
-    for (int setIdx = 0; setIdx < m_storage->m_bk.devSet().setCardinality(); setIdx++) {
-        for (int a = 0; a < nNodes; a++) {
-            auto& nodeId = m_storage->m_executionOrder[a];
-
-#ifdef NEON_USE_NVTX
-            const auto nvtxName = helpNvtxName(nodeId);
-            nvtxRangePush(nvtxName.c_str());
-#endif
-            MetaNodeExtended      metaNodeExtended = h_getMetaNodeExtended(nodeId);
-            const Neon::StreamIdx streamIdx = metaNodeExtended.schedulingInfo.streamIdx;
-            const EventIdx        eventIdx = metaNodeExtended.schedulingInfo.setEventIdx;
-            for (const auto& eventToBeWaited : metaNodeExtended.schedulingInfo.waitEventIdxList) {
-                if (nodeId == m_storage->m_graph.finalNodeId()) {
-                    continue;
-                }
-                helpWaitForEventCompletion(setIdx, streamIdx, eventToBeWaited);
-            }
-
-            helpRun(setIdx, nodeId, streamIdx);
-            if (eventIdx != -1 && nodeId != m_storage->m_graph.finalNodeId()) {
-                helpEnqueueEvent(setIdx, streamIdx, eventIdx);
-            }
-            if (nodeId == m_storage->m_graph.finalNodeId()) {
-                if (!m_storage->canEndNodeLastBarrierBeOptimizedOut) {
-                    m_storage->m_bk.syncAll();
-                }
-            }
-#ifdef NEON_USE_NVTX
-            nvtxRangePop();
-#endif
-        }
-    }
-}
-auto StreamScheduler::run(const Neon::skeleton::Options& options) -> void
-{
-    if (Neon::skeleton::Executor::ompAtNodeLevel == options.executor()) {
-#ifdef NEON_USE_NVTX
-        nvtxRangePush("Skeleton Iteration - ompAtNodeLevel");
-#endif
-        helpRunOmpAtNodeLevel();
-#ifdef NEON_USE_NVTX
-        nvtxRangePop();
-#endif
-        return;
-    }
-
-    if (Neon::skeleton::Executor::ompAtGraphLevel == options.executor()) {
-#ifdef NEON_USE_NVTX
-        nvtxRangePush("Skeleton Iteration - ompAtGraphLevel");
-#endif
-        helpRunOmpAtGraphLevel();
-#ifdef NEON_USE_NVTX
-        nvtxRangePop();
-#endif
-        return;
-    }
-    NEON_THROW_UNSUPPORTED_OPTION("No supported Executor option.");
-}
-
-auto StreamScheduler::helpRun(NodeId nodeId, Neon::StreamIdx streamIdx) -> void
-{
-    MetaNode& metaNode = h_getMetaNode(nodeId);
-
-
-    switch (metaNode.nodeType()) {
-        case MetaNodeType_te::CONTAINER: {
-
-            ContainerIdx containerIdx = metaNode.getContainerId();
-            auto&        container = m_storage->m_graph.getContainer(containerIdx);
-            container.run(streamIdx, metaNode.getDataView());
-            return;
-        }
-        case MetaNodeType_te::SYNC_LEFT_RIGHT: {
-            // Neon::set::Event_LR_barrier::sync(m_storage->m_bk, streamIdx, h_getMetaNodeExtended(nodeId).schedulingInfo.barrierLR);
-            m_storage->m_bk.sync(streamIdx);
-            return;
-        }
-        case MetaNodeType_te::HALO_UPDATE: {
-            const bool           startWithBarrier = false;
-            Neon::set::HuOptions huOptions(metaNode.transferMode(), startWithBarrier, streamIdx);
-            metaNode.hu(huOptions);
-            return;
-        }
-        case MetaNodeType_te::HELPER: {
-            return;
-        }
-        case MetaNodeType_te::BARRIER:
-        case MetaNodeType_te::UNDEFINED: {
-            NEON_THROW_UNSUPPORTED_OPTION("");
-        }
-    }
-}
-
-auto StreamScheduler::helpRun(Neon::SetIdx setIdx, NodeId nodeId, Neon::StreamIdx streamIdx) -> void
-{
-    MetaNode& metaNode = h_getMetaNode(nodeId);
-
-
-    switch (metaNode.nodeType()) {
-        case MetaNodeType_te::CONTAINER: {
-
-            ContainerIdx containerIdx = metaNode.getContainerId();
-            auto&        container = m_storage->m_graph.getContainer(containerIdx);
-            container.run(setIdx, streamIdx, metaNode.getDataView());
-            return;
-        }
-        case MetaNodeType_te::SYNC_LEFT_RIGHT: {
-            // Neon::set::Event_LR_barrier::sync(m_storage->m_bk, streamIdx, h_getMetaNodeExtended(nodeId).schedulingInfo.barrierLR);
-            m_storage->m_bk.sync(setIdx, streamIdx);
-            return;
-        }
-        case MetaNodeType_te::HALO_UPDATE: {
-            const bool           startWithBarrier = false;
-            Neon::set::HuOptions huOptions(metaNode.transferMode(), startWithBarrier, streamIdx);
-            metaNode.hu(setIdx, huOptions);
-            return;
-        }
-        case MetaNodeType_te::HELPER: {
-            return;
-        }
-        case MetaNodeType_te::BARRIER:
-        case MetaNodeType_te::UNDEFINED: {
-            NEON_THROW_UNSUPPORTED_OPTION("");
-        }
-    }
-}
-
-auto StreamScheduler::helpNvtxName(NodeId nodeId) -> std::string
-{
-    MetaNode& metaNode = h_getMetaNode(nodeId);
-    switch (metaNode.nodeType()) {
-        case MetaNodeType_te::CONTAINER: {
-
-            ContainerIdx containerIdx = metaNode.getContainerId();
-            auto&        container = m_storage->m_graph.getContainer(containerIdx);
-            std::string  name = container.getName() + "_" + Neon::DataViewUtil::toString(metaNode.getDataView());
-            return name;
-        }
-        case MetaNodeType_te::SYNC_LEFT_RIGHT: {
-            // Neon::set::Event_LR_barrier::sync(m_storage->m_bk, streamIdx, h_getMetaNodeExtended(nodeId).schedulingInfo.barrierLR);
-            return "LeftRightSync";
-        }
-        case MetaNodeType_te::HALO_UPDATE: {
-            return "Halo Update";
-        }
-        case MetaNodeType_te::HELPER: {
-            return "HELPER";
-        }
-        case MetaNodeType_te::BARRIER:
-        case MetaNodeType_te::UNDEFINED:
-        default: {
-            NEON_THROW_UNSUPPORTED_OPTION("");
-        }
-    }
-}
-
-
-auto StreamScheduler::helpWaitForEventCompletion(StreamIdx streamIdx, Neon::EventIdx eventIdx) -> void
-{
-    auto& bk = m_storage->m_bk;
-    bk.waitEventOnStream(eventIdx, streamIdx);
-}
-
-auto StreamScheduler::helpEnqueueEvent(StreamIdx streamIdx, Neon::EventIdx eventIdx) -> void
-{
-    auto& bk = m_storage->m_bk;
-    bk.pushEventOnStream(eventIdx, streamIdx);
-}
-
-auto StreamScheduler::helpWaitForEventCompletion(Neon::SetIdx setIdx, StreamIdx streamIdx, Neon::EventIdx eventIdx) -> void
-{
-    auto& bk = m_storage->m_bk;
-    bk.waitEventOnStream(setIdx, eventIdx, streamIdx);
-}
-
-auto StreamScheduler::helpEnqueueEvent(Neon::SetIdx setIdx, StreamIdx streamIdx, Neon::EventIdx eventIdx) -> void
-{
-    auto& bk = m_storage->m_bk;
-    bk.pushEventOnStream(setIdx, eventIdx, streamIdx);
-}
-
-#if 0
-    auto StreamScheduler::io2Dot(const std::string& fname, const std::string& graphName) -> void
-    {
-        auto clone = m_storage->m_graph.getDiGraph();
-        m_storage->m_graph.getSchedulingDiGraph().forEachEdge([&](const MultiGpuGraph::DiGraphScheduling::Edge& edge) {
-            auto edgeMeta = Edge_t::factorySchedulingEdge();
-            clone.addEdge(edge.first, edge.second, edgeMeta);
-        });
-
-        auto& mGpuGraph = m_storage->m_graph;
-
-        // HELPER //////////////////////////////////////////////////////////////////////////
-        auto vertexLabel = [&](NodeId nodeId) -> std::string {
-            auto& metaNodeExtended = h_getMetaNodeExtended(nodeId);
-
-            auto h_intro = [&]() -> std::string {
-                return std::string("Scheduling info: \\l- Scheduling ID ") + std::to_string(metaNodeExtended.schedulingInfo.schedulingOrder) + "\\l";
-            };
-
-            auto h_eventWaitString = [&]() -> std::string {
-                std::string ret;
-                if (metaNodeExtended.schedulingInfo.waitEventIdxList.size() == 0) {
-                    ret += "- No waiting\\l";
-                } else {
-                    ret += "- Waiting events:";
-                    for (auto& e : metaNodeExtended.schedulingInfo.waitEventIdxList) {
-                        ret += " " + std::to_string(e);
-                    }
-                    ret += "\\l";
-                }
-                return ret;
-            };
-
-            auto h_streamString = [&]() -> std::string {
-                return "- Stream " + std::to_string(metaNodeExtended.schedulingInfo.streamIdx) + "\\l";
-            };
-
-            [[maybe_unused]] auto h_barrierString = [&]() -> std::string {
-                if (metaNodeExtended.schedulingInfo.barrierLR != -1) {
-                    return "- LR Event " + std::to_string(metaNodeExtended.schedulingInfo.barrierLR) + "\\l";
-                    ;
-                }
-                return "";
-            };
-
-            auto h_eventRegisterString = [&]() -> std::string {
-                if (metaNodeExtended.schedulingInfo.setEventIdx != -1) {
-                    return "- Registering Event " + std::to_string(metaNodeExtended.schedulingInfo.setEventIdx) + "\\l";
-                    ;
-                }
-                return "";
-            };
-
-            if (nodeId == mGpuGraph.finalNodeId()) {
-                return std::string("END (") + std::to_string(nodeId) + ")\n\n" + h_intro() + h_eventWaitString() + h_streamString() + "\\l";
-            }
-            if (nodeId == mGpuGraph.rootNodeId()) {
-                return std::string("START(") + std::to_string(nodeId) + ")\n\n" + h_intro() + h_eventWaitString() + h_streamString() + h_eventRegisterString() + "\\l";
-            }
-
-
-            return clone.getVertexProperty(nodeId).toString() + h_intro() + h_eventWaitString() + h_streamString() + h_eventRegisterString() + "\\l";
-        };
-
-        // HELPER //////////////////////////////////////////////////////////////////////////
-        auto edgeLabel = [&](const std::pair<size_t, size_t>& edge)
-            -> std::string {
-            const auto& metaEdge = clone.getEdgeProperty(edge);
-            if (metaEdge.m_isSchedulingEdge) {
-                return "";
-            }
-            //if (property.nDependencies() > 0) {
-            auto& metaNodeExtendedStart = h_getMetaNodeExtended(edge.first);
-            auto& metaNodeExtendedEnd = h_getMetaNodeExtended(edge.second);
-            if (metaNodeExtendedStart.schedulingInfo.streamIdx != metaNodeExtendedEnd.schedulingInfo.streamIdx) {
-                // bool found = false;
-                for (auto& e : metaNodeExtendedEnd.schedulingInfo.waitEventIdxList) {
-                    if (e == metaNodeExtendedStart.schedulingInfo.setEventIdx) {
-                        // found = true;
-                    }
-                }
-                // if (!found) {
-                //      NEON_THROW_UNSUPPORTED_OPTION("");
-                // }
-                if (metaEdge.nDependencies() > 0) {
-                    return metaEdge.toString() +
-                           "Synchronizations:\\l- Stream " +
-                           std::to_string(metaNodeExtendedStart.schedulingInfo.streamIdx) +
-                           "\\l- Event " + std::to_string(metaNodeExtendedStart.schedulingInfo.setEventIdx) + "\\l";
-                } else {
-                    return "Synchronization:\\l- Stream " +
-                           std::to_string(metaNodeExtendedStart.schedulingInfo.streamIdx) +
-                           "\\l- Event " + std::to_string(metaNodeExtendedStart.schedulingInfo.setEventIdx) + "\\l";
-                }
-            }
-            //return property.toString() + "\\l";
-            //        }
-            return "";
-        };
-
-        // HELPER //////////////////////////////////////////////////////////////////////////
-        auto edgeLabelProperty = [&](const std::pair<size_t, size_t>& edge)
-            -> std::string {
-          const auto& metaEdge = clone.getEdgeProperty(edge);
-          if (metaEdge.m_isSchedulingEdge) {
-              // return "style=dashed, color=\"#2A9D8F\"";
-              return "style=dashed, color=\"#F4A261\", penwidth=7";
-          }
-          return "color=\"#d9d9d9\", penwidth=7";
-        };
-        // HELPER //////////////////////////////////////////////////////////////////////////
-        auto vertexLabelProperty = [&](const size_t& v) {
-          if (v == mGpuGraph.finalNodeId() || (v == mGpuGraph.rootNodeId())) {
-              return R"(shape=doublecircle, style=filled, fillcolor="#d9d9d9", color="#6c6c6c")";
-          }
-          const auto& metaNode = clone.getVertexProperty(v);
-          if (metaNode.isHu()) {
-              return R"(shape=octagon, style="rounded,filled", fillcolor="#fb8072", color="#b11605")";
-          }
-          if (metaNode.isSync()) {
-              return R"(shape=octagon, style="rounded,filled", fillcolor="#fb8072", color="#b11605")";
-          }
-
-          if (metaNode.isMap()) {
-              return R"(style=filled, fillcolor="#b3de69", color="#5f861d")";
-          }
-          if (metaNode.isReduce()) {
-              return R"(style=filled, fillcolor="#80b1d3", color="#2b5c7d")";
-          }
-          if (metaNode.isStencil()) {
-              return R"(style=filled, fillcolor="#bebada", color="#4e4683")";
-          }
-          return "";
-        };
-
-        ////////////////////////////////////////////////////////////////////////////
-        clone.exportDotFile(fname, graphName, vertexLabel, edgeLabel,
-                            vertexLabelProperty, edgeLabelProperty);
-    }
-#else
-
-auto StreamScheduler::io2Dot(const std::string& fname, const std::string& graphName) -> void
-{
-    auto clone = m_storage->m_graph.getDiGraph();
-    m_storage->m_graph.getSchedulingDiGraph().forEachEdge([&](const MultiGpuGraph::DiGraphScheduling::Edge& edge) {
-        auto edgeMeta = Edge::factorySchedulingEdge();
-        clone.addEdge(edge.first, edge.second, edgeMeta);
-    });
-
-    auto& mGpuGraph = m_storage->m_graph;
-
-    auto vertexLabel = [&](NodeId nodeId) -> std::string {
-        auto& metaNodeExtended = h_getMetaNodeExtended(nodeId);
-
-        auto h_intro = [&]() -> std::string {
-            return std::string("Scheduling info: \\l- Taks idx ") +
-                   std::to_string(metaNodeExtended.schedulingInfo.schedulingOrder) + "\\l";
-        };
-        // HELPER //////////////////////////////////////////////////////////////////////////
-        auto h_eventWaitString = [&]() -> std::string {
-            std::string ret;
-            if (metaNodeExtended.schedulingInfo.waitEventIdxList.size() == 0) {
-                ret += "- Waiting events: []\\l";
-            } else {
-                ret += "- Waiting events: [";
-                for (auto& e : metaNodeExtended.schedulingInfo.waitEventIdxList) {
-                    ret += " " + std::to_string(e);
-                }
-                ret += "]\\l";
-            }
-            return ret;
-        };
-        // HELPER //////////////////////////////////////////////////////////////////////////
-        auto h_streamString = [&]() -> std::string {
-            return "- Stream idx: " + std::to_string(metaNodeExtended.schedulingInfo.streamIdx) + "\\l";
-        };
-
-        [[maybe_unused]] auto h_barrierString = [&]() -> std::string {
-            if (metaNodeExtended.schedulingInfo.barrierLR != -1) {
-                return "- LR Event " + std::to_string(metaNodeExtended.schedulingInfo.barrierLR) + "\\l";
-                ;
-            }
-            return "";
-        };
-        // HELPER //////////////////////////////////////////////////////////////////////////
-        auto h_eventRegisterString = [&]() -> std::string {
-            if (metaNodeExtended.schedulingInfo.setEventIdx != -1) {
-                return "- Completion Event idx: " + std::to_string(metaNodeExtended.schedulingInfo.setEventIdx) +
-                       "\\l";
-            } else {
-                return "- Completion Event idx: None";
-            }
-        };
-
-        if (nodeId == mGpuGraph.finalNodeId()) {
-            return std::string("END \n") + h_intro() + h_streamString() + h_eventWaitString() +
-                   h_eventRegisterString() + "\\l";
-        }
-        if (nodeId == mGpuGraph.rootNodeId()) {
-            return std::string("START \n") + h_intro() + h_streamString() + h_eventWaitString() +
-                   h_eventRegisterString() + "\\l";
-        }
-        return clone.getVertexProperty(nodeId).toString() + h_intro() + h_streamString() + h_eventWaitString() +
-               h_eventRegisterString() + "\\l";
-    };
-    // HELPER //////////////////////////////////////////////////////////////////////////
-    auto edgeLabel = [&](const std::pair<size_t, size_t>&)
-        -> std::string {
-        return "";
-    };
-
-    // HELPER //////////////////////////////////////////////////////////////////////////
-    auto edgeLabelProperty = [&](const std::pair<size_t, size_t>& edge)
-        -> std::string {
-        const auto& metaEdge = clone.getEdgeProperty(edge);
-        if (metaEdge.m_isSchedulingEdge) {
-            // return "style=dashed, color=\"#2A9D8F\"";
-            return "style=dashed, color=\"#F4A261\", penwidth=7";
-        }
-        return "color=\"#d9d9d9\", penwidth=7";
-    };
-    // HELPER //////////////////////////////////////////////////////////////////////////
-    auto vertexLabelProperty = [&](const size_t& v) {
-        if (v == mGpuGraph.finalNodeId() || (v == mGpuGraph.rootNodeId())) {
-            return R"(shape=doublecircle, style=filled, fillcolor="#d9d9d9", color="#6c6c6c")";
-        }
-        const auto& metaNode = clone.getVertexProperty(v);
-        if (metaNode.isHu()) {
-            return R"(shape=octagon, style="rounded,filled", fillcolor="#fb8072", color="#b11605")";
-        }
-        if (metaNode.isSync()) {
-            return R"(shape=octagon, style="rounded,filled", fillcolor="#fb8072", color="#b11605")";
-        }
-
-        if (metaNode.isMap()) {
-            return R"(style=filled, fillcolor="#b3de69", color="#5f861d")";
-        }
-        if (metaNode.isReduce()) {
-            return R"(style=filled, fillcolor="#80b1d3", color="#2b5c7d")";
-        }
-        if (metaNode.isStencil()) {
-            return R"(style=filled, fillcolor="#bebada", color="#4e4683")";
-        }
-        return "";
-    };
-
-    ////////////////////////////////////////////////////////////////////////////
-    clone.exportDotFile(fname, graphName, vertexLabel, edgeLabel,
-                        vertexLabelProperty, edgeLabelProperty);
-}
-
-#endif
-
-auto StreamScheduler::io2DotOrder(const std::string& fname, const std::string& graphName) -> void
-{
-    MultiGpuGraph::DiGraphScheduling orderGraph;
-    for (int i = 0; i < int(m_storage->m_executionOrder.size()); i++) {
-        orderGraph.addVertex(m_storage->m_executionOrder[i]);
-        if (i > 0) {
-            orderGraph.addEdge(m_storage->m_executionOrder[i - 1], m_storage->m_executionOrder[i]);
-        }
-    }
-
-
-    auto& mGpuGraph = m_storage->m_graph;
-
-    auto vertexLabel = [&](NodeId nodeId) -> std::string {
-        auto& metaNodeExtended = h_getMetaNodeExtended(nodeId);
-
-        auto h_intro = [&]() -> std::string {
-            return std::string("Scheduling info: \\l- Taks idx ") +
-                   std::to_string(metaNodeExtended.schedulingInfo.schedulingOrder) + "\\l";
-        };
-        // HELPER //////////////////////////////////////////////////////////////////////////
-        auto h_eventWaitString = [&]() -> std::string {
-            std::string ret;
-            if (metaNodeExtended.schedulingInfo.waitEventIdxList.size() == 0) {
-                ret += "- Waiting events: []\\l";
-            } else {
-                ret += "- Waiting events: [";
-                for (auto& e : metaNodeExtended.schedulingInfo.waitEventIdxList) {
-                    ret += " " + std::to_string(e);
-                }
-                ret += "]\\l";
-            }
-            return ret;
-        };
-        // HELPER //////////////////////////////////////////////////////////////////////////
-        auto h_streamString = [&]() -> std::string {
-            return "- Stream idx: " + std::to_string(metaNodeExtended.schedulingInfo.streamIdx) + "\\l";
-        };
-
-        [[maybe_unused]] auto h_barrierString = [&]() -> std::string {
-            if (metaNodeExtended.schedulingInfo.barrierLR != -1) {
-                return "- LR Event " + std::to_string(metaNodeExtended.schedulingInfo.barrierLR) + "\\l";
-                ;
-            }
-            return "";
-        };
-        // HELPER //////////////////////////////////////////////////////////////////////////
-        auto h_eventRegisterString = [&]() -> std::string {
-            if (metaNodeExtended.schedulingInfo.setEventIdx != -1) {
-                return "- Completion Event idx: " + std::to_string(metaNodeExtended.schedulingInfo.setEventIdx) +
-                       "\\l";
-            } else {
-                return "- Completion Event idx: None";
-            }
-        };
-
-        if (nodeId == mGpuGraph.finalNodeId()) {
-            return std::string("Task List \n END");
-        }
-        if (nodeId == mGpuGraph.rootNodeId()) {
-            return std::string("Task List \n BEGIN");
-        }
-        return mGpuGraph.getDiGraph().getVertexProperty(nodeId).toString() + h_intro() + h_streamString() +
-               h_eventWaitString() + h_eventRegisterString() + "\\l";
-    };
-    // HELPER //////////////////////////////////////////////////////////////////////////
-    auto edgeLabel = [&](const std::pair<size_t, size_t>&)
-        -> std::string {
-        return "";
-    };
-
-    // HELPER //////////////////////////////////////////////////////////////////////////
-    auto edgeLabelProperty = [&]([[maybe_unused]] const std::pair<size_t, size_t>& edge)
-        -> std::string {
-        return "color=\"#d9d9d9\", penwidth=7";
-    };
-    // HELPER //////////////////////////////////////////////////////////////////////////
-    auto vertexLabelProperty = [&](const size_t& v) {
-        if (v == mGpuGraph.finalNodeId() || (v == mGpuGraph.rootNodeId())) {
-            return R"(shape=box, style="rounded,filled", fillcolor="#d9d9d9", color="#6c6c6c")";
-        }
-        const auto& metaNode = mGpuGraph.getDiGraph().getVertexProperty(v);
-        if (metaNode.isHu()) {
-            return R"(shape=box, style="rounded,filled", fillcolor="#fb8072", color="#b11605")";
-        }
-        if (metaNode.isSync()) {
-            return R"(shape=box, style="rounded,filled", fillcolor="#fb8072", color="#b11605")";
-        }
-
-        if (metaNode.isMap()) {
-            return R"(shape=box, style="rounded,filled", fillcolor="#b3de69", color="#5f861d")";
-        }
-        if (metaNode.isReduce()) {
-            return R"(shape=box, style="rounded,filled", fillcolor="#80b1d3", color="#2b5c7d")";
-        }
-        if (metaNode.isStencil()) {
-            return R"(shape=box, style="rounded,filled", fillcolor="#bebada", color="#4e4683")";
-        }
-        return "";
-    };
-
-    ////////////////////////////////////////////////////////////////////////////
-    orderGraph.exportDotFile(fname, graphName, vertexLabel, edgeLabel,
-                             vertexLabelProperty, edgeLabelProperty);
-}
-
-
-}  // namespace Neon::skeleton::internal
diff --git a/libNeonSkeleton/tests/unit/sUt_skeletonOnStreams/src/sUt.runHelper.h b/libNeonSkeleton/tests/unit/sUt_skeletonOnStreams/src/sUt.runHelper.h
index a9e9f6e5..75bb6c0e 100644
--- a/libNeonSkeleton/tests/unit/sUt_skeletonOnStreams/src/sUt.runHelper.h
+++ b/libNeonSkeleton/tests/unit/sUt_skeletonOnStreams/src/sUt.runHelper.h
@@ -34,8 +34,8 @@ void runAllTestConfiguration(const std::string&                      gname,
 
         std::vector<int> cardinalityTest{1};
 
-        std::vector<Neon::index_3d> dimTest{{64, 16, 252}};
-        std::vector<Neon::Runtime>  runtimeE{Neon::Runtime::openmp, Neon::Runtime::stream};
+        std::vector<Neon::index_3d> dimTest{{80, 50, 252},{90, 50, 252},{80, 51, 300}};
+        std::vector<Neon::Runtime>  runtimeE{ Neon::Runtime::stream};
 
         std::vector<Geometry> geos;
 
diff --git a/libNeonSkeleton/tests/unit/sUt_skeletonOnStreams/src/sUt_skeleton.Stencil.cu b/libNeonSkeleton/tests/unit/sUt_skeletonOnStreams/src/sUt_skeleton.Stencil.cu
index b74125b9..40abcd1f 100644
--- a/libNeonSkeleton/tests/unit/sUt_skeletonOnStreams/src/sUt_skeleton.Stencil.cu
+++ b/libNeonSkeleton/tests/unit/sUt_skeletonOnStreams/src/sUt_skeleton.Stencil.cu
@@ -223,7 +223,7 @@ int getNGpus()
 }  // namespace
 
 
-TEST(Stencil_NoOCC, bGrid)
+TEST(Stencil_NoOCC, DISABLED_bGrid)
 {
     int nGpus = 1;
     using Grid = Neon::domain::internal::bGrid::bGrid;
diff --git a/libNeonSkeleton/tests/unit/sUt_skeletonOnStreams/src/sUt_skeleton.mapStencilDot.cu b/libNeonSkeleton/tests/unit/sUt_skeletonOnStreams/src/sUt_skeleton.mapStencilDot.cu
index 340f4c09..e3b37b2e 100644
--- a/libNeonSkeleton/tests/unit/sUt_skeletonOnStreams/src/sUt_skeleton.mapStencilDot.cu
+++ b/libNeonSkeleton/tests/unit/sUt_skeletonOnStreams/src/sUt_skeleton.mapStencilDot.cu
@@ -140,7 +140,7 @@ int getNGpus()
 }
 }  // namespace
 
-TEST(MapStencilDotNoOcc, bGrid)
+TEST(MapStencilDotNoOcc, DISABLED_bGrid)
 {
     int nGpus = 1;
     using Grid = Neon::domain::bGrid;
diff --git a/libNeonSkeleton/tests/unit/sUt_skeletonOnStreams/src/sUt_skeleton.mapStencilMap.cu b/libNeonSkeleton/tests/unit/sUt_skeletonOnStreams/src/sUt_skeleton.mapStencilMap.cu
index 3fbd6daf..3030274b 100644
--- a/libNeonSkeleton/tests/unit/sUt_skeletonOnStreams/src/sUt_skeleton.mapStencilMap.cu
+++ b/libNeonSkeleton/tests/unit/sUt_skeletonOnStreams/src/sUt_skeleton.mapStencilMap.cu
@@ -43,7 +43,8 @@ void MapStencilMap(TestData<G, T, C>&      data,
     fR() = scalarVal;
     data.getBackend().syncAll();
 
-    data.resetValuesToRandom(1, 50);
+    //data.resetValuesToRandom(1, 50);
+    data.resetValuesToMasked(1,1,3);
     Neon::Timer_sec timer;
 
     {  // SKELETON
@@ -57,11 +58,14 @@ void MapStencilMap(TestData<G, T, C>&      data,
 
         skl.sequence(ops, appName, opt);
 
-        skl.ioToDot(appName + "_" + Neon::skeleton::OccUtils::toString(opt.occ()));
+        skl.ioToDot(appName + "_" + Neon::skeleton::OccUtils::toString(opt.occ()),
+                    "",
+                    true);
 
         timer.start();
         for (int i = 0; i < nIterations; i++) {
             skl.run();
+            data.getBackend().syncAll();
         }
         data.getBackend().syncAll();
         timer.stop();
@@ -83,13 +87,13 @@ void MapStencilMap(TestData<G, T, C>&      data,
     bool isOk = data.compare(FieldNames::X);
     isOk = isOk && data.compare(FieldNames::Y);
 
-    /*{  // DEBUG
+    {  // DEBUG
         data.getIODomain(FieldNames::X).ioToVti("IODomain_X", "X");
         data.getField(FieldNames::X).ioToVtk("Field_X", "X");
 
         data.getIODomain(FieldNames::Y).ioToVti("IODomain_Y", "Y");
         data.getField(FieldNames::Y).ioToVtk("Field_Y", "Y");
-    }*/
+    }
 
     ASSERT_TRUE(isOk);
 }
@@ -142,6 +146,14 @@ TEST(MapStencilMap_NoOCC, eGrid)
     runAllTestConfiguration<Grid, Type, 0>("eGrid_t", MapStencilNoOCC<Grid, Type, 0>, nGpus, 1);
 }
 
+TEST(MapStencilMap_NoOCC, dGrid)
+{
+    int nGpus = getNGpus();
+    using Grid = Neon::domain::dGrid;
+    using Type = int32_t;
+    runAllTestConfiguration<Grid, Type, 0>("dGrid", MapStencilNoOCC<Grid, Type, 0>, nGpus, 2);
+}
+
 TEST(MapStencilMap_OCC, eGrid)
 {
     int nGpus = getNGpus();
@@ -150,6 +162,14 @@ TEST(MapStencilMap_OCC, eGrid)
     runAllTestConfiguration<Grid, Type, 0>("eGrid_t", MapStencilOCC<Grid, Type, 0>, nGpus, 1);
 }
 
+TEST(MapStencilMap_OCC, dGrid)
+{
+    int nGpus = getNGpus();
+    using Grid = Neon::domain::dGrid;
+    using Type = int32_t;
+    runAllTestConfiguration<Grid, Type, 0>("dGrid", MapStencilOCC<Grid, Type, 0>, nGpus, 2);
+}
+
 TEST(MapStencilMap_ExtendedOCC, eGrid)
 {
     int nGpus = getNGpus();
@@ -159,6 +179,15 @@ TEST(MapStencilMap_ExtendedOCC, eGrid)
     runAllTestConfiguration<Grid, Type, 0>("eGrid_t", MapStencilExtendedOCC<Grid, Type, 0>, nGpus, 1);
 }
 
+TEST(MapStencilMap_ExtendedOCC, dGrid)
+{
+    int nGpus = getNGpus();
+    NEON_INFO("MapStencilMap_ExtendedOCC");
+    using Grid = Neon::domain::dGrid;
+    using Type = int32_t;
+    runAllTestConfiguration<Grid, Type, 0>("dGrid", MapStencilExtendedOCC<Grid, Type, 0>, nGpus, 1);
+}
+
 TEST(MapStencilMap_TwoWayExtendedOCC, eGrid)
 {
     int nGpus = getNGpus();
@@ -167,7 +196,15 @@ TEST(MapStencilMap_TwoWayExtendedOCC, eGrid)
     runAllTestConfiguration<Grid, Type, 0>("eGrid_t", MapStencilTwoWayExtendedOCC<Grid, Type, 0>, nGpus, 1);
 }
 
-TEST(MapStencilMap_NoOCC, bGrid)
+TEST(MapStencilMap_TwoWayExtendedOCC, dGrid)
+{
+    int nGpus = getNGpus();
+    using Grid = Neon::domain::dGrid;
+    using Type = int32_t;
+    runAllTestConfiguration<Grid, Type, 0>("dGrid", MapStencilTwoWayExtendedOCC<Grid, Type, 0>, nGpus, 2);
+}
+
+TEST(MapStencilMap_NoOCC, DISABLED_bGrid)
 {
     int nGpus = 1;
     using Grid = Neon::domain::internal::bGrid::bGrid;
diff --git a/libNeonSkeleton/tests/unit/sUt_skeletonOnStreams/src/sUt_skeleton.onStream.kernels.h b/libNeonSkeleton/tests/unit/sUt_skeletonOnStreams/src/sUt_skeleton.onStream.kernels.h
index 2ef2d591..f390b87a 100644
--- a/libNeonSkeleton/tests/unit/sUt_skeletonOnStreams/src/sUt_skeleton.onStream.kernels.h
+++ b/libNeonSkeleton/tests/unit/sUt_skeletonOnStreams/src/sUt_skeleton.onStream.kernels.h
@@ -17,7 +17,7 @@ auto xpy(const Field& x,
          Field&       y) -> Neon::set::Container
 {
     auto Kontainer = x.getGrid().getContainer(
-        "xpy", [&](Neon::set::Loader & L) -> auto {
+        "xpy", [&](Neon::set::Loader& L) -> auto {
             auto& xLocal = L.load(x);
             auto& yLocal = L.load(y);
             return [=] NEON_CUDA_HOST_DEVICE(const typename Field::Cell& e) mutable {
@@ -35,16 +35,16 @@ auto aInvXpY(const Neon::template PatternScalar<T>& fR,
              Field&                                 y) -> Neon::set::Container
 {
     auto Kontainer = x.getGrid().getContainer(
-        "AXPY", [&](Neon::set::Loader & L) -> auto {
+        "AXPY", [&](Neon::set::Loader& L) -> auto {
             auto&      xLocal = L.load(x);
             auto&      yLocal = L.load(y);
             auto       fRLocal = L.load(fR);
             const auto fRVal = fRLocal();
             return [=] NEON_CUDA_HOST_DEVICE(const typename Field::Cell& e) mutable {
-                //printf("%d yLocal.cardinality()\n", yLocal.cardinality());
+                // printf("%d yLocal.cardinality()\n", yLocal.cardinality());
 
                 for (int i = 0; i < yLocal.cardinality(); i++) {
-                    //printf("%d %d (%d) x\n", e, xLocal(e, i), i);
+                    // printf("%d %d (%d) x\n", e, xLocal(e, i), i);
                     yLocal(e, i) += (1.0 / fRVal) * xLocal(e, i);
                 }
             };
@@ -58,16 +58,19 @@ auto axpy(const Neon::template PatternScalar<T>& fR,
           Field&                                 y) -> Neon::set::Container
 {
     auto Kontainer = x.getGrid().getContainer(
-        "AXPY", [&](Neon::set::Loader & L) -> auto {
+        "AXPY", [&](Neon::set::Loader& L) -> auto {
             auto&      xLocal = L.load(x);
             auto&      yLocal = L.load(y);
             auto       fRLocal = L.load(fR);
             const auto fRVal = fRLocal();
             return [=] NEON_CUDA_HOST_DEVICE(const typename Field::Cell& e) mutable {
-                //printf("%d yLocal.cardinality()\n", yLocal.cardinality());
+                // #ifdef NEON_PLACE_CUDA_DEVICE
+                //                 if(yLocal.prtID()==0) {
+                //                     __nanosleep(2000000U);
+                //                 }
+                // #endif
 
                 for (int i = 0; i < yLocal.cardinality(); i++) {
-                    //printf("%d %d (%d) x\n", e, xLocal(e, i), i);
                     yLocal(e, i) += fRVal * xLocal(e, i);
                 }
             };
@@ -77,11 +80,10 @@ auto axpy(const Neon::template PatternScalar<T>& fR,
 
 template <typename Field>
 auto laplace(const Field& x,
-             Field&       y,
-             size_t       sharedMem = 0) -> Neon::set::Container
+             Field&       y) -> Neon::set::Container
 {
-    auto Kontainer = x.getGrid().getContainer(
-        "Laplace", [&](Neon::set::Loader & L) -> auto {
+    Neon::set::Container container = x.getGrid().getContainer(
+        "Laplace", [&](Neon::set::Loader& L) -> auto {
             auto& xLocal = L.load(x, Neon::Compute::STENCIL);
             auto& yLocal = L.load(y);
 
@@ -154,7 +156,7 @@ auto laplace(const Field& x,
                 }
             };
         });
-    return Kontainer;
+    return container;
 }
 
 }  // namespace UserTools
\ No newline at end of file
diff --git a/libNeonSkeleton/tests/unit/sUt_skeletonOnStreams/src/sUt_skeleton.singleDot.cu b/libNeonSkeleton/tests/unit/sUt_skeletonOnStreams/src/sUt_skeleton.singleDot.cu
index 065c7bdc..e65179c6 100644
--- a/libNeonSkeleton/tests/unit/sUt_skeletonOnStreams/src/sUt_skeleton.singleDot.cu
+++ b/libNeonSkeleton/tests/unit/sUt_skeletonOnStreams/src/sUt_skeleton.singleDot.cu
@@ -66,11 +66,10 @@ void SingleStencilTestData(TestData<G, T, C>&      data,
                            Neon::skeleton::Occ     occ,
                            Neon::set::TransferMode transfer)
 {
-
-
     using Type = typename TestData<G, T, C>::Type;
 
     auto occName = Neon::skeleton::OccUtils::toString(occ);
+
     occName[0] = toupper(occName[0]);
     const std::string appName(testFilePrefix + "_" + occName);
 
@@ -78,7 +77,7 @@ void SingleStencilTestData(TestData<G, T, C>&      data,
     Neon::skeleton::Options  opt(occ, transfer);
 
     const Type scalarVal = 2;
-    const int  nIterations = 2;
+    const int  nIterations = 10;
 
     auto fR = data.getGrid().template newPatternScalar<Type>();
     fR() = scalarVal;
@@ -91,18 +90,17 @@ void SingleStencilTestData(TestData<G, T, C>&      data,
         auto& X = data.getField(FieldNames::X);
         auto& Y = data.getField(FieldNames::Y);
 
-        std::vector<Neon::set::Container> ops{
-            UserTools::laplace(X, Y),
-            UserTools::laplace(Y, X)};
+        std::vector<Neon::set::Container> ops{UserTools::laplace(X, Y),
+                                              UserTools::laplace(Y, X)};
 
         skl.sequence(ops, appName, opt);
-
-        skl.ioToDot(appName + "_" + Neon::skeleton::OccUtils::toString(opt.occ()));
+        skl.ioToDot(appName + "_" + Neon::skeleton::OccUtils::toString(opt.occ()), "", true);
 
         timer.start();
         for (int i = 0; i < nIterations; i++) {
             skl.run();
         }
+
         data.getBackend().syncAll();
         timer.stop();
     }
@@ -126,7 +124,6 @@ void SingleStencilTestData(TestData<G, T, C>&      data,
     }
 #endif
 
-
     bool isOk = data.compare(FieldNames::Y);
     isOk = isOk && data.compare(FieldNames::X);
 
@@ -143,7 +140,10 @@ void runSingleDot(TestData<G, T, C>& data)
 template <typename G, typename T, int C>
 void runSingleStencilTestData(TestData<G, T, C>& data)
 {
+    std::cout << "Executing Occ::none" << std::endl;
     help::SingleStencilTestData<G, T, C>(data, Neon::skeleton::Occ::none, Neon::set::TransferMode::get);
+    std::cout << "Executing Occ::standard" << std::endl;
+    help::SingleStencilTestData<G, T, C>(data, Neon::skeleton::Occ::standard, Neon::set::TransferMode::get);
 }
 
 int getNGpus()
@@ -177,7 +177,7 @@ TEST(SingleStencilTestData, dGrid)
 }
 
 
-TEST(SingleDot, bGrid)
+TEST(SingleDot, DISABLED_bGrid)
 {
     int nGpus = 1;
     using Grid = Neon::domain::bGrid;
@@ -185,7 +185,7 @@ TEST(SingleDot, bGrid)
     runAllTestConfiguration<Grid, Type, 0>("bGrid", runSingleDot<Grid, Type, 0>, nGpus, 1);
 }
 
-TEST(SingleStencilTestData, bGrid)
+TEST(SingleStencilTestData, DISABLED_bGrid)
 {
     int nGpus = 1;
     using Grid = Neon::domain::bGrid;
diff --git a/libNeonSkeleton/tests/unit/sUt_stencil/src/sUt_stencil.cu b/libNeonSkeleton/tests/unit/sUt_stencil/src/sUt_stencil.cu
index 82e354cf..41c2db4e 100644
--- a/libNeonSkeleton/tests/unit/sUt_stencil/src/sUt_stencil.cu
+++ b/libNeonSkeleton/tests/unit/sUt_stencil/src/sUt_stencil.cu
@@ -160,7 +160,7 @@ TEST(Stencil_NoOCC, dGrid)
     runAllTestConfiguration<Grid, Type, 0>("dGrid_t", SingleStencil<Grid, Type, 0>, nGpus, 1);
 }
 
-TEST(Stencil_NoOCC, bGrid)
+TEST(DISABLED_Stencil_NoOCC, DISABLED_bGrid)
 {
     int nGpus = 1;
     using Grid = Neon::domain::bGrid;
diff --git a/libNeonSys/include/Neon/sys/devices/gpu/GpuStream.h b/libNeonSys/include/Neon/sys/devices/gpu/GpuStream.h
index 0225f4a9..5d1f877f 100644
--- a/libNeonSys/include/Neon/sys/devices/gpu/GpuStream.h
+++ b/libNeonSys/include/Neon/sys/devices/gpu/GpuStream.h
@@ -3,11 +3,10 @@
 #include <atomic>
 #include <vector>
 #include "Neon/core/core.h"
-#include "Neon/sys/devices/gpu/GpuEvent.h"
 #include "Neon/sys/devices/gpu/ComputeID.h"
+#include "Neon/sys/devices/gpu/GpuEvent.h"
 
-namespace Neon {
-namespace sys {
+namespace Neon::sys {
 
 struct GpuStream
 {
@@ -131,24 +130,10 @@ struct GpuStream
      * @tparam runMode
      */
     template <run_et::et runMode = run_et::et::sync>
-    void sync() const
-    {
-        if constexpr (run_et::et::sync == runMode) {
-            cudaError_t retCode = cudaStreamSynchronize(m_cudaStream);
-            if (cudaSuccess != retCode) {
-                NeonException exc("GpuStream_t");
-                exc << "CUDA error completing cudaStreamSynchronize operation.\n";
-                exc << "   target device: " << m_gpuId;
-                exc << "\n   Error: " << cudaGetErrorString(retCode);
-                NEON_THROW(exc);
-            }
-            return;
-        } else {
-            return;
-        }
-    }
+    auto sync() const -> void;
 };
 
+extern template auto GpuStream::sync<run_et::et::sync>() const -> void;
+extern template auto GpuStream::sync<run_et::et::async>() const -> void;
 
-}  // End of namespace sys
 }  // End of namespace Neon
diff --git a/libNeonSys/include/Neon/sys/global/GpuSysGlobal.h b/libNeonSys/include/Neon/sys/global/GpuSysGlobal.h
index fd49b020..bfd330dd 100644
--- a/libNeonSys/include/Neon/sys/global/GpuSysGlobal.h
+++ b/libNeonSys/include/Neon/sys/global/GpuSysGlobal.h
@@ -2,14 +2,10 @@
 #include "Neon/sys/devices/gpu/GpuSys.h"
 #include "libneonsys_export.h"
 
-namespace Neon {
-namespace sys {
-namespace globalSpace {
+namespace Neon::sys::globalSpace {
 
 LIBNEONSYS_EXPORT extern GpuSys gpuSysObjStorage;
 
 GpuSys& gpuSysObj();
 
-}  // namespace globalSpace
-}  // End of namespace sys
-}  // End of namespace Neon
\ No newline at end of file
+}  // namespace Neon::sys::globalSpace
\ No newline at end of file
diff --git a/libNeonSys/src/sys/devices/gpu/gpuStream.cpp b/libNeonSys/src/sys/devices/gpu/gpuStream.cpp
index 2b3903b9..3befef0e 100644
--- a/libNeonSys/src/sys/devices/gpu/gpuStream.cpp
+++ b/libNeonSys/src/sys/devices/gpu/gpuStream.cpp
@@ -16,12 +16,12 @@ GpuStream::GpuStream(ComputeID gpuIdx, cudaStream_t cudaStream)
     m_referenceCounter = new std::atomic_size_t(1);
 }
 
-//GpuStream_t::GpuStream_t(gpu_id gpuIdx, cudaStream_t cudaStream, GpuStreamSet* streamSet){
-//    m_gpuId = gpuIdx;
-//    m_cudaStream = cudaStream;
-//    m_referenceCounter = nullptr;
+// GpuStream_t::GpuStream_t(gpu_id gpuIdx, cudaStream_t cudaStream, GpuStreamSet* streamSet){
+//     m_gpuId = gpuIdx;
+//     m_cudaStream = cudaStream;
+//     m_referenceCounter = nullptr;
 //
-//}
+// }
 
 GpuStream::GpuStream(const GpuStream& other)
 {
@@ -161,6 +161,27 @@ const ComputeID& GpuStream::gpuId() const
     return m_gpuId;
 }
 
+template <run_et::et runMode>
+auto GpuStream::sync() const -> void
+{
+    if constexpr (run_et::et::sync == runMode) {
+        ::Neon::sys::globalSpace::gpuSysObj().dev(m_gpuId).tools.setActiveDevContext();
+        cudaError_t retCode = cudaStreamSynchronize(m_cudaStream);
+        if (cudaSuccess != retCode) {
+            NeonException exc("GpuStream_t");
+            exc << "CUDA error completing cudaStreamSynchronize operation.\n";
+            exc << "   target device: " << m_gpuId;
+            exc << "\n   Error: " << cudaGetErrorString(retCode);
+            NEON_THROW(exc);
+        }
+        return;
+    } else {
+        return;
+    }
+}
+
+template auto GpuStream::sync<run_et::et::sync>() const -> void;
+template auto GpuStream::sync<run_et::et::async>() const -> void;
 
 }  // End of namespace sys
 }  // End of namespace Neon
diff --git a/libNeonSys/src/sys/memory/CpuMem.cpp b/libNeonSys/src/sys/memory/CpuMem.cpp
index 36745e6d..014b7a40 100644
--- a/libNeonSys/src/sys/memory/CpuMem.cpp
+++ b/libNeonSys/src/sys/memory/CpuMem.cpp
@@ -112,7 +112,7 @@ void* CpuMem::allocateMem(const Neon::Allocator& allocType, size_t size)
         }
         default: {
             Neon::NeonException exp("CpuMem_t");
-            exp << "Unsupported->memory.allocation m_type " << allocType << " for device " << m_cpuDev->getIdx();
+            exp << "Unsupported->memory.allocation mType " << allocType << " for device " << m_cpuDev->getIdx();
             NEON_THROW(exp);
         }
     }
@@ -145,7 +145,7 @@ void CpuMem::releaseMem(const Neon::Allocator& allocType, size_t size, void* mem
         }
         default: {
             Neon::NeonException exp("CpuMem_t");
-            exp << "Unsupported memory de-allocation m_type " << allocType << " for device " << m_cpuDev->getIdx();
+            exp << "Unsupported memory de-allocation mType " << allocType << " for device " << m_cpuDev->getIdx();
             NEON_THROW(exp);
         }
     }
diff --git a/libNeonSys/src/sys/memory/GpuMem.cpp b/libNeonSys/src/sys/memory/GpuMem.cpp
index eed4de91..c4d6ad18 100644
--- a/libNeonSys/src/sys/memory/GpuMem.cpp
+++ b/libNeonSys/src/sys/memory/GpuMem.cpp
@@ -52,7 +52,7 @@ void* GpuMem::allocateMem(const Neon::Allocator& allocType, size_t size)
 
         default: {
             Neon::NeonException exp("GpuMem_t");
-            exp << "Unsupported memory allocation m_type " << AllocatorUtils::toString(allocType) << " for device " << m_gpuDev->getIdx();
+            exp << "Unsupported memory allocation mType " << AllocatorUtils::toString(allocType) << " for device " << m_gpuDev->getIdx();
             NEON_THROW(exp);
         }
     }
@@ -71,7 +71,7 @@ void GpuMem::releaseMem(const Neon::Allocator& allocType, size_t size, void* mem
 
         default: {
             Neon::NeonException exp("GpuMem_t");
-            exp << "Unsupported memory de-allocation m_type " << allocType << " for device " << m_gpuDev->getIdx();
+            exp << "Unsupported memory de-allocation mType " << allocType << " for device " << m_gpuDev->getIdx();
             NEON_THROW(exp);
         }
     }