Add option to disable SPIR-V validation

include/amber/amber.h

@@ -38,6 +38,13 @@ enum EngineType {
   kEngineTypeDawn,
 };
 
+enum class ExecutionType {
+  /// Execute as normal.
+  kExecute = 0,
+  /// Only create the pipelines and then exit.
+  kPipelineCreateOnly
+};
+
 /// Override point of engines to add their own configuration.
 struct EngineConfig {
   virtual ~EngineConfig();
@@ -101,8 +108,12 @@ struct Options {
   std::string spv_env;
   /// Lists the buffers to extract at the end of the execution
   std::vector<BufferInfo> extractions;
-  /// Terminate after creating the pipelines.
-  bool pipeline_create_only;
+  /// The type of execution. For example, execute as normal or just create the
+  /// piplines and exit.
+  ExecutionType execution_type;
+  /// If true, disables SPIR-V validation. If false, SPIR-V shaders will be
+  /// validated using the Validator component (spirv-val) from SPIRV-Tools.
+  bool disable_spirv_validation;
   /// Delegate implementation
   Delegate* delegate;
 };

samples/amber.cc

@@ -56,6 +56,7 @@ struct Options {
   bool log_graphics_calls = false;
   bool log_graphics_calls_time = false;
   bool log_execute_calls = false;
+  bool disable_spirv_validation = false;
   amber::EngineType engine = amber::kEngineTypeVulkan;
   std::string spv_env;
 };
@@ -86,6 +87,7 @@ const char kUsage[] = R"(Usage: amber [options] SCRIPT [SCRIPTS...]
   --log-graphics-calls      -- Log graphics API calls (only for Vulkan so far).
   --log-graphics-calls-time -- Log timing of graphics API calls timing (Vulkan only).
   --log-execute-calls       -- Log each execute call before run.
+  --disable-spirv-val       -- Disable SPIR-V validation.
   -h                        -- This help text.
 )";
 
@@ -193,6 +195,8 @@ bool ParseArgs(const std::vector<std::string>& args, Options* opts) {
       opts->log_graphics_calls_time = true;
     } else if (arg == "--log-execute-calls") {
       opts->log_execute_calls = true;
+    } else if (arg == "--disable-spirv-val") {
+      opts->disable_spirv_validation = true;
     } else if (arg.size() > 0 && arg[0] == '-') {
       std::cerr << "Unrecognized option " << arg << std::endl;
       return false;
@@ -352,8 +356,11 @@ int main(int argc, const char** argv) {
   amber::Options amber_options;
   amber_options.engine = options.engine;
   amber_options.spv_env = options.spv_env;
-  amber_options.pipeline_create_only = options.pipeline_create_only;
+  amber_options.execution_type = options.pipeline_create_only
+                                     ? amber::ExecutionType::kPipelineCreateOnly
+                                     : amber::ExecutionType::kExecute;
   amber_options.delegate = &delegate;
+  amber_options.disable_spirv_validation = options.disable_spirv_validation;
 
   std::set<std::string> required_features;
   std::set<std::string> required_device_extensions;

src/amber.cc

@@ -67,7 +67,8 @@ EngineConfig::~EngineConfig() = default;
 Options::Options()
     : engine(amber::EngineType::kEngineTypeVulkan),
       config(nullptr),
-      pipeline_create_only(false),
+      execution_type(ExecutionType::kExecute),
+      disable_spirv_validation(false),
       delegate(nullptr) {}
 
 Options::~Options() = default;
@@ -168,10 +169,8 @@ amber::Result Amber::ExecuteWithShaderData(const amber::Recipe* recipe,
   script->SetSpvTargetEnv(opts->spv_env);
 
   Executor executor;
-  Result executor_result = executor.Execute(
-      engine.get(), script, opts->delegate, shader_data,
-      opts->pipeline_create_only ? ExecutionType::kPipelineCreateOnly
-                                 : ExecutionType::kExecute);
+  Result executor_result =
+      executor.Execute(engine.get(), script, shader_data, opts);
   // Hold the executor result until the extractions are complete. This will let
   // us dump any buffers requested even on failure.
 

src/executor.cc

@@ -30,10 +30,12 @@ Executor::Executor() = default;
 Executor::~Executor() = default;
 
 Result Executor::CompileShaders(const amber::Script* script,
-                                const ShaderMap& shader_map) {
+                                const ShaderMap& shader_map,
+                                Options* options) {
   for (auto& pipeline : script->GetPipelines()) {
     for (auto& shader_info : pipeline->GetShaders()) {
-      ShaderCompiler sc(script->GetSpvTargetEnv());
+      ShaderCompiler sc(script->GetSpvTargetEnv(),
+                        options->disable_spirv_validation);
 
       Result r;
       std::vector<uint32_t> data;
@@ -49,13 +51,12 @@ Result Executor::CompileShaders(const amber::Script* script,
 
 Result Executor::Execute(Engine* engine,
                          const amber::Script* script,
-                         Delegate* delegate,
                          const ShaderMap& shader_map,
-                         ExecutionType executionType) {
+                         Options* options) {
   engine->SetEngineData(script->GetEngineData());
 
   if (!script->GetPipelines().empty()) {
-    Result r = CompileShaders(script, shader_map);
+    Result r = CompileShaders(script, shader_map, options);
     if (!r.IsSuccess())
       return r;
 
@@ -76,13 +77,15 @@ Result Executor::Execute(Engine* engine,
     }
   }
 
-  if (executionType == ExecutionType::kPipelineCreateOnly)
+  if (options->execution_type == ExecutionType::kPipelineCreateOnly)
     return {};
 
   // Process Commands
   for (const auto& cmd : script->GetCommands()) {
-    if (delegate && delegate->LogExecuteCalls())
-      delegate->Log(std::to_string(cmd->GetLine()) + ": " + cmd->ToString());
+    if (options->delegate && options->delegate->LogExecuteCalls()) {
+      options->delegate->Log(std::to_string(cmd->GetLine()) + ": " +
+                             cmd->ToString());
+    }
 
     Result r = ExecuteCommand(engine, cmd.get());
     if (!r.IsSuccess())

src/executor.h

@@ -23,8 +23,6 @@
 
 namespace amber {
 
-enum class ExecutionType { kExecute = 0, kPipelineCreateOnly };
-
 /// The executor is responsible for running the given script against an engine.
 class Executor {
  public:
@@ -37,12 +35,13 @@ class Executor {
   /// used as the shader binary.
   Result Execute(Engine* engine,
                  const Script* script,
-                 Delegate* delegate,
                  const ShaderMap& map,
-                 ExecutionType executionType);
+                 Options* options);
 
  private:
-  Result CompileShaders(const Script* script, const ShaderMap& shader_map);
+  Result CompileShaders(const Script* script,
+                        const ShaderMap& shader_map,
+                        Options* options);
   Result ExecuteCommand(Engine* engine, Command* cmd);
 
   Verifier verifier_;