Create an EngineData structure. (#140)

This CL moves the fence_timeout directive from a Requirement to a new
EngineData structure. EngineData can be extended if there is more
configuration needed in the future.

12 files changed, 40 insertions, 47 deletions

diff --git a/src/amber.cc b/src/amber.cc
index 084328c..ca8c219 100644
--- a/src/amber.cc
+++ b/src/amber.cc
@@ -71,7 +71,6 @@ amber::Result Amber::ExecuteWithShaderData(const std::string& input,
     r = engine->Initialize(script->RequiredFeatures(),
                            script->RequiredExtensions());
   }
-
   if (!r.IsSuccess())
     return r;
 
diff --git a/src/dawn/engine_dawn.cc b/src/dawn/engine_dawn.cc
index 84184c4..56c0e88 100644
--- a/src/dawn/engine_dawn.cc
+++ b/src/dawn/engine_dawn.cc
@@ -236,7 +236,7 @@ Result EngineDawn::CreatePipeline(PipelineType type) {
   return {};
 }
 
-Result EngineDawn::AddRequirement(Feature, const Format*, uint32_t) {
+Result EngineDawn::AddRequirement(Feature, const Format*) {
   return Result("Dawn:AddRequirement not implemented");
 }
 
diff --git a/src/dawn/engine_dawn.h b/src/dawn/engine_dawn.h
index 3ea8db2..c4d151b 100644
--- a/src/dawn/engine_dawn.h
+++ b/src/dawn/engine_dawn.h
@@ -44,13 +44,14 @@ class EngineDawn : public Engine {
       EngineConfig* config,
       const std::vector<Feature>& features,
       const std::vector<std::string>& extensions) override;
+
   Result Shutdown() override;
   // Record info for a pipeline.  The Dawn render pipeline will be created
   // later.  Assumes necessary shader modules have been created.  A compute
   // pipeline requires a compute shader.  A graphics pipeline requires a vertex
   // and a fragment shader.
   Result CreatePipeline(PipelineType) override;
-  Result AddRequirement(Feature feature, const Format*, uint32_t) override;
+  Result AddRequirement(Feature feature, const Format*) override;
   Result SetShader(ShaderType type, const std::vector<uint32_t>& data) override;
   Result SetBuffer(BufferType type,
                    uint8_t location,
diff --git a/src/engine.h b/src/engine.h
index c0d2f6d..d306cd6 100644
--- a/src/engine.h
+++ b/src/engine.h
@@ -39,6 +39,12 @@ enum class ResourceInfoType : uint8_t {
   kImage,
 };
 
+/// EngineData stores information used during engine execution.
+struct EngineData {
+  /// The timeout to use for fences, in milliseconds.
+  uint32_t fence_timeout_ms = 100;
+};
+
 struct ResourceInfo {
   ResourceInfoType type = ResourceInfoType::kBuffer;
 
@@ -93,9 +99,7 @@ class Engine {
   // Enable |feature|. If the feature requires a pixel format it will be
   // provided in |format|, otherwise |format| is a nullptr. If the feature
   // requires a uint32 value it will be set in the |uint32_t|.
-  virtual Result AddRequirement(Feature feature,
-                                const Format* format,
-                                uint32_t) = 0;
+  virtual Result AddRequirement(Feature feature, const Format* format) = 0;
 
   // Create graphics pipeline.
   virtual Result CreatePipeline(PipelineType type) = 0;
@@ -164,8 +168,17 @@ class Engine {
                                    const uint32_t binding,
                                    ResourceInfo* info) = 0;
 
+  /// Sets the engine data to use.
+  void SetEngineData(const EngineData& data) { engine_data_ = data; }
+
  protected:
   Engine();
+
+  /// Retrieves the engine data.
+  const EngineData& GetEngineData() const { return engine_data_; }
+
+ private:
+  EngineData engine_data_;
 };
 
 }  // namespace amber
diff --git a/src/script.h b/src/script.h
index b1ce218..379c43e 100644
--- a/src/script.h
+++ b/src/script.h
@@ -24,6 +24,7 @@
 
 #include "amber/result.h"
 #include "src/command.h"
+#include "src/engine.h"
 #include "src/feature.h"
 #include "src/shader.h"
 
@@ -72,6 +73,9 @@ class Script {
     return engine_info_.required_extensions;
   }
 
+  EngineData& GetEngineData() { return engine_data_; }
+  const EngineData& GetEngineData() const { return engine_data_; }
+
   void SetCommands(std::vector<std::unique_ptr<Command>> cmds) {
     commands_ = std::move(cmds);
   }
@@ -89,6 +93,7 @@ class Script {
   } engine_info_;
 
   ScriptType script_type_;
+  EngineData engine_data_;
   std::map<std::string, Shader*> name_to_shader_;
   std::vector<std::unique_ptr<Shader>> shaders_;
   std::vector<std::unique_ptr<Command>> commands_;
diff --git a/src/vkscript/executor.cc b/src/vkscript/executor.cc
index cfd92a4..0523b1f 100644
--- a/src/vkscript/executor.cc
+++ b/src/vkscript/executor.cc
@@ -36,6 +36,7 @@ Result Executor::Execute(Engine* engine,
     return Result("VkScript Executor called with non-vkscript source");
 
   const Script* script = ToVkScript(src_script);
+  engine->SetEngineData(script->GetEngineData());
 
   // Process Requirement nodes
   for (const auto& node : script->Nodes()) {
@@ -43,8 +44,8 @@ Result Executor::Execute(Engine* engine,
       continue;
 
     for (const auto& require : node->AsRequire()->Requirements()) {
-      Result r = engine->AddRequirement(
-          require.GetFeature(), require.GetFormat(), require.GetUint32Value());
+      Result r =
+          engine->AddRequirement(require.GetFeature(), require.GetFormat());
       if (!r.IsSuccess())
         return r;
     }
diff --git a/src/vkscript/executor_test.cc b/src/vkscript/executor_test.cc
index 5c60b9b..7b78493 100644
--- a/src/vkscript/executor_test.cc
+++ b/src/vkscript/executor_test.cc
@@ -49,17 +49,10 @@ class EngineStub : public Engine {
   Result Shutdown() override { return {}; }
 
   void FailRequirements() { fail_requirements_ = true; }
-  Result AddRequirement(Feature feature,
-                        const Format* fmt,
-                        uint32_t val) override {
+  Result AddRequirement(Feature feature, const Format* fmt) override {
     if (fail_requirements_)
       return Result("requirements failed");
 
-    if (feature == Feature::kFenceTimeout) {
-      fence_timeout_ms_ = val;
-      return {};
-    }
-
     if (feature == Feature::kFramebuffer) {
       if (fmt != nullptr)
         color_frame_format_ = fmt->GetFormatType();
@@ -81,7 +74,7 @@ class EngineStub : public Engine {
   const std::vector<std::string>& GetExtensions() const { return extensions_; }
   FormatType GetColorFrameFormat() const { return color_frame_format_; }
   FormatType GetDepthFrameFormat() const { return depth_frame_format_; }
-  uint32_t GetFenceTimeoutMs() { return fence_timeout_ms_; }
+  uint32_t GetFenceTimeoutMs() { return GetEngineData().fence_timeout_ms; }
 
   Result CreatePipeline(PipelineType) override { return {}; }
 
@@ -264,7 +257,6 @@ class EngineStub : public Engine {
   std::vector<ShaderType> shaders_seen_;
   FormatType color_frame_format_ = FormatType::kUnknown;
   FormatType depth_frame_format_ = FormatType::kUnknown;
-  uint32_t fence_timeout_ms_ = 0;
   std::vector<Feature> features_;
   std::vector<std::string> extensions_;
 
@@ -333,7 +325,7 @@ logicOp)";
   const auto& extensions = ToStub(engine.get())->GetExtensions();
   ASSERT_EQ(0U, extensions.size());
 
-  EXPECT_EQ(0U, ToStub(engine.get())->GetFenceTimeoutMs());
+  EXPECT_EQ(100U, ToStub(engine.get())->GetFenceTimeoutMs());
 
   auto color_frame_format = ToStub(engine.get())->GetColorFrameFormat();
   auto depth_frame_format = ToStub(engine.get())->GetDepthFrameFormat();
@@ -366,7 +358,7 @@ VK_KHR_variable_pointers)";
   EXPECT_EQ("VK_KHR_storage_buffer_storage_class", extensions[0]);
   EXPECT_EQ("VK_KHR_variable_pointers", extensions[1]);
 
-  EXPECT_EQ(0U, ToStub(engine.get())->GetFenceTimeoutMs());
+  EXPECT_EQ(100U, ToStub(engine.get())->GetFenceTimeoutMs());
 
   auto color_frame_format = ToStub(engine.get())->GetColorFrameFormat();
   auto depth_frame_format = ToStub(engine.get())->GetDepthFrameFormat();
@@ -397,7 +389,7 @@ depthstencil D24_UNORM_S8_UINT)";
   const auto& extensions = ToStub(engine.get())->GetExtensions();
   ASSERT_EQ(0U, extensions.size());
 
-  EXPECT_EQ(0U, ToStub(engine.get())->GetFenceTimeoutMs());
+  EXPECT_EQ(100U, ToStub(engine.get())->GetFenceTimeoutMs());
 
   auto color_frame_format = ToStub(engine.get())->GetColorFrameFormat();
   auto depth_frame_format = ToStub(engine.get())->GetDepthFrameFormat();
@@ -477,7 +469,7 @@ fence_timeout 12345)";
 
 TEST_F(VkScriptExecutorTest, EngineAddRequirementFailed) {
   auto engine = MakeEngine();
-  Result r = engine->AddRequirement(Feature::kRobustBufferAccess, nullptr, 0U);
+  Result r = engine->AddRequirement(Feature::kRobustBufferAccess, nullptr);
   ASSERT_FALSE(r.IsSuccess());
   EXPECT_EQ(
       "Vulkan::AddRequirement features and extensions must be handled by "
diff --git a/src/vkscript/nodes.cc b/src/vkscript/nodes.cc
index 371b61f..993f989 100644
--- a/src/vkscript/nodes.cc
+++ b/src/vkscript/nodes.cc
@@ -46,9 +46,6 @@ RequireNode::Requirement::Requirement(Feature feature,
                                       std::unique_ptr<Format> format)
     : feature_(feature), format_(std::move(format)) {}
 
-RequireNode::Requirement::Requirement(Feature feature, uint32_t value)
-    : feature_(feature), uint32_value_(value) {}
-
 RequireNode::Requirement::Requirement(Requirement&&) = default;
 
 RequireNode::Requirement::~Requirement() = default;
@@ -58,10 +55,6 @@ void RequireNode::AddRequirement(Feature feature,
   requirements_.emplace_back(feature, std::move(format));
 }
 
-void RequireNode::AddRequirement(Feature feature, uint32_t value) {
-  requirements_.emplace_back(feature, value);
-}
-
 IndicesNode::IndicesNode(std::unique_ptr<Buffer> buffer)
     : Node(NodeType::kIndices), buffer_(std::move(buffer)) {}
 
diff --git a/src/vkscript/nodes.h b/src/vkscript/nodes.h
index db1149a..95b9556 100644
--- a/src/vkscript/nodes.h
+++ b/src/vkscript/nodes.h
@@ -59,25 +59,21 @@ class RequireNode : public Node {
    public:
     explicit Requirement(Feature feature);
     Requirement(Feature feature, std::unique_ptr<Format> format);
-    Requirement(Feature feature, uint32_t value);
     Requirement(Requirement&&);
     ~Requirement();
 
     Feature GetFeature() const { return feature_; }
     const Format* GetFormat() const { return format_.get(); }
-    uint32_t GetUint32Value() const { return uint32_value_; }
 
    private:
     Feature feature_;
     std::unique_ptr<Format> format_;
-    uint32_t uint32_value_;
   };
 
   RequireNode();
   ~RequireNode() override;
 
   void AddRequirement(Feature feature, std::unique_ptr<Format> format);
-  void AddRequirement(Feature feature, uint32_t value);
 
   const std::vector<Requirement>& Requirements() const { return requirements_; }
 
diff --git a/src/vkscript/parser.cc b/src/vkscript/parser.cc
index ab78191..e2c0864 100644
--- a/src/vkscript/parser.cc
+++ b/src/vkscript/parser.cc
@@ -256,7 +256,7 @@ Result Parser::ProcessRequireBlock(const std::string& data) {
       if (!token->IsInteger())
         return Result("Missing fence_timeout value");
 
-      node->AddRequirement(feature, token->AsUint32());
+      script_.GetEngineData().fence_timeout_ms = token->AsUint32();
     } else {
       script_.AddRequiredFeature(feature);
     }
diff --git a/src/vulkan/engine_vulkan.cc b/src/vulkan/engine_vulkan.cc
index e7afe5e..919616b 100644
--- a/src/vulkan/engine_vulkan.cc
+++ b/src/vulkan/engine_vulkan.cc
@@ -105,14 +105,7 @@ Result EngineVulkan::Shutdown() {
   return {};
 }
 
-Result EngineVulkan::AddRequirement(Feature feature,
-                                    const Format* fmt,
-                                    uint32_t val) {
-  if (feature == Feature::kFenceTimeout) {
-    fence_timeout_ms_ = val;
-    return {};
-  }
-
+Result EngineVulkan::AddRequirement(Feature feature, const Format* fmt) {
   if (feature == Feature::kFramebuffer) {
     if (fmt != nullptr)
       color_frame_format_ = ToVkFormat(fmt->GetFormatType());
@@ -131,17 +124,19 @@ Result EngineVulkan::AddRequirement(Feature feature,
 }
 
 Result EngineVulkan::CreatePipeline(PipelineType type) {
+  const auto& engine_data = GetEngineData();
+
   if (type == PipelineType::kCompute) {
     pipeline_ = MakeUnique<ComputePipeline>(
         device_->GetDevice(), device_->GetPhysicalMemoryProperties(),
-        fence_timeout_ms_, GetShaderStageInfo());
+        engine_data.fence_timeout_ms, GetShaderStageInfo());
     return pipeline_->AsCompute()->Initialize(pool_->GetCommandPool(),
                                               device_->GetQueue());
   }
 
   pipeline_ = MakeUnique<GraphicsPipeline>(
       device_->GetDevice(), device_->GetPhysicalMemoryProperties(),
-      color_frame_format_, depth_frame_format_, fence_timeout_ms_,
+      color_frame_format_, depth_frame_format_, engine_data.fence_timeout_ms,
       GetShaderStageInfo());
 
   return pipeline_->AsGraphics()->Initialize(
diff --git a/src/vulkan/engine_vulkan.h b/src/vulkan/engine_vulkan.h
index 95347ff..d5b5f99 100644
--- a/src/vulkan/engine_vulkan.h
+++ b/src/vulkan/engine_vulkan.h
@@ -43,7 +43,7 @@ class EngineVulkan : public Engine {
       const std::vector<Feature>& features,
       const std::vector<std::string>& extensions) override;
   Result Shutdown() override;
-  Result AddRequirement(Feature feature, const Format*, uint32_t) override;
+  Result AddRequirement(Feature feature, const Format*) override;
   Result CreatePipeline(PipelineType type) override;
   Result SetShader(ShaderType type, const std::vector<uint32_t>& data) override;
   Result SetBuffer(BufferType type,
@@ -72,8 +72,6 @@ class EngineVulkan : public Engine {
 
   std::vector<VkPipelineShaderStageCreateInfo> GetShaderStageInfo();
 
-  uint32_t fence_timeout_ms_ = 100;
-
   std::unique_ptr<Device> device_;
   std::unique_ptr<CommandPool> pool_;
   std::unique_ptr<Pipeline> pipeline_;