minor cleanup

Author: fschlimb

src/Creator.cpp

@@ -163,7 +163,7 @@ struct DeferredArange : public Deferred
         llvm::SmallVector<int64_t> shape(1, -1); //::mlir::ShapedType::kDynamicSize);
         auto artype = ::imex::ptensor::PTensorType::get(builder.getContext(), ::mlir::RankedTensorType::get(shape, dtype), true);
         auto ar = builder.create<::imex::ptensor::ARangeOp>(loc, artype, start, end, step, true);
-        auto setter = [this](uint64_t rank, void *allocated, void *aligned, intptr_t offset, intptr_t * sizes, intptr_t * strides) {
+        auto setter = [this](uint64_t rank, void *allocated, void *aligned, intptr_t offset, const intptr_t * sizes, const intptr_t * strides) {
             // FIXME GC assert(allocated == aligned);
             assert(rank == 1);
             assert(strides[0] == 1);

src/EWBinOp.cpp

@@ -460,7 +460,7 @@ struct DeferredEWBinOp : public Deferred
         // FIXME the type of the result is hard-coded to uint64_t
         auto rtyp = ivm[_a].first.getType();
         auto ewbo = builder.create<::imex::ptensor::EWBinOp>(loc, rtyp, builder.getI32IntegerAttr(ddpt2mlir(_op)), ivm[_a].first, ivm[_b].first);
-        auto setter = [this](uint64_t rank, void *allocated, void *aligned, intptr_t offset, intptr_t * sizes, intptr_t * strides) {
+        auto setter = [this](uint64_t rank, void *allocated, void *aligned, intptr_t offset, const intptr_t * sizes, const intptr_t * strides) {
             // FIXME GC assert(allocated == aligned);
             this->set_value(std::move(x::operatorx<uint64_t>::mk_tx(rank, allocated, aligned, offset, sizes, strides)));
         };

src/ReduceOp.cpp

@@ -128,7 +128,7 @@ struct DeferredReduceOp : public Deferred
             true
         );
         auto rop = builder.create<::imex::ptensor::ReductionOp>(loc, rtyp, builder.getI32IntegerAttr(ddpt2mlir(_op)), a);
-        auto setter = [this](uint64_t rank, void *allocated, void *aligned, intptr_t offset, intptr_t * sizes, intptr_t * strides) {
+        auto setter = [this](uint64_t rank, void *allocated, void *aligned, intptr_t offset, const intptr_t * sizes, const intptr_t * strides) {
             // FIXME GC assert(allocated == aligned);
             this->set_value(std::move(x::operatorx<uint64_t>::mk_tx(rank, allocated, aligned, offset, sizes, strides)));
         };

src/Service.cpp

@@ -74,7 +74,7 @@ struct DeferredService : public Deferred
         default:
             throw(std::runtime_error("Unkown Service operation requested."));
         }
-        
+
         return {};
     }
 

src/include/ddptensor/jit/mlir.hpp

@@ -17,7 +17,7 @@ namespace jit {
 
 // function type for building body for linalg::generic
 using SetResFunc = std::function<void(
-    uint64_t rank, void *allocated, void *aligned, intptr_t offset, intptr_t * sizes, intptr_t * strides)>;
+    uint64_t rank, void *allocated, void *aligned, intptr_t offset, const intptr_t * sizes, const intptr_t * strides)>;
 using IdValueMap = std::unordered_map<id_type, std::pair<::mlir::Value, SetResFunc>>;
 
 // initialize jit

src/include/ddptensor/x.hpp

@@ -12,6 +12,7 @@
 #include <type_traits>
 #include <sstream>
 #include <memory>
+#include <algorithm>
 #include <xtensor/xarray.hpp>
 #include <xtensor/xadapt.hpp>
 #include <xtensor/xstrided_view.hpp>
@@ -265,17 +266,21 @@ namespace x
             return std::make_shared<DPTensorX<T>>(std::forward<Ts>(args)...);
         }
 
-        static typename DPTensorX<T>::typed_ptr_type mk_tx(uint64_t rank, void *allocated, void *aligned, intptr_t offset, intptr_t * sizes, intptr_t * strides)
+        static typename DPTensorX<T>::typed_ptr_type mk_tx(
+            uint64_t rank,
+            void *allocated,
+            void *aligned,
+            intptr_t offset,
+            const intptr_t * sizes,
+            const intptr_t * strides)
         {
             // FIXME strides/slices are not used
+            T * dptr = reinterpret_cast<T*>(aligned) + offset;
             if(rank == 0) {
-                return std::make_shared<DPTensorX<T>>(static_cast<T>(*reinterpret_cast<T*>(aligned)+offset));
+                return std::make_shared<DPTensorX<T>>(*dptr);
             }
-            shape_type shp(rank);
-            for(int i = 0; i < rank; ++i) {
-                shp[i] = sizes[i];
-            }
-            return std::make_shared<DPTensorX<T>>(shp, reinterpret_cast<T*>(aligned) + offset);
+            shape_type shp(sizes, sizes+rank);
+            return std::make_shared<DPTensorX<T>>(shp, dptr);
         }
 
         template<typename X>