Merge remote-tracking branch 'origin/master' into QPR-11721

Author: pcaspers

Docker/Dockerfile-Boost

@@ -5,7 +5,7 @@ MAINTAINER Quaternion Risk Management
 LABEL Description="Provide a base environment for building in C++ with Boost"
 
 RUN apt-get update && apt-get upgrade -y \
- && apt-get install -f -y build-essential wget libbz2-dev autoconf libtool dos2unix cmake zlib1g-dev \
+ && apt-get install -f -y build-essential wget libbz2-dev autoconf libtool dos2unix cmake zlib1g-dev opencl-headers ocl-icd-opencl-dev \
  && apt-get clean \
  && rm -rf /var/lib/apt/lists/*
 

Docker/Dockerfile-ORE

@@ -27,7 +27,7 @@ RUN cd /ore \
   && find -regex ".*\.\(sh\|in\|ac\|am\)" -exec dos2unix {} ';' \
   && cp Docker/CMakeLists_ORE.txt CMakeLists.txt \
   && mkdir -p build.ore && cd build.ore \
-  && cmake .. -DORE_BUILD_DOC=ON -DCMAKE_BUILD_TYPE=Release -DCMAKE_CXX_FLAGS="-mavx2" -DORE_ENABLE_PARALLEL_UNIT_TEST_RUNNER=ON
+  && cmake .. -DORE_BUILD_DOC=ON -DCMAKE_BUILD_TYPE=Release -DCMAKE_CXX_FLAGS="-mavx2" -DORE_ENABLE_PARALLEL_UNIT_TEST_RUNNER=ON -DORE_USE_ZLIB=ON
 
 WORKDIR /ore/build.ore
 RUN --mount=type=cache,target=/ccache/ make -j ${num_cores} \

Docker/Dockerfile-ORE-App

@@ -13,6 +13,7 @@ COPY OREAnalytics/test /ore/OREAnalytics/test
 RUN mkdir /ore/App
 
 COPY --from=env_ore /usr/local/bin /ore/App
+COPY --from=env_ore /usr/lib/x86_64-linux-gnu /usr/lib/x86_64-linux-gnu
 
 RUN true
 

Docs/UserGuide/computeenvironment.tex

@@ -140,11 +140,13 @@ instruments/tenorbasisswap.cpp
 instruments/varianceswap.cpp
 math/blockmatrixinverse.cpp
 math/bucketeddistribution.cpp
+math/computeenvironment.cpp
 math/deltagammavar.cpp
 math/differentialevolution_mt.cpp
 math/discretedistribution.cpp
 math/fillemptymatrix.cpp
 math/matrixfunctions.cpp
+math/openclenvironment.cpp
 math/randomvariable.cpp
 math/randomvariable_io.cpp
 methods/brownianbridgepathinterpolator.cpp
@@ -579,6 +581,7 @@ instruments/varianceswap.hpp
 interpolators/optioninterpolator2d.hpp
 math/blockmatrixinverse.hpp
 math/bucketeddistribution.hpp
+math/computeenvironment.hpp
 math/constantinterpolation.hpp
 math/covariancesalvage.hpp
 math/deltagammavar.hpp
@@ -591,10 +594,12 @@ math/logquadraticinterpolation.hpp
 math/matrixfunctions.hpp
 math/method_mt.hpp
 math/nadarayawatson.hpp
+math/openclenvironment.hpp
 math/problem_mt.hpp
 math/quadraticinterpolation.hpp
 math/randomvariable.hpp
 math/randomvariable_io.hpp
+math/randomvariable_opcodes.hpp
 math/stabilisedglls.hpp
 math/trace.hpp
 methods/brownianbridgepathinterpolator.hpp
@@ -917,6 +922,15 @@ writeAll("qle" "quantext.hpp" "auto_link.hpp" "${QuantExt_HDR}")
 add_library(${QLE_LIB_NAME} ${QuantExt_SRC})
 target_link_libraries(${QLE_LIB_NAME} ${QL_LIB_NAME} ${Boost_LIBRARIES})
 
+if(ORE_ENABLE_OPENCL)
+  if(APPLE)
+    target_link_libraries(${QLE_LIB_NAME} "-framework OpenCL")
+  else()
+    find_package(OpenCL REQUIRED)
+    target_link_libraries(${QLE_LIB_NAME} OpenCL::OpenCL)
+  endif()
+endif()
+
 install(DIRECTORY . DESTINATION include/qle
         FILES_MATCHING PATTERN "*.hpp" PATTERN "*.h")
 

QuantExt/qle/CMakeLists.txt

@@ -0,0 +1,86 @@
+/*
+ Copyright (C) 2023 Quaternion Risk Management Ltd
+ All rights reserved.
+
+ This file is part of ORE, a free-software/open-source library
+ for transparent pricing and risk analysis - http://opensourcerisk.org
+
+ ORE is free software: you can redistribute it and/or modify it
+ under the terms of the Modified BSD License.  You should have received a
+ copy of the license along with this program.
+ The license is also available online at <http://opensourcerisk.org>
+
+ This program is distributed on the basis that it will form a useful
+ contribution to risk analytics and model standardisation, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE. See the license for more details.
+*/
+
+#include <qle/math/computeenvironment.hpp>
+#include <qle/math/openclenvironment.hpp>
+
+#include <boost/algorithm/string/join.hpp>
+
+#include <ql/errors.hpp>
+
+#include <iostream>
+
+#ifdef ORE_ENABLE_OPENCL
+#ifdef __APPLE__
+#include <OpenCL/cl.h>
+#else
+#include <CL/cl.h>
+#endif
+#endif
+
+namespace QuantExt {
+
+ComputeEnvironment::ComputeEnvironment() { reset(); }
+
+ComputeEnvironment::~ComputeEnvironment() { releaseFrameworks(); }
+
+void ComputeEnvironment::releaseFrameworks() {
+    for (auto& f : frameworks_)
+        delete f;
+    frameworks_.clear();
+}
+
+void ComputeEnvironment::reset() {
+    currentContext_ = nullptr;
+    releaseFrameworks();
+    frameworks_.push_back(new OpenClFramework());
+}
+
+std::set<std::string> ComputeEnvironment::getAvailableDevices() const {
+    std::set<std::string> result;
+    for (auto const& f : frameworks_) {
+        auto tmp = f->getAvailableDevices();
+        result.insert(tmp.begin(), tmp.end());
+    }
+    return result;
+}
+
+bool ComputeEnvironment::hasContext() const { return currentContext_ != nullptr; }
+
+void ComputeEnvironment::selectContext(const std::string& deviceName) {
+    for (auto& f : frameworks_) {
+        if (auto tmp = f->getAvailableDevices(); tmp.find(deviceName) != tmp.end()) {
+            currentContext_ = f->getContext(deviceName);
+            currentContext_->init();
+            return;
+        }
+    }
+    QL_FAIL("ComputeEnvironment::selectContext(): device '"
+            << deviceName << "' not found. Available devices: " << boost::join(getAvailableDevices(), ","));
+}
+
+ComputeContext& ComputeEnvironment::context() { return *currentContext_; }
+
+void ComputeContext::finalizeCalculation(std::vector<std::vector<float>>& output) {
+    std::vector<float*> outputPtr(output.size());
+    std::transform(output.begin(), output.end(), outputPtr.begin(),
+                   [](std::vector<float>& v) -> float* { return &v[0]; });
+    finalizeCalculation(outputPtr);
+}
+
+}; // namespace QuantExt

QuantExt/qle/math/computeenvironment.cpp

@@ -0,0 +1,95 @@
+/*
+ Copyright (C) 2023 Quaternion Risk Management Ltd
+ All rights reserved.
+
+ This file is part of ORE, a free-software/open-source library
+ for transparent pricing and risk analysis - http://opensourcerisk.org
+
+ ORE is free software: you can redistribute it and/or modify it
+ under the terms of the Modified BSD License.  You should have received a
+ copy of the license along with this program.
+ The license is also available online at <http://opensourcerisk.org>
+
+ This program is distributed on the basis that it will form a useful
+ contribution to risk analytics and model standardisation, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE. See the license for more details.
+*/
+
+/*! \file qle/math/computeenvironment.hpp
+    \brief interface to compute envs
+*/
+
+#pragma once
+
+#include <ql/patterns/singleton.hpp>
+
+#include <set>
+
+namespace QuantExt {
+
+class ComputeContext;
+class ComputeFramework;
+
+class ComputeEnvironment : public QuantLib::Singleton<ComputeEnvironment> {
+public:
+    ComputeEnvironment();
+    ~ComputeEnvironment();
+    std::set<std::string> getAvailableDevices() const;
+    bool hasContext() const;
+    void selectContext(const std::string& deviceName);
+    ComputeContext& context();
+    void reset();
+
+private:
+    void releaseFrameworks();
+
+    std::vector<ComputeFramework*> frameworks_;
+    ComputeContext* currentContext_;
+};
+
+class ComputeFramework {
+public:
+    virtual ~ComputeFramework() {}
+    virtual std::set<std::string> getAvailableDevices() const = 0;
+    virtual ComputeContext* getContext(const std::string& deviceName) = 0;
+};
+
+class ComputeContext {
+public:
+    struct DebugInfo {
+        unsigned long numberOfOperations = 0;
+        unsigned long nanoSecondsDataCopy = 0;
+        unsigned long nanoSecondsProgramBuild = 0;
+        unsigned long nanoSecondsCalculation = 0;
+    };
+
+    virtual ~ComputeContext() {}
+    virtual void init() = 0;
+
+    virtual std::pair<std::size_t, bool> initiateCalculation(const std::size_t n, const std::size_t id = 0,
+                                                             const std::size_t version = 0,
+                                                             const bool debug = false) = 0;
+
+    virtual std::size_t createInputVariable(float v) = 0;
+    virtual std::size_t createInputVariable(float* v) = 0;
+    virtual std::vector<std::vector<std::size_t>> createInputVariates(const std::size_t dim, const std::size_t steps,
+                                                                      const std::uint32_t seed) = 0;
+
+    virtual std::size_t applyOperation(const std::size_t randomVariableOpCode,
+                                       const std::vector<std::size_t>& args) = 0;
+    virtual void freeVariable(const std::size_t id) = 0;
+    virtual void declareOutputVariable(const std::size_t id) = 0;
+
+    virtual void finalizeCalculation(std::vector<float*>& output) = 0;
+
+    // debug info
+
+    virtual const DebugInfo& debugInfo() const = 0;
+
+    // convenience methods
+
+    void finalizeCalculation(std::vector<std::vector<float>>& output);
+};
+
+} // namespace QuantExt