SDL (#97)

* (conda) build
  * adding pip, g++ and sysroot
  * adding -D__STDC_FORMAT_MACROS to compile flags: needed by conda g++ packages
  * not adding dpcpp because packages are incomplete, still require system dpcpp
* SDL
  * more error reporting through exceptions
  * checking buffer overflows
  * checking out-of-bounds accesses
  * NULL -> nullptr
  * string handling aligned with secure coding standard

Author: fschlimb

CMakeLists.txt

@@ -17,6 +17,11 @@ if(DEFINED ENV{IMEXROOT})
 else()
   set(IMEX_ROOT ${CONDA_PREFIX})
 endif()
+if(DEFINED ENV{ZLIBROOT})
+  set(ZLIB_ROOT $ENV{ZLIBROOT})
+else()
+  set(ZLIB_ROOT ${CONDA_PREFIX})
+endif()
 
 # C++ standard
 set(CMAKE_CXX_STANDARD 17)
@@ -35,7 +40,9 @@ message(STATUS "Expected IMEX sha: \"${EXPECTED_IMEX_SHA}\"")
 # Deps
 # ===============
 # Find dependent packages like IMEX, Python3 and NumPy
-find_package(ZLIB REQUIRED)
+# find_package(ZLIB REQUIRED)
+find_library(LIBZ z NAMES libz.so libz.so.1 REQUIRED PATHS ${ZLIB_ROOT}/lib)
+message("FOUND zlib ${LIBZ}")
 find_package(TBB REQUIRED)
 find_package(Python3 COMPONENTS Interpreter Development.Module NumPy REQUIRED)
 find_package(pybind11 CONFIG REQUIRED)
@@ -57,8 +64,9 @@ list(APPEND CMAKE_MODULE_PATH "${LLVM_CMAKE_DIR}")
 #include(AddMLIR)
 #include(AddIMEX)
 
-# macro for mlir root directory
-add_compile_definitions(CMAKE_MLIR_ROOT="${MLIR_ROOT}" CMAKE_IMEX_ROOT="${IMEX_ROOT}" FORTIFY_SOURCE=2)
+# macro for mlir/imex root directories
+# __STDC_FORMAT_MACROS for PRIxPTR et al
+add_compile_definitions(CMAKE_MLIR_ROOT="${MLIR_ROOT}" CMAKE_IMEX_ROOT="${IMEX_ROOT}" FORTIFY_SOURCE=2 __STDC_FORMAT_MACROS=1)
 add_compile_options(
     "-ftemplate-backtrace-limit=0"
     "$<$<STREQUAL:${CMAKE_CXX_COMPILER_ID},GNU>:-flarge-source-files>"
@@ -171,7 +179,7 @@ target_link_libraries(_sharpy PRIVATE
     LLVMX86AsmParser
     idtr
     TBB::tbb
-    ZLIB::ZLIB
+    ${LIBZ}
 )
 target_link_libraries(idtr PRIVATE
     ${MPI_CXX_LIBRARIES}

conda-recipe/build.sh

@@ -1,8 +1,13 @@
 # FIX dpcpp env
 set -ex
-export CC=gcc-11
-export CXX=g++-11
+if [ -n "${GCC}" ]; then
+    export CC=${GCC}
+fi
+if [ -n "${GXX}" ]; then
+    export CXX=${GXX}
+fi
 env
+conda list
 
 if [ -z ${GITHUB_WORKSPACE} ]; then
     INSTALLED_DIR=${SRC_DIR}/installed
@@ -31,7 +36,8 @@ if [ ! -d "${INSTALLED_DIR}/imex/lib" ]; then
             exit 1
         fi
     fi
-    echo "Found SYCLDIR=${SYCL_DIR}"
+    # export SYCL_DIR=${CONDA_PREFIX}
+    echo "Using SYCLDIR=${SYCL_DIR}"
 
     rm -rf ${INSTALLED_DIR}/imex
     IMEX_SHA=$(cat imex_version.txt)
@@ -64,9 +70,9 @@ if [ ! -d "${INSTALLED_DIR}/imex/lib" ]; then
     rm -rf build/CMakeFiles/ build/CMakeCache.txt
     cmake -S ./llvm-project/llvm -B build \
         -GNinja \
-        -DCMAKE_PREFIX_PATH=$CONDA_PREFIX/lib/cmake \
-        -DCMAKE_CXX_COMPILER=$CXX \
-        -DCMAKE_C_COMPILER=$CC \
+        -DCMAKE_PREFIX_PATH=${CONDA_PREFIX}/lib/cmake \
+        -DCMAKE_CXX_COMPILER=${CXX} \
+        -DCMAKE_C_COMPILER=${CC} \
         -DCMAKE_BUILD_TYPE=Release \
         -DLLVM_ENABLE_PROJECTS=mlir \
         -DLLVM_ENABLE_ASSERTIONS=ON \
@@ -77,15 +83,16 @@ if [ ! -d "${INSTALLED_DIR}/imex/lib" ]; then
         -DLLVM_ENABLE_ZSTD=OFF \
         -DLLVM_ENABLE_ZLIB=OFF \
         -DLLVM_EXTERNAL_PROJECTS="Imex"  \
-        -DIMEX_ENABLE_SYCL_RUNTIME=1 \
-        -DIMEX_ENABLE_L0_RUNTIME=1 \
         -DLLVM_EXTERNAL_IMEX_SOURCE_DIR=. \
-        -DLEVEL_ZERO_DIR=${INSTALLED_DIR}/level-zero
+        -DLEVEL_ZERO_DIR=${INSTALLED_DIR}/level-zero \
+        -DIMEX_ENABLE_SYCL_RUNTIME=1 \
+        -DIMEX_ENABLE_L0_RUNTIME=1
     cmake --build build
     cmake --install build --prefix=${INSTALLED_DIR}/imex
     popd
 else
     echo "Found IMEX install, skipped building IMEX"
 fi
 
-MLIRROOT=${INSTALLED_DIR}/imex IMEXROOT=${INSTALLED_DIR}/imex ${PYTHON} -m pip install . -vv
+ls -l ${CONDA_PREFIX}/lib
+ZLIBROOT=${CONDA_PREFIX} MLIRROOT=${INSTALLED_DIR}/imex IMEXROOT=${INSTALLED_DIR}/imex ${PYTHON} -m pip install . -vv

conda-recipe/meta.yaml

@@ -12,6 +12,7 @@ source:
 
 requirements:
   host:
+    - pip
     - python
     - cmake >=3.26
     - git
@@ -23,8 +24,13 @@ requirements:
     - impi-devel
     - mpi4py
     - wheel
+    - libzlib
+
   build:
-    # - {{compiler('cxx')}}
+    - {{compiler('gxx')}}
+    - sysroot_linux-64 >=2.28  # [linux]
+    # - dpcpp_linux-64  # [linux]
+    # - dpcpp_win-64  # [win]
     # - {{compiler('dpcpp')}} >={{required_compiler_and_mkl_version}},!={{excluded_compiler_version1}},!={{excluded_compiler_version2}} # [not osx]
   run:
     - numpy x.x
@@ -38,6 +44,8 @@ build:
     - GITHUB_WORKSPACE
 
 test:
+  # requires:
+  #   - pytest
   script_env:
     - GITHUB_WORKSPACE
   imports:

src/Creator.cpp

@@ -66,7 +66,7 @@ struct DeferredFull : public Deferred {
       } else if constexpr (std::is_integral_v<T>) {
         return ::imex::createInt(loc, builder, val._int, sizeof(T) * 8);
       }
-      assert("Unsupported dtype in dispatch");
+      throw std::runtime_error("Unsupported dtype in dispatch");
       return {};
     };
   };

src/IO.cpp

@@ -86,12 +86,17 @@ struct DeferredFromLocal : public Deferred {
 };
 
 GetItem::py_future_type IO::to_numpy(const FutureArray &a) {
-  assert(!getTransceiver()->is_cw() || getTransceiver()->rank() == 0);
+  if (getTransceiver()->is_cw() && getTransceiver()->rank() != 0) {
+    throw std::runtime_error(
+        "In c/w mode, to_numpy is only supported on rank 0");
+  }
   return GetItem::gather(a, getTransceiver()->is_cw() ? 0 : REPLICATED);
 }
 
 FutureArray *IO::from_locals(const std::vector<py::array> &a) {
-  assert(a.size() == 1);
+  if (a.size() != 1) {
+    throw std::runtime_error("from_locals only supports a single local array");
+  }
   return new FutureArray(defer<DeferredFromLocal>(a.front()));
 }
 

src/MPIMediator.cpp

@@ -113,6 +113,9 @@ void send_to_workers(const Runable *dfrd, bool self, MPI_Comm comm) {
     ser.value<sizeof(tag)>(tag);
   }
   ser.adapter().flush();
+  if (ser.adapter().writtenBytesCount() > INT_MAX) {
+    throw std::runtime_error("Message too large for MPI (int count).");
+  }
   int cnt = static_cast<int>(ser.adapter().writtenBytesCount());
 
   if (self) {

src/MPITransceiver.cpp

@@ -22,7 +22,7 @@ MPITransceiver::MPITransceiver(bool is_cw)
   MPI_Initialized(&flag);
   if (!flag) {
     int provided;
-    MPI_Init_thread(NULL, NULL, MPI_THREAD_MULTIPLE, &provided);
+    MPI_Init_thread(nullptr, nullptr, MPI_THREAD_MULTIPLE, &provided);
     if (provided < MPI_THREAD_MULTIPLE) {
       throw std::runtime_error(
           "Your MPI implementation is not MPI_THREAD_MULTIPLE. "
@@ -36,6 +36,8 @@ MPITransceiver::MPITransceiver(bool is_cw)
     std::cerr << "MPI already initialized\n";
   }
 
+  // always abort if an MPI error occured
+  MPI_Errhandler_set(MPI_COMM_WORLD, MPI_ERRORS_ARE_FATAL);
   int nranks, rank;
   MPI_Comm_rank(_comm, &rank);
   MPI_Comm parentComm;
@@ -49,7 +51,7 @@ MPITransceiver::MPITransceiver(bool is_cw)
     int nClientsToSpawn = get_int_env("SHARPY_MPI_SPAWN", 0);
     if (nClientsToSpawn) {
       std::vector<std::string> args;
-      std::string clientExe = get_text_env("SHARPY_MPI_EXECUTABLE");
+      auto clientExe = get_text_env("SHARPY_MPI_EXECUTABLE");
       std::string exeArgs;
       if (clientExe.empty()) {
         auto pythonExe = get_text_env("PYTHON_EXE");
@@ -78,7 +80,7 @@ MPITransceiver::MPITransceiver(bool is_cw)
         }
       }
 
-      const char *clientArgs[args.size() + 1];
+      std::vector<const char *> clientArgs(args.size() + 1);
       for (auto i = 0ul; i < args.size(); ++i)
         clientArgs[i] = args[i].c_str();
       clientArgs[args.size()] = nullptr;
@@ -100,10 +102,10 @@ MPITransceiver::MPITransceiver(bool is_cw)
                 << std::endl;
       int *errCodes = new int[nClientsToSpawn];
       MPI_Comm interComm;
-      int err =
-          MPI_Comm_spawn(const_cast<char *>(clientExe.c_str()),
-                         const_cast<char **>(clientArgs), nClientsToSpawn,
-                         clientInfo, 0, MPI_COMM_WORLD, &interComm, errCodes);
+      int err = MPI_Comm_spawn(const_cast<char *>(clientExe.c_str()),
+                               const_cast<char **>(clientArgs.data()),
+                               nClientsToSpawn, clientInfo, 0, MPI_COMM_WORLD,
+                               &interComm, errCodes);
       delete[] errCodes;
       if (err) {
         std::cerr << "[SHARPY " << rank

src/ManipOp.cpp

@@ -61,7 +61,7 @@ struct DeferredReshape : public Deferred {
                            o_sizes, o_strides, r_allocated, r_aligned, r_offset,
                            r_sizes, r_strides, std::move(loffs));
           if (_copy != COPY_ALWAYS) {
-            assert(!"copy-free reshape not supported");
+            throw std::runtime_error("copy-free reshape not supported");
             if (Registry::has(_a)) {
               t->set_base(Registry::get(_a).get());
             } // else _a is a temporary and was dropped
@@ -106,7 +106,10 @@ struct DeferredAsType : public Deferred {
     ::imex::ndarray::DType ndDType = dispatch<convDType>(dtype);
     auto mlirElType = ::imex::ndarray::toMLIR(builder, ndDType);
     auto arType = av.getType().dyn_cast<::imex::ndarray::NDArrayType>();
-    assert(arType);
+    if (!arType) {
+      throw std::runtime_error(
+          "Encountered unexpected ndarray type in astype.");
+    }
     auto outType = arType.cloneWith(std::nullopt, mlirElType);
     auto res = builder.create<::imex::ndarray::CastElemTypeOp>(loc, outType, av,
                                                                copyAttr);
@@ -154,7 +157,10 @@ struct DeferredToDevice : public Deferred {
     auto av = dm.getDependent(builder, Registry::get(_a));
 
     auto srcType = av.getType().dyn_cast<::imex::ndarray::NDArrayType>();
-    assert(srcType);
+    if (!srcType) {
+      throw std::runtime_error(
+          "Encountered unexpected ndarray type in to_device.");
+    }
     // copy envs, drop gpu env (if any)
     auto srcEnvs = srcType.getEnvironments();
     ::mlir::SmallVector<::mlir::Attribute> envs;
@@ -205,7 +211,7 @@ FutureArray *ManipOp::reshape(const FutureArray &a, const shape_type &shape,
                     : (copy.cast<bool>() ? DeferredReshape::COPY_ALWAYS
                                          : DeferredReshape::COPY_NEVER);
   if (doCopy == DeferredReshape::COPY_NEVER) {
-    assert(!"zero-copy reshape not supported");
+    throw std::runtime_error("zero-copy reshape not supported");
   }
   doCopy = DeferredReshape::COPY_ALWAYS;
   return new FutureArray(defer<DeferredReshape>(a.get(), shape, doCopy));

src/NDArray.cpp

@@ -19,7 +19,7 @@ namespace py = pybind11;
 namespace SHARPY {
 
 NDArray::NDArray(id_type guid_, DTypeId dtype_, shape_type gShape,
-                 std::string device_, uint64_t team_, void *l_allocated,
+                 const std::string &device_, uint64_t team_, void *l_allocated,
                  void *l_aligned, intptr_t l_offset, const intptr_t *l_sizes,
                  const intptr_t *l_strides, void *o_allocated, void *o_aligned,
                  intptr_t o_offset, const intptr_t *o_sizes,
@@ -38,11 +38,10 @@ NDArray::NDArray(id_type guid_, DTypeId dtype_, shape_type gShape,
   if (ndims() == 0) {
     _owner = REPLICATED;
   }
-  assert(team() == 0 || transceiver() == getTransceiver());
 }
 
 NDArray::NDArray(id_type guid_, DTypeId dtype_, const shape_type &shp,
-                 std::string device_, uint64_t team_, rank_type owner)
+                 const std::string &device_, uint64_t team_, rank_type owner)
     : ArrayMeta(guid_, dtype_, shp, device_, team_), _owner(owner) {
 
   auto esz = sizeof_dtype(dtype_);
@@ -60,24 +59,22 @@ NDArray::NDArray(id_type guid_, DTypeId dtype_, const shape_type &shp,
     stride *= shp[i];
   }
   _lData = DynMemRef(nds, allocated, allocated, 0, sizes, strides);
-  assert(team() == 0 || transceiver() == getTransceiver());
   delete[] sizes;
   delete[] strides;
 }
 
 // incomplete, useful for computing meta information
 NDArray::NDArray(id_type guid_, const int64_t *shape, uint64_t N,
-                 std::string device_, uint64_t team_, rank_type owner)
+                 const std::string &device_, uint64_t team_, rank_type owner)
     : ArrayMeta(guid_, DTYPE_LAST, {shape, shape + N}, device_, team_),
       _owner(owner) {
   assert(ndims() <= 1);
-  assert(team() == 0 || transceiver() == getTransceiver());
 }
 
 // from numpy
 NDArray::NDArray(id_type guid_, DTypeId dtype_, ssize_t ndims,
                  const ssize_t *shape, const intptr_t *strides, void *data,
-                 std::string device_, uint64_t team_)
+                 const std::string &device_, uint64_t team_)
     : ArrayMeta(guid_, dtype_, {shape, shape + ndims}, device_, team_),
       _owner(NOOWNER),
       _lData(ndims, data, data, 0, reinterpret_cast<const intptr_t *>(shape),

src/PVSlice.cpp

@@ -110,7 +110,9 @@ int PVSlice::split_dim() const { return _base->split_dim(); }
 bool PVSlice::is_sliced() const { return base_shape() != shape(); }
 
 bool PVSlice::local_is_contiguous(rank_type rank) const {
-  assert(split_dim() == 0);
+  if (split_dim() != 0) {
+    throw std::runtime_error("Only split_dim == 0 is supported.");
+  }
   auto tshp = tile_shape(rank);
   auto tslc = tile_slice(rank);
   for (auto i = 0; i < ndims(); ++i) {