Verify environment variables (#94)

Author: tkarna

.bandit.yml

@@ -83,12 +83,12 @@
 # IPAS Required Checkers. Do not disable these
 # Additional checkers may be added if desired
 tests:
-  [ 'B301', 'B302', 'B303', 'B304', 'B305', 'B306', 'B308', 'B310', 'B311', 'B312', 'B313', 'B314', 'B315', 'B316', 'B317', 'B318', 'B319', 'B320', 'B321', 'B323', 'B324', 'B401', 'B402', 'B403', 'B404', 'B405', 'B406', 'B407', 'B408', 'B409', 'B410', 'B411', 'B412', 'B413']
+  [ 'B301', 'B302', 'B303', 'B304', 'B305', 'B306', 'B308', 'B310', 'B311', 'B312', 'B313', 'B314', 'B315', 'B316', 'B317', 'B318', 'B319', 'B320', 'B321', 'B323', 'B324', 'B401', 'B402', 'B403', 'B405', 'B406', 'B407', 'B408', 'B409', 'B410', 'B411', 'B412', 'B413']
 
 # (optional) list skipped test IDs here, eg '[B101, B406]':
 # The following checkers are not required but be added to tests list if desired
 skips:
-  [ 'B101', 'B102', 'B103', 'B104', 'B105', 'B106', 'B107', 'B108', 'B110', 'B112', 'B201', 'B501', 'B502', 'B503', 'B504', 'B505', 'B506', 'B507', 'B601', 'B602', 'B603', 'B604', 'B605', 'B606', 'B607', 'B608', 'B609', 'B610', 'B611', 'B701', 'B702', 'B703']
+  [ 'B101', 'B102', 'B103', 'B104', 'B105', 'B106', 'B107', 'B108', 'B110', 'B112', 'B201', 'B404', 'B501', 'B502', 'B503', 'B504', 'B505', 'B506', 'B507', 'B601', 'B602', 'B603', 'B604', 'B605', 'B606', 'B607', 'B608', 'B609', 'B610', 'B611', 'B701', 'B702', 'B703']
 
 ### (optional) plugin settings - some test plugins require configuration data
 ### that may be given here, per-plugin. All bandit test plugins have a built in

.github/workflows/ci.yml

@@ -26,16 +26,16 @@ jobs:
           token: ${{ secrets.PATIMEX }}
           path: third_party/imex
           ref: ${{ env.IMEX_SHA }}
-      - name: Cache miniconda
-        id: cache-miniconda
-        uses: actions/cache@v3
-        env:
-          MINICONDA_CACHE_NUMBER: 2  # Increase to reset cache
-        with:
-          path: third_party/install/miniconda/**
-          key: ${{ runner.os }}-miniconda-${{ env.MINICONDA_CACHE_NUMBER }}-${{ hashFiles('conda-env.txt') }}
+      # - name: Cache miniconda
+      #   id: cache-miniconda
+      #   uses: actions/cache@v3
+      #   env:
+      #     MINICONDA_CACHE_NUMBER: 2  # Increase to reset cache
+      #   with:
+      #     path: third_party/install/miniconda/**
+      #     key: ${{ runner.os }}-miniconda-${{ env.MINICONDA_CACHE_NUMBER }}-${{ hashFiles('conda-env.txt') }}
       - name: Miniconda
-        if: steps.cache-miniconda.outputs.cache-hit != 'true'
+        # if: steps.cache-miniconda.outputs.cache-hit != 'true'
         run: |
           rm -rf "$GITHUB_WORKSPACE"/third_party/install/miniconda
           mkdir -p "$GITHUB_WORKSPACE"/third_party/install
@@ -50,12 +50,12 @@ jobs:
           cd -
           conda create --file conda-env.txt --name sharpy
           conda clean -a -y
-      - name: Setup miniconda
-        if: steps.cache-miniconda.outputs.cache-hit == 'true'
-        run: |
-          echo "$GITHUB_WORKSPACE/third_party/install/miniconda/bin" >> $GITHUB_PATH
-          echo "$GITHUB_WORKSPACE/third_party/install/miniconda/condabin" >> $GITHUB_PATH
-          export PATH=$GITHUB_WORKSPACE/third_party/install/miniconda/bin:${PATH}
+      # - name: Setup miniconda
+      #   if: steps.cache-miniconda.outputs.cache-hit == 'true'
+      #   run: |
+      #     echo "$GITHUB_WORKSPACE/third_party/install/miniconda/bin" >> $GITHUB_PATH
+      #     echo "$GITHUB_WORKSPACE/third_party/install/miniconda/condabin" >> $GITHUB_PATH
+      #     export PATH=$GITHUB_WORKSPACE/third_party/install/miniconda/bin:${PATH}
       - name: Setup LLVM Cache Var
         run: |
           echo 'LLVM_SHA<<EOF' >> $GITHUB_ENV

README.md

@@ -34,7 +34,7 @@ If your compiler does not default to a recent (e.g. g++ >= 9) version, try somet
 # single rank
 pytest test
 # distributed on multiple ($N) ranks/processes
-SHARPY_IDTR_SO=`pwd`/sharpy/libidtr.so mpirun -n $N python -m pytest test
+mpirun -n $N python -m pytest test
 ```
 
 ## Running
@@ -57,13 +57,13 @@ sp.fini()
 Assuming the above is in file `simple.py` a single-process run is executed like
 
 ```bash
-SHARPY_IDTR_SO=`pwd`/sharpy/libidtr.so python simple.py
+python simple.py
 ```
 
 and multi-process run is executed like
 
 ```bash
-SHARPY_IDTR_SO=`pwd`/sharpy/libidtr.so mpirun -n 5 python simple.py
+mpirun -n 5 python simple.py
 ```
 
 ### Distributed Execution without mpirun
@@ -76,7 +76,7 @@ Additionally SHARPY_MPI_HOSTS can be used to control the host to use for spawnin
 The following command will run the stencil example on 3 MPI ranks:
 
 ```bash
-SHARPY_IDTR_SO=`pwd`/sharpy/libidtr.so \
+SHARPY_FALLBACK=numpy \
   SHARPY_MPI_SPAWN=2 \
   SHARPY_MPI_EXECUTABLE=`which python` \
   SHARPY_MPI_EXE_ARGS="examples/stencil-2d.py 10 2000 star 2" \

examples/black_scholes.py

@@ -176,7 +176,7 @@ def run(nopt, backend, iterations, datatype):
         import sharpy as np
         from sharpy import fini, init, sync
 
-        device = os.getenv("SHARPY_USE_GPU", "")
+        device = os.getenv("SHARPY_DEVICE", "")
         create_full = partial(np.full, device=device)
         erf = np.erf
 

examples/shallow_water.py

@@ -55,7 +55,7 @@ def run(n, backend, datatype, benchmark_mode):
         from sharpy import fini, init, sync
         from sharpy.numpy import fromfunction as _fromfunction
 
-        device = os.getenv("SHARPY_USE_GPU", "")
+        device = os.getenv("SHARPY_DEVICE", "")
         create_full = partial(np.full, device=device)
         fromfunction = partial(_fromfunction, device=device)
 

examples/stencil-2d.py

@@ -118,7 +118,7 @@ def main():
     print("Data type            = double precision")
     print("Compact representation of stencil loop body")
 
-    device = os.getenv("SHARPY_USE_GPU", "")
+    device = os.getenv("SHARPY_DEVICE", "")
 
     # there is certainly a more Pythonic way to initialize W,
     # but it will have no impact on performance.

examples/wave_equation.py

@@ -55,7 +55,7 @@ def run(n, backend, datatype, benchmark_mode):
         from sharpy import fini, init, sync
         from sharpy.numpy import fromfunction as _fromfunction
 
-        device = os.getenv("SHARPY_USE_GPU", "")
+        device = os.getenv("SHARPY_DEVICE", "")
         create_full = partial(np.full, device=device)
         fromfunction = partial(_fromfunction, device=device)
 

sharpy/__init__.py

@@ -13,6 +13,8 @@
 # At this point there are no checks of input arguments whatsoever, arguments
 # are simply forwarded as-is.
 
+import os
+import re
 from importlib import import_module
 from os import getenv
 from typing import Any
@@ -42,8 +44,11 @@
 
 
 def init(cw=None):
+    libidtr = os.path.join(os.path.dirname(__file__), "libidtr.so")
+    assert os.path.isfile(libidtr), "libidtr.so not found"
+
     cw = _sharpy_cw if cw is None else cw
-    _init(cw)
+    _init(cw, libidtr)
 
 
 def to_numpy(a):
@@ -64,31 +69,42 @@ def to_numpy(a):
             f"{op} = lambda this: ndarray(_csp.EWUnyOp.op(_csp.{OP}, this._t))"
         )
 
+
+def _validate_device(device):
+    if len(device) == 0 or re.search(
+        r"^((opencl|level-zero|cuda):)?(host|gpu|cpu|accelerator)(:\d+)?$",
+        device,
+    ):
+        return device
+    else:
+        raise ValueError(f"Invalid device string: {device}")
+
+
 for func in api.api_categories["Creator"]:
     FUNC = func.upper()
     if func == "full":
         exec(
-            f"{func} = lambda shape, val, dtype=float64, device='', team=1: ndarray(_csp.Creator.full(shape, val, dtype, device, team))"
+            f"{func} = lambda shape, val, dtype=float64, device='', team=1: ndarray(_csp.Creator.full(shape, val, dtype, _validate_device(device), team))"
         )
     elif func == "empty":
         exec(
-            f"{func} = lambda shape, dtype=float64, device='', team=1: ndarray(_csp.Creator.full(shape, None, dtype, device, team))"
+            f"{func} = lambda shape, dtype=float64, device='', team=1: ndarray(_csp.Creator.full(shape, None, dtype, _validate_device(device), team))"
         )
     elif func == "ones":
         exec(
-            f"{func} = lambda shape, dtype=float64, device='', team=1: ndarray(_csp.Creator.full(shape, 1, dtype, device, team))"
+            f"{func} = lambda shape, dtype=float64, device='', team=1: ndarray(_csp.Creator.full(shape, 1, dtype, _validate_device(device), team))"
         )
     elif func == "zeros":
         exec(
-            f"{func} = lambda shape, dtype=float64, device='', team=1: ndarray(_csp.Creator.full(shape, 0, dtype, device, team))"
+            f"{func} = lambda shape, dtype=float64, device='', team=1: ndarray(_csp.Creator.full(shape, 0, dtype, _validate_device(device), team))"
         )
     elif func == "arange":
         exec(
-            f"{func} = lambda start, end, step, dtype=int64, device='', team=1: ndarray(_csp.Creator.arange(start, end, step, dtype, device, team))"
+            f"{func} = lambda start, end, step, dtype=int64, device='', team=1: ndarray(_csp.Creator.arange(start, end, step, dtype, _validate_device(device), team))"
         )
     elif func == "linspace":
         exec(
-            f"{func} = lambda start, end, step, endpoint, dtype=float64, device='', team=1: ndarray(_csp.Creator.linspace(start, end, step, endpoint, dtype, device, team))"
+            f"{func} = lambda start, end, step, endpoint, dtype=float64, device='', team=1: ndarray(_csp.Creator.linspace(start, end, step, endpoint, dtype, _validate_device(device), team))"
         )
 
 for func in api.api_categories["ReduceOp"]:
@@ -116,10 +132,17 @@ def to_numpy(a):
 
 _fb_env = getenv("SHARPY_FALLBACK")
 if _fb_env is not None:
+    if not _fb_env.isalnum():
+        raise ValueError(f"Invalid SHARPY_FALLBACK value '{_fb_env}'")
 
     class _fallback:
         "Fallback to whatever is provided in SHARPY_FALLBACK"
-        _fb_lib = import_module(_fb_env)
+        try:
+            _fb_lib = import_module(_fb_env)
+        except ModuleNotFoundError:
+            raise ValueError(
+                f"Invalid SHARPY_FALLBACK value '{_fb_env}': module not found"
+            )
 
         def __init__(self, fname: str, mod=None) -> None:
             """get callable with name 'fname' from fallback-lib

src/Creator.cpp

@@ -22,7 +22,7 @@
 
 namespace SHARPY {
 
-static const char *FORCE_DIST = getenv("SHARPY_FORCE_DIST");
+static bool FORCE_DIST = get_bool_env("SHARPY_FORCE_DIST");
 
 inline uint64_t mkTeam(uint64_t team) {
   if (team && (FORCE_DIST || getTransceiver()->nranks() > 1)) {

src/Deferred.cpp

@@ -81,15 +81,15 @@ void Runable::fini() { _deferred.clear(); }
 // When execution is needed, the function signature (input args, return
 // statement) is finalized, the function gets compiled and executed. The loop
 // completes by calling run() on the requesting object.
-void process_promises() {
+void process_promises(const std::string &libidtr) {
   int vtProcessSym, vtSHARPYClass, vtPopSym;
   VT(VT_classdef, "sharpy", &vtSHARPYClass);
   VT(VT_funcdef, "process", vtSHARPYClass, &vtProcessSym);
   VT(VT_funcdef, "pop", vtSHARPYClass, &vtPopSym);
   VT(VT_begin, vtProcessSym);
 
   bool done = false;
-  jit::JIT jit;
+  jit::JIT jit(libidtr);
   std::vector<Runable::ptr_type> deleters;
 
   do {

src/MPITransceiver.cpp

@@ -5,6 +5,8 @@
 */
 
 #include "sharpy/MPITransceiver.hpp"
+#include "sharpy/UtilsAndTypes.hpp"
+#include <fstream>
 #include <iostream>
 #include <limits>
 #include <mpi.h>
@@ -44,28 +46,32 @@ MPITransceiver::MPITransceiver(bool is_cw)
     // Ok, let's spawn the clients.
     // I need some information for the startup.
     // 1. Name of the executable (default is the current exe)
-    const char *_tmp = getenv("SHARPY_MPI_SPAWN");
-    if (_tmp) {
-      int nClientsToSpawn = atol(_tmp);
-      std::string clientExe;
+    int nClientsToSpawn = get_int_env("SHARPY_MPI_SPAWN", 0);
+    if (nClientsToSpawn) {
       std::vector<std::string> args;
-      _tmp = getenv("SHARPY_MPI_EXECUTABLE");
-      if (!_tmp) {
-        _tmp = getenv("PYTHON_EXE");
-        if (!_tmp)
+      std::string clientExe = get_text_env("SHARPY_MPI_EXECUTABLE");
+      std::string exeArgs;
+      if (clientExe.empty()) {
+        auto pythonExe = get_text_env("PYTHON_EXE");
+        if (pythonExe.empty())
           throw std::runtime_error("Spawning MPI processes requires setting "
                                    "'SHARPY_MPI_EXECUTABLE' or 'PYTHON_EXE'");
-        clientExe = _tmp;
+        if (!std::ifstream(pythonExe)) {
+          throw std::runtime_error("Invalid PYTHON_EXE");
+        }
+        clientExe = pythonExe;
         // 2. arguments
-        _tmp = "-c import sharpy as sp; sp.init(True)";
+        exeArgs += " -c import sharpy as sp; sp.init(True)";
         args.push_back("-c");
         args.push_back("import sharpy as sp; sp.init(True)");
       } else {
-        clientExe = _tmp;
+        if (!std::ifstream(clientExe)) {
+          throw std::runtime_error("Invalid SHARPY_MPI_EXECUTABLE.");
+        }
         // 2. arguments
-        _tmp = getenv("SHARPY_MPI_EXE_ARGS");
-        if (_tmp) {
-          std::istringstream iss(_tmp);
+        exeArgs = get_text_env("SHARPY_MPI_EXE_ARGS");
+        if (!exeArgs.empty()) {
+          std::istringstream iss(exeArgs);
           std::copy(std::istream_iterator<std::string>(iss),
                     std::istream_iterator<std::string>(),
                     std::back_inserter(args));
@@ -78,20 +84,19 @@ MPITransceiver::MPITransceiver(bool is_cw)
       clientArgs[args.size()] = nullptr;
 
       // 3. Special setting for MPI_Info: hosts
-      const char *clientHost = getenv("SHARPY_MPI_HOSTS");
-
+      auto clientHost = get_text_env("SHARPY_MPI_HOSTS");
       // Prepare MPI_Info object:
       MPI_Info clientInfo = MPI_INFO_NULL;
-      if (clientHost) {
+      if (!clientHost.empty()) {
         MPI_Info_create(&clientInfo);
         MPI_Info_set(clientInfo, const_cast<char *>("host"),
-                     const_cast<char *>(clientHost));
+                     const_cast<char *>(clientHost.c_str()));
         std::cerr << "[SHARPY " << rank << "] Set MPI_Info_set(\"host\", \""
                   << clientHost << "\")\n";
       }
       // Now spawn the client processes:
       std::cerr << "[SHARPY " << rank << "] Spawning " << nClientsToSpawn
-                << " MPI processes (" << clientExe << " " << _tmp << ")"
+                << " MPI processes (" << clientExe << " " << exeArgs << ")"
                 << std::endl;
       int *errCodes = new int[nClientsToSpawn];
       MPI_Comm interComm;

src/_sharpy.cpp

@@ -44,6 +44,7 @@ using namespace pybind11::literals; // to bring _a
 #include "sharpy/itac.hpp"
 #include "sharpy/jit/mlir.hpp"
 
+#include <fstream>
 #include <iostream>
 
 namespace SHARPY {
@@ -96,23 +97,27 @@ void fini() {
   finied = true;
 }
 
-void init(bool cw) {
+void init(bool cw, std::string libidtr) {
   if (inited)
     return;
 
+  if (!std::ifstream(libidtr)) {
+    throw std::runtime_error(std::string("Cannot find libidtr.so"));
+  }
+
   init_transceiver(new MPITransceiver(cw));
   init_mediator(new MPIMediator());
   int cpu = sched_getcpu();
   std::cerr << "rank " << getTransceiver()->rank() << " is running on core "
             << cpu << std::endl;
   if (cw) {
     if (getTransceiver()->rank()) {
-      process_promises();
+      process_promises(libidtr);
       fini();
       exit(0);
     }
   }
-  pprocessor = new std::thread(process_promises);
+  pprocessor = new std::thread(process_promises, libidtr);
   inited = true;
   finied = false;
 }