git subrepo pull (merge) ore

jenkins · jenkins · commit 67f99f5b4563 · 2024-04-16T14:17:24.000Z
subrepo: subdir: "ore" merged: "3b09ab42ed" upstream: origin: "git@gitlab.acadiasoft.net:qs/ore.git" branch: "master" commit: "95d7cf31b5" git-subrepo: version: "0.4.6" origin: "https://github.com/ingydotnet/git-subrepo" commit: "73a0129"
diff --git a/Docs/ComputeEnvironment/computeenvironment.tex b/Docs/ComputeEnvironment/computeenvironment.tex
@@ -89,6 +89,7 @@ \section*{Document History}
 Date & Author & Comment \\
 \hline
 19 June 2023 & Acadia & initial release\\
+15 April 2024 & Acadia & refactor context settings, add supportsDoublePrecision()\\
 \hline
 \end{supertabular}
 \end{flushleft}
@@ -222,7 +223,7 @@ \subsection{Implementation of the ComputeFramework interface}\label{implComputeF
   Notice that the same device can appear under several frameworks, e.g. a GPU could be accessed both via an OpenCL
   driver or via a CUDA driver.
 \item \verb+getContext()+ should return a raw pointer to a \verb+ComputeContext+ implementation for a given device label
-  or throw an erro if the device label is not valid. See \ref{implComputeContext} for more details.
+  or throw an error if the device label is not valid. See \ref{implComputeContext} for more details.
 \item \verb+Destructor+ The destructor of \verb+ComputeFramework+ is virtual and has an empty default implementation. It
   can be override in implementations to free ressources. For example, the \verb+OpenClFramework+ implementation stores
   raw pointers for each compute contexts that need to be deleted on destruction of the \verb+OpenClFramework+ instance.
@@ -251,9 +252,19 @@ \subsection{Implementation of the ComputeContext interface}\label{implComputeCon
     previous calculation. In this case only the input variables and random variates (see below) need to be set to
     retrieve the results of the calculation calling \verb+finalizeCalculation()+. If \verb+id+ is \verb+0+ on the other
     hand, a new calculation \verb+id+ will be generated and returned.
-  \item \verb+version+: The version of a calculation.
-  \item \verb+debug+: A flag indicating whether debug information on the number of performed operations and timings for
-    data copying, kernel building and calculations should be collected.
+  \item \verb+version+: The version of a calculation. This is a freely choosable integer, which is only used to identify
+    different versions. Usually the first version of a calculation will be $0$, then next $1$, etc.
+  \item \verb+Settings+: A struct summarizing settings for the compute environment:
+    \begin{itemize}
+      \item debug: a flag indicating whether debug information on the number of performed operations and timings for
+    data copying, kernel building and calculations should be collected. Defaults to false.
+      \item useDoublePrecision: a flag indicating whether double precision should be used for calculations. Defaults to
+        false.
+      \item rngSequenceType: the sequence type for random number generation. One of MersenneTwister,
+        MersenneTwisterAntithetic, Sobol, Burley2020Sobol, SobolBrownianBridge, Burley2020SobolBrownianBridge
+      \item seed: the seed for the random number generator
+      \item regressionOrder: the regression order to be used within regression models
+    \end{itemize}
   \end{itemize}
   The output parameter is a pair consisting of
   \begin{itemize}
@@ -268,8 +279,6 @@ \subsection{Implementation of the ComputeContext interface}\label{implComputeCon
   \begin{itemize}
   \item \verb+dim+ the dimension (typically the number of assets in a MC simulation)
   \item \verb+steps+ the number of steps (typically the number of time steps in a MC simulation)
-  \item \verb+seed+ the seed of the random number generation, equal seeds must generate identical variates, different
-    seeds might or might not generate different variates
   \end{itemize}
   The output parameter is a vector of a vector of ids for the generated variates. The inner vector loops of the steps,
   the outer vector over the dimensions.
@@ -281,6 +290,8 @@ \subsection{Implementation of the ComputeContext interface}\label{implComputeCon
 \item \verb+finalizeCalculation()+: execute the calculation and populate the given vector of vector of floats with the
   result. The inner vector is given as a raw pointer and must have the size of the calculation. The outer vector matches
   the output variables in the order they were declared before.
+\item \verb+deviceInfo()+: provide key-value pairs that describes the device, only used for information purposes
+\item \verb+supportsDoublePreicions()+: should return true if doule precision is supported, otherwise false
 \item \verb+debugInfo()+: provide info on the number of elementary operations and timings on data copying, program build
   and calculations. This info is collected if a new calculation is started with flag debug set to true
 \end{itemize}
@@ -428,7 +439,7 @@ \subsection{Populating the input variates}
 if (useExternalComputeFramework_ && newExternalCalc) {
     auto gen =
         ComputeEnvironment::instance().context().
-                   createInputVariates(rv.size(), rv.front().size(), 42);
+                   createInputVariates(rv.size(), rv.front().size());
     for (Size k = 0; k < rv.size(); ++k) {
         for (Size j = 0; j < rv.front().size(); ++j)
             valuesExternal[rv[k][j]] = ExternalRandomVariable(gen[k][j]);
diff --git a/Docs/ScriptedTrade/docs/models.tex b/Docs/ScriptedTrade/docs/models.tex
@@ -152,6 +152,7 @@ \subsection{Pricing Engine Configuration}\label{pricingengine_config}
   UseExternalComputingDevice is true, this implies that UseCG is true irrespective of how it is configured.
 \item UseExternalComputingDevice: If true and RunType is not NPV (generating additional results) and AD sensitivities
   are {\em not} used, an external compute device is used for the calculations.
+\item UseDoublePrecisionForExternalCalculation: Use double precision for external computations. Defaults to false.
 \item ExternalComputeDevice: The external compute device to use if UseExternalComputingDevice is effective.
 \end{itemize}
 
diff --git a/OREData/ored/portfolio/builders/scriptedtrade.cpp b/OREData/ored/portfolio/builders/scriptedtrade.cpp
@@ -264,6 +264,7 @@ ScriptedTradeEngineBuilder::engine(const std::string& id, const ScriptedTrade& s
     DLOG("useCg                = " << std::boolalpha << useCg_);
     DLOG("useAd                = " << std::boolalpha << useAd_);
     DLOG("useExternalDevice    = " << std::boolalpha << useExternalComputeDevice_);
+    DLOG("useDblPrecExtCalc    = " << std::boolalpha << useDoublePrecisionForExternalCalculation_);
     DLOG("externalDevice       = " << (useExternalComputeDevice_ ? externalComputeDevice_ : "na"));
     DLOG("calibration          = " << calibration_);
     DLOG("base ccy             = " << baseCcy_);
@@ -327,7 +328,8 @@ ScriptedTradeEngineBuilder::engine(const std::string& id, const ScriptedTrade& s
         bool useExternalDev = useExternalComputeDevice_ && !generateAdditionalResults && !useCachedSensis;
         engine = QuantLib::ext::make_shared<ScriptedInstrumentPricingEngineCG>(
             script.npv(), script.results(), modelCG_, ast_, context, mcParams_, script.code(), interactive_,
-            generateAdditionalResults, includePastCashflows_, useCachedSensis, useExternalDev);
+            generateAdditionalResults, includePastCashflows_, useCachedSensis, useExternalDev,
+            useDoublePrecisionForExternalCalculation_);
         if (useExternalDev) {
             ComputeEnvironment::instance().selectContext(externalComputeDevice_);
         }
@@ -484,6 +486,8 @@ void ScriptedTradeEngineBuilder::populateModelParameters() {
     useAd_ = parseBool(engineParameter("UseAD", {resolvedProductTag_}, false, "false"));
     useExternalComputeDevice_ =
         parseBool(engineParameter("UseExternalComputeDevice", {resolvedProductTag_}, false, "false"));
+    useDoublePrecisionForExternalCalculation_ =
+        parseBool(engineParameter("UseDoublePrecisionForExternalCalculation", {resolvedProductTag_}, false, "false"));
     externalComputeDevice_ = engineParameter("ExternalComputeDevice", {}, false, "");
     includePastCashflows_ = parseBool(engineParameter("IncludePastCashflows", {resolvedProductTag_}, false, "false"));
 
diff --git a/OREData/ored/portfolio/builders/scriptedtrade.hpp b/OREData/ored/portfolio/builders/scriptedtrade.hpp
@@ -160,6 +160,7 @@ class ScriptedTradeEngineBuilder : public EngineBuilder {
     bool useCg_;
     bool useAd_;
     bool useExternalComputeDevice_;
+    bool useDoublePrecisionForExternalCalculation_;
     std::string externalComputeDevice_;
     bool includePastCashflows_;
 };
diff --git a/OREData/ored/scripting/engines/scriptedinstrumentpricingenginecg.cpp b/OREData/ored/scripting/engines/scriptedinstrumentpricingenginecg.cpp
@@ -66,14 +66,16 @@ double externalAverage(const std::vector<double>& v) {
 
 ScriptedInstrumentPricingEngineCG::ScriptedInstrumentPricingEngineCG(
     const std::string& npv, const std::vector<std::pair<std::string, std::string>>& additionalResults,
-    const QuantLib::ext::shared_ptr<ModelCG>& model, const ASTNodePtr ast, const QuantLib::ext::shared_ptr<Context>& context,
-    const Model::McParams& mcParams, const std::string& script, const bool interactive,
-    const bool generateAdditionalResults, const bool includePastCashflows, const bool useCachedSensis,
-    const bool useExternalComputeFramework)
+    const QuantLib::ext::shared_ptr<ModelCG>& model, const ASTNodePtr ast,
+    const QuantLib::ext::shared_ptr<Context>& context, const Model::McParams& mcParams, const std::string& script,
+    const bool interactive, const bool generateAdditionalResults, const bool includePastCashflows,
+    const bool useCachedSensis, const bool useExternalComputeFramework,
+    const bool useDoublePrecisionForExternalCalculation)
     : npv_(npv), additionalResults_(additionalResults), model_(model), ast_(ast), context_(context),
       mcParams_(mcParams), script_(script), interactive_(interactive),
       generateAdditionalResults_(generateAdditionalResults), includePastCashflows_(includePastCashflows),
-      useCachedSensis_(useCachedSensis), useExternalComputeFramework_(useExternalComputeFramework) {
+      useCachedSensis_(useCachedSensis), useExternalComputeFramework_(useExternalComputeFramework),
+      useDoublePrecisionForExternalCalculation_(useDoublePrecisionForExternalCalculation) {
 
     // register with model
 
@@ -180,9 +182,15 @@ void ScriptedInstrumentPricingEngineCG::calculate() const {
         if (useExternalComputeFramework_) {
             QL_REQUIRE(ComputeEnvironment::instance().hasContext(),
                        "ScriptedInstrumentPricingEngineCG::calculate(): no compute enviroment context selected.");
+            ComputeContext::Settings settings;
+            settings.debug = false;
+            settings.useDoublePrecision = useDoublePrecisionForExternalCalculation_;
+            settings.rngSequenceType = mcParams_.sequenceType;
+            settings.seed = mcParams_.seed;
+            settings.regressionOrder = mcParams_.regressionOrder;
             std::tie(externalCalculationId_, newExternalCalc) =
                 ComputeEnvironment::instance().context().initiateCalculation(model_->size(), externalCalculationId_,
-                                                                             cgVersion_);
+                                                                             cgVersion_, settings);
             DLOG("initiated external calculation id " << externalCalculationId_ << ", version " << cgVersion_);
         }
 
@@ -224,7 +232,7 @@ void ScriptedInstrumentPricingEngineCG::calculate() const {
             if (useExternalComputeFramework_) {
                 if (newExternalCalc) {
                     auto gen =
-                        ComputeEnvironment::instance().context().createInputVariates(rv.size(), rv.front().size(), 42);
+                        ComputeEnvironment::instance().context().createInputVariates(rv.size(), rv.front().size());
                     for (Size k = 0; k < rv.size(); ++k) {
                         for (Size j = 0; j < rv.front().size(); ++j)
                             valuesExternal[rv[k][j]] = ExternalRandomVariable(gen[k][j]);
@@ -296,8 +304,7 @@ void ScriptedInstrumentPricingEngineCG::calculate() const {
         // extract npv result and set it
 
         if (useExternalComputeFramework_) {
-            ComputeEnvironment::instance().context().finalizeCalculation(externalOutputPtr_,
-                                                                         {mcParams_.regressionOrder});
+            ComputeEnvironment::instance().context().finalizeCalculation(externalOutputPtr_);
             baseNpv_ = results_.value = externalAverage(externalOutput_[0]);
         } else {
             baseNpv_ = results_.value = model_->extractT0Result(values[baseNpvNode]);
diff --git a/OREData/ored/scripting/engines/scriptedinstrumentpricingenginecg.hpp b/OREData/ored/scripting/engines/scriptedinstrumentpricingenginecg.hpp
@@ -42,11 +42,12 @@ class ScriptedInstrumentPricingEngineCG : public QuantExt::ScriptedInstrument::e
     ScriptedInstrumentPricingEngineCG(const std::string& npv,
                                       const std::vector<std::pair<std::string, std::string>>& additionalResults,
                                       const QuantLib::ext::shared_ptr<ModelCG>& model, const ASTNodePtr ast,
-                                      const QuantLib::ext::shared_ptr<Context>& context, const Model::McParams& mcParams,
-                                      const std::string& script = "", const bool interactive = false,
-                                      const bool generateAdditionalResults = false,
+                                      const QuantLib::ext::shared_ptr<Context>& context,
+                                      const Model::McParams& mcParams, const std::string& script = "",
+                                      const bool interactive = false, const bool generateAdditionalResults = false,
                                       const bool includePastCashflows = false, const bool useCachedSensis = false,
-                                      const bool useExternalComputeFramework = false);
+                                      const bool useExternalComputeFramework = false,
+                                      const bool useDoublePrecisionForExternalCalculation = false);
 
     bool lastCalculationWasValid() const { return lastCalculationWasValid_; }
     const std::string& npvName() const { return npv_; }
@@ -110,6 +111,7 @@ class ScriptedInstrumentPricingEngineCG : public QuantExt::ScriptedInstrument::e
     const bool includePastCashflows_;
     const bool useCachedSensis_;
     const bool useExternalComputeFramework_;
+    const bool useDoublePrecisionForExternalCalculation_;
 };
 
 } // namespace data
diff --git a/QuantExt/qle/math/basiccpuenvironment.cpp b/QuantExt/qle/math/basiccpuenvironment.cpp
@@ -41,16 +41,18 @@ class BasicCpuContext : public ComputeContext {
 
     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) override final;
+                                                     const Settings settings = {}) override final;
     std::size_t createInputVariable(double v) override final;
     std::size_t createInputVariable(double* v) override final;
-    std::vector<std::vector<std::size_t>> createInputVariates(const std::size_t dim, const std::size_t steps,
-                                                              const std::uint32_t seed) override final;
+    std::vector<std::vector<std::size_t>> createInputVariates(const std::size_t dim,
+                                                              const std::size_t steps) override final;
     std::size_t applyOperation(const std::size_t randomVariableOpCode,
                                const std::vector<std::size_t>& args) override final;
     void freeVariable(const std::size_t id) override final;
     void declareOutputVariable(const std::size_t id) override final;
-    void finalizeCalculation(std::vector<double*>& output, const Settings& settings = Settings()) override final;
+    void finalizeCalculation(std::vector<double*>& output) override final;
+
+    bool supportsDoublePrecision() const override { return true; }
 
     const DebugInfo& debugInfo() const override final;
 
@@ -100,7 +102,7 @@ class BasicCpuContext : public ComputeContext {
 
     std::size_t currentId_ = 0;
     ComputeState currentState_ = ComputeState::idle;
-    bool debug_;
+    Settings settings_;
     bool newCalc_;
 
     std::vector<RandomVariable> values_;
@@ -140,12 +142,12 @@ void BasicCpuContext::init() {
 }
 
 std::pair<std::size_t, bool> BasicCpuContext::initiateCalculation(const std::size_t n, const std::size_t id,
-                                                                  const std::size_t version, const bool debug) {
+                                                                  const std::size_t version, const Settings settings) {
 
     QL_REQUIRE(n > 0, "BasicCpuContext::initiateCalculation(): n must not be zero");
 
     newCalc_ = false;
-    debug_ = debug;
+    settings_ = settings;
 
     if (id == 0) {
 
@@ -220,18 +222,21 @@ std::size_t BasicCpuContext::createInputVariable(double* v) {
     return numberOfInputVars_[currentId_ - 1]++;
 }
 
-std::vector<std::vector<std::size_t>>
-BasicCpuContext::createInputVariates(const std::size_t dim, const std::size_t steps, const std::uint32_t seed) {
+std::vector<std::vector<std::size_t>> BasicCpuContext::createInputVariates(const std::size_t dim,
+                                                                           const std::size_t steps) {
     QL_REQUIRE(currentState_ == ComputeState::createInput || currentState_ == ComputeState::createVariates,
-               "BasicCpuContext::createInputVariable(): not in state createInput or createVariates ("
+               "BasicCpuContext::createInputVariates(): not in state createInput or createVariates ("
                    << static_cast<int>(currentState_) << ")");
     QL_REQUIRE(currentId_ > 0, "BasicCpuContext::freeVariable(): current id is not set");
     QL_REQUIRE(newCalc_, "BasicCpuContext::createInputVariates(): id (" << currentId_ << ") in version "
                                                                         << version_[currentId_ - 1] << " is replayed.");
     currentState_ = ComputeState::createVariates;
 
     if (rng_ == nullptr) {
-        rng_ = std::make_unique<MersenneTwisterUniformRng>(seed);
+        QL_REQUIRE(settings_.rngSequenceType == QuantExt::SequenceType::MersenneTwister,
+                   "BasiCpuContext::createInputVariates(): sequence type "
+                       << settings_.rngSequenceType << " not supported, expected 'MersenneTwister'");
+        rng_ = std::make_unique<MersenneTwisterUniformRng>(settings_.seed);
     }
 
     if (variates_.size() < dim * steps) {
@@ -282,7 +287,7 @@ std::size_t BasicCpuContext::applyOperation(const std::size_t randomVariableOpCo
 
     // update num of ops in debug info
 
-    if (debug_)
+    if (settings_.debug)
         debugInfo_.numberOfOperations += 1 * size_[currentId_ - 1];
 
     // return result id
@@ -314,7 +319,7 @@ void BasicCpuContext::declareOutputVariable(const std::size_t id) {
     outputVars_[currentId_ - 1].push_back(id);
 }
 
-void BasicCpuContext::finalizeCalculation(std::vector<double*>& output, const Settings& settings) {
+void BasicCpuContext::finalizeCalculation(std::vector<double*>& output) {
     struct exitGuard {
         exitGuard() {}
         ~exitGuard() { *currentState = ComputeState::idle; }
@@ -331,7 +336,7 @@ void BasicCpuContext::finalizeCalculation(std::vector<double*>& output, const Se
 
     const auto& p = program_[currentId_ - 1];
 
-    auto ops = getRandomVariableOps(size_[currentId_ - 1], settings.regressionOrder);
+    auto ops = getRandomVariableOps(size_[currentId_ - 1], settings_.regressionOrder);
 
     // resize values vector to required size
 
diff --git a/QuantExt/qle/math/computeenvironment.cpp b/QuantExt/qle/math/computeenvironment.cpp
@@ -70,11 +70,11 @@ void ComputeEnvironment::selectContext(const std::string& deviceName) {
 
 ComputeContext& ComputeEnvironment::context() { return *currentContext_; }
 
-void ComputeContext::finalizeCalculation(std::vector<std::vector<double>>& output, const Settings& settings) {
+void ComputeContext::finalizeCalculation(std::vector<std::vector<double>>& output) {
     std::vector<double*> outputPtr(output.size());
     std::transform(output.begin(), output.end(), outputPtr.begin(),
                    [](std::vector<double>& v) -> double* { return &v[0]; });
-    finalizeCalculation(outputPtr, settings);
+    finalizeCalculation(outputPtr);
 }
 
 void ComputeFrameworkRegistry::add(const std::string& name, std::function<ComputeFramework*(void)> creator,
diff --git a/QuantExt/qle/math/computeenvironment.hpp b/QuantExt/qle/math/computeenvironment.hpp
diff --git a/QuantExt/qle/math/openclenvironment.cpp b/QuantExt/qle/math/openclenvironment.cpp
diff --git a/QuantExt/test/computeenvironment.cpp b/QuantExt/test/computeenvironment.cpp
