merge attempt

legate/core/operation.py

@@ -28,12 +28,12 @@ def __init__(self, context, mapper_id=0):
         self._inputs = []
         self._outputs = []
         self._reductions = []
+        self._is_fused = False
         self._temps = []
-        self._future_output = None
-        self._future_reduction = None
+        self._scalar_outputs = []
+        self._scalar_reductions = []
         self._constraints = EqClass()
-        self._broadcasts = set()
-        self._is_fused = False
+        self._broadcasts = OrderedSet()
 
     @property
     def context(self):
@@ -161,13 +161,15 @@ def launch(self, strategy):
 
         for input in self._inputs:
             proj = strategy.get_projection(input)
-            launcher.add_input(input, proj)
+            tag = self.get_tag(strategy, input)
+            launcher.add_input(input, proj, tag=tag)
         for temp in self._temps:
             proj = strategy.get_projection(temp)
             launcher.add_temp(temp, proj)
             partition = strategy.get_partition(temp)
             # We update the key partition of a store only when it gets updated
             temp.set_key_partition(partition)
+
         for output in self._outputs:
             if output.unbound:
                 continue

src/core.mk

@@ -15,17 +15,24 @@
 
 
 # General source files
-GEN_CPU_SRC	= legate_c.cc               \
-							data/scalar.cc            \
-							data/store.cc             \
-							data/transform.cc         \
-							mapping/mapper.cc         \
-							runtime/context.cc        \
-							runtime/projection.cc     \
-							runtime/runtime.cc        \
-							runtime/shard.cc          \
-							task/task.cc              \
-							utilities/deserializer.cc \
+GEN_CPU_SRC	= legate_c.cc                 \
+							data/scalar.cc              \
+							data/store.cc               \
+							data/transform.cc           \
+							mapping/base_mapper.cc      \
+							mapping/core_mapper.cc      \
+							mapping/instance_manager.cc \
+							mapping/mapping.cc          \
+							mapping/task.cc             \
+							runtime/context.cc          \
+							runtime/projection.cc       \
+							runtime/runtime.cc          \
+							runtime/shard.cc            \
+							task/return.cc              \
+							task/task.cc                \
+							utilities/deserializer.cc   \
+							utilities/machine.cc        \
+							utilities/linearize.cc      \
 							utilities/makeshift_serializer.cc
 
 ifeq ($(strip $(USE_CUDA)),1)
@@ -39,22 +46,29 @@ INSTALL_PATHS = data      \
 								task      \
 								utilities
 
-INSTALL_HEADERS = legate.h                 \
-									legate_c.h               \
-									legate_defines.h         \
-									legate_preamble.h        \
-									data/buffer.h            \
-									data/scalar.h            \
-									data/scalar.inl          \
-									data/store.h             \
-									data/store.inl           \
-									data/transform.h         \
-									runtime/context.h        \
-									runtime/runtime.h        \
-									task/task.h              \
-									utilities/deserializer.h \
-									utilities/dispatch.h     \
-									utilities/span.h         \
-									utilities/type_traits.h  \
+INSTALL_HEADERS = legate.h                   \
+									legate_c.h                 \
+									legate_defines.h           \
+									legate_preamble.h          \
+									data/buffer.h              \
+									data/scalar.h              \
+									data/scalar.inl            \
+									data/store.h               \
+									data/store.inl             \
+									data/transform.h           \
+									mapping/base_mapper.h      \
+									mapping/mapping.h          \
+									mapping/task.h             \
+									mapping/task.inl           \
+									runtime/context.h          \
+									runtime/runtime.h          \
+									task/return.h              \
+									task/task.h                \
+									utilities/deserializer.h   \
+									utilities/deserializer.inl \
+									utilities/dispatch.h       \
+									utilities/machine.h        \
+									utilities/span.h           \
 									utilities/makeshift_serializer.h  \
+									utilities/type_traits.h    \
 									utilities/typedefs.h

src/data/transform.h

@@ -35,8 +35,8 @@ class StoreTransform {
   virtual Legion::DomainAffineTransform inverse_transform(int32_t in_dim) const = 0;
   virtual int32_t getTransformCode() const =0;
  protected:
-  std::unique_ptr<StoreTransform> parent_{nullptr};
- friend class MakeshiftSerializer;
+  friend class MakeshiftSerializer;
+  std::shared_ptr<StoreTransform> parent_{nullptr};
 };
 
 class Shift : public StoreTransform {

src/runtime/context.cc

@@ -147,8 +147,9 @@ TaskContext::TaskContext(const Legion::Task* task,
                          Legion::Runtime* runtime)
   : task_(task), regions_(regions), context_(context), runtime_(runtime)
 {
-  Deserializer dez(task, regions);
+  TaskDeserializer dez(task, regions);
   fusionMetadata = dez.unpack<FusionMetadata>(); 
+
   inputs_     = dez.unpack<std::vector<Store>>();
   outputs_    = dez.unpack<std::vector<Store>>();
   reductions_ = dez.unpack<std::vector<Store>>();

src/runtime/context.h

@@ -54,10 +54,10 @@ class ResourceScope {
 
  public:
   bool valid() const { return base_ != -1; }
-  bool in_scope(int64_t resource_id) const { 
-  std::cout<<"resource_id "<<resource_id<<std::endl;  
-  std::cout<<"max "<<max_<<std::endl;  
-  return base_ <= resource_id && resource_id < max_; }
+  bool in_scope(int64_t resource_id) const
+  {
+    return base_ <= resource_id && resource_id < base_ + max_;
+  }
 
  private:
   int64_t base_{-1};
@@ -121,6 +121,9 @@ class TaskContext {
   std::vector<Store>& reductions() { return reductions_; }
   std::vector<Scalar>& scalars() { return scalars_; }
 
+ public:
+  ReturnValues pack_return_values() const;
+
  public:
   const Legion::Task* task_;
   const std::vector<Legion::PhysicalRegion>& regions_;

src/utilities/deserializer.cc

@@ -40,12 +40,7 @@ TaskDeserializer::TaskDeserializer(const LegionTask* task,
   first_task_ = !task->is_index_space || (task->index_point == task->index_domain.lo());
 }
 
-void Deserializer::_unpack(LegateTypeCode& value)
-{
-  value = static_cast<LegateTypeCode>(unpack<int32_t>());
-}
-
-
+/*
 void Deserializer::_unpack(FusionMetadata& metadata){
     metadata.isFused = unpack<bool>();
     if (!metadata.isFused){
@@ -99,8 +94,8 @@ void Deserializer::_unpack(FusionMetadata& metadata){
         metadata.opIDs[i] = unpack<int32_t>();
     }   
 }
-
-void Deserializer::_unpack(Store& value)
+*/
+void TaskDeserializer::_unpack(Store& value)
 {
   auto is_future = unpack<bool>();
   auto dim       = unpack<int32_t>();
@@ -130,8 +125,7 @@ void TaskDeserializer::_unpack(FutureWrapper& value)
   auto field_size  = unpack<int32_t>();
 
   auto point = unpack<std::vector<int64_t>>();
-
-  Domain domain;
+  Legion::Domain domain;
   domain.dim = static_cast<int32_t>(point.size());
   for (int32_t idx = 0; idx < domain.dim; ++idx) {
     domain.rect_data[idx]              = 0;
@@ -172,43 +166,7 @@ MapperDeserializer::MapperDeserializer(const LegionTask* task,
                                        MapperContext context)
   : BaseDeserializer(task), runtime_(runtime), context_(context)
 {
-  int32_t code = unpack<int32_t>();
-  switch (code) {
-    case -1: {
-      return nullptr;
-    }
-    case LEGATE_CORE_TRANSFORM_SHIFT: {
-      auto dim    = unpack<int32_t>();
-      auto offset = unpack<int64_t>();
-      auto parent = unpack_transform();
-      return std::make_unique<Shift>(dim, offset, std::move(parent));
-    }
-    case LEGATE_CORE_TRANSFORM_PROMOTE: {
-      auto extra_dim = unpack<int32_t>();
-      auto dim_size  = unpack<int64_t>();
-      auto parent    = unpack_transform();
-      return std::make_unique<Promote>(extra_dim, dim_size, std::move(parent));
-    }
-    case LEGATE_CORE_TRANSFORM_PROJECT: {
-      auto dim    = unpack<int32_t>();
-      auto coord  = unpack<int64_t>();
-      auto parent = unpack_transform();
-      return std::make_unique<Project>(dim, coord, std::move(parent));
-    }
-    case LEGATE_CORE_TRANSFORM_TRANSPOSE: {
-      auto axes   = unpack<std::vector<int32_t>>();
-      auto parent = unpack_transform();
-      return std::make_unique<Transpose>(std::move(axes), std::move(parent));
-    }
-    case LEGATE_CORE_TRANSFORM_DELINEARIZE: {
-      auto dim    = unpack<int32_t>();
-      auto sizes  = unpack<std::vector<int64_t>>();
-      auto parent = unpack_transform();
-      return std::make_unique<Delinearize>(dim, std::move(sizes), std::move(parent));
-    }
-  }
-  assert(false);
-  return nullptr;
+  first_task_ = false;
 }
 
 void MapperDeserializer::_unpack(Store& value)

src/utilities/deserializer.h

@@ -30,15 +30,9 @@
 
 namespace legate {
 
-class Store;
-class StoreTransform;
-class Scalar;
-class FutureWrapper;
-class RegionField;
-class OutputRegionField;
 struct FusionMetadata;
-
-class Deserializer {
+template <typename Deserializer>
+class BaseDeserializer {
  public:
   BaseDeserializer(const Legion::Task* task);
 
@@ -51,9 +45,7 @@ class Deserializer {
     return std::move(value);
   }
 
- //void unpackFusionMetadata(bool& isFused);
-
- private:
+ public:
   template <typename T, std::enable_if_t<legate_type_code_of<T> != MAX_TYPE_NUMBER>* = nullptr>
   void _unpack(T& value)
   {