Address feedback: rethink layer::isEnabled

Author: aarongreig

scripts/templates/trcddi.cpp.mako

@@ -102,9 +102,15 @@ namespace ur_tracing_layer
     }
     %endfor
 
-    ${x}_result_t context_t::init(ur_dditable_t *dditable) {
+    ${x}_result_t
+    context_t::init(ur_dditable_t *dditable,
+                    const std::set<std::string> &enabledLayerNames) {
         ${x}_result_t result = ${X}_RESULT_SUCCESS;
 
+        if(!enabledLayerNames.count(name)) {
+            return result;
+        }
+
     %for tbl in th.get_pfntables(specs, meta, n, tags):
         if( ${X}_RESULT_SUCCESS == result )
         {

scripts/templates/valddi.cpp.mako

@@ -138,9 +138,23 @@ namespace ur_validation_layer
     }
 
     %endfor
-    ${x}_result_t context_t::init(${x}_dditable_t *dditable) {
+    ${x}_result_t
+    context_t::init(ur_dditable_t *dditable,
+                    const std::set<std::string> &enabledLayerNames) {
         ${x}_result_t result = ${X}_RESULT_SUCCESS;
 
+        if (enabledLayerNames.count(nameFullValidation)) {
+            enableParameterValidation = true;
+            enableLeakChecking = true;
+        } else {
+            if (enabledLayerNames.count(nameParameterValidation)) {
+                enableParameterValidation = true;
+            }
+            if (enabledLayerNames.count(nameLeakChecking)) {
+                enableLeakChecking = true;
+            }
+        }
+
         if(!enableParameterValidation && !enableLeakChecking) {
             return result;
         }

source/loader/layers/tracing/ur_tracing_layer.hpp

@@ -30,12 +30,9 @@ class __urdlllocal context_t : public proxy_layer_context_t {
 
     bool isAvailable() const override;
 
-    bool isEnabled(const std::set<std::string> &enabledLayerNames) override {
-        return enabledLayerNames.find(name) != enabledLayerNames.end();
-    }
-
     std::vector<std::string> getNames() const override { return {name}; }
-    ur_result_t init(ur_dditable_t *dditable) override;
+    ur_result_t init(ur_dditable_t *dditable,
+                     const std::set<std::string> &enabledLayerNames) override;
     uint64_t notify_begin(uint32_t id, const char *name, void *args);
     void notify_end(uint32_t id, const char *name, void *args,
                     ur_result_t *resultp, uint64_t instance);

source/loader/layers/tracing/ur_trcddi.cpp

@@ -6782,9 +6782,14 @@ __urdlllocal ur_result_t UR_APICALL urGetDeviceProcAddrTable(
     return result;
 }
 
-ur_result_t context_t::init(ur_dditable_t *dditable) {
+ur_result_t context_t::init(ur_dditable_t *dditable,
+                            const std::set<std::string> &enabledLayerNames) {
     ur_result_t result = UR_RESULT_SUCCESS;
 
+    if (!enabledLayerNames.count(name)) {
+        return result;
+    }
+
     if (UR_RESULT_SUCCESS == result) {
         result = ur_tracing_layer::urGetGlobalProcAddrTable(
             UR_API_VERSION_CURRENT, &dditable->Global);

source/loader/layers/ur_proxy_layer.hpp

@@ -24,8 +24,9 @@ class __urdlllocal proxy_layer_context_t {
 
     virtual std::vector<std::string> getNames() const = 0;
     virtual bool isAvailable() const = 0;
-    virtual bool isEnabled(const std::set<std::string> &enabledLayerNames) = 0;
-    virtual ur_result_t init(ur_dditable_t *dditable) = 0;
+    virtual ur_result_t
+    init(ur_dditable_t *dditable,
+         const std::set<std::string> &enabledLayerNames) = 0;
 };
 
 #endif /* UR_PROXY_LAYER_H */

source/loader/layers/validation/ur_valddi.cpp

@@ -8145,9 +8145,22 @@ UR_DLLEXPORT ur_result_t UR_APICALL urGetDeviceProcAddrTable(
     return result;
 }
 
-ur_result_t context_t::init(ur_dditable_t *dditable) {
+ur_result_t context_t::init(ur_dditable_t *dditable,
+                            const std::set<std::string> &enabledLayerNames) {
     ur_result_t result = UR_RESULT_SUCCESS;
 
+    if (enabledLayerNames.count(nameFullValidation)) {
+        enableParameterValidation = true;
+        enableLeakChecking = true;
+    } else {
+        if (enabledLayerNames.count(nameParameterValidation)) {
+            enableParameterValidation = true;
+        }
+        if (enabledLayerNames.count(nameLeakChecking)) {
+            enableLeakChecking = true;
+        }
+    }
+
     if (!enableParameterValidation && !enableLeakChecking) {
         return result;
     }

source/loader/layers/validation/ur_validation_layer.cpp

@@ -20,21 +20,4 @@ context_t::context_t() : logger(logger::create_logger("validation")) {}
 ///////////////////////////////////////////////////////////////////////////////
 context_t::~context_t() {}
 
-bool context_t::isEnabled(const std::set<std::string> &enabledLayerNames) {
-    if (enabledLayerNames.find(nameFullValidation) != enabledLayerNames.end()) {
-        enableParameterValidation = true;
-        enableLeakChecking = true;
-    } else {
-        if (enabledLayerNames.find(nameParameterValidation) !=
-            enabledLayerNames.end()) {
-            enableParameterValidation = true;
-        }
-        if (enabledLayerNames.find(nameLeakChecking) !=
-            enabledLayerNames.end()) {
-            enableLeakChecking = true;
-        }
-    }
-    return enableParameterValidation || enableLeakChecking;
-}
-
 } // namespace ur_validation_layer

source/loader/layers/validation/ur_validation_layer.hpp

@@ -30,11 +30,11 @@ class __urdlllocal context_t : public proxy_layer_context_t {
     ~context_t();
 
     bool isAvailable() const override { return true; }
-    bool isEnabled(const std::set<std::string> &enabledLayerNames) override;
     std::vector<std::string> getNames() const override {
         return {nameFullValidation, nameParameterValidation, nameLeakChecking};
     }
-    ur_result_t init(ur_dditable_t *dditable) override;
+    ur_result_t init(ur_dditable_t *dditable,
+                     const std::set<std::string> &enabledLayerNames) override;
 
   private:
     const std::string nameFullValidation = "UR_LAYER_FULL_VALIDATION";

source/loader/ur_lib.cpp

@@ -54,8 +54,8 @@ void context_t::parseEnvEnabledLayers() {
 
 void context_t::initLayers() const {
     for (auto &l : layers) {
-        if (l->isAvailable() && l->isEnabled(enabledLayerNames)) {
-            l->init(&context->urDdiTable);
+        if (l->isAvailable()) {
+            l->init(&context->urDdiTable, enabledLayerNames);
         }
     }
 }