Vulkan: More micro-optimizations.

src/libANGLE/params.cpp

@@ -85,16 +85,6 @@ DrawCallParams::DrawCallParams(PrimitiveMode mode, GLenum type, const void *indi
 {
 }
 
-GLint DrawCallParams::firstVertex() const
-{
-    // In some cases we can know the first vertex will be fixed at zero, if we're on the "fast
-    // path". In these cases the index range is not resolved. If the first vertex is not zero,
-    // however, then it must be because the index range is resolved. This only applies to the
-    // D3D11 back-end currently.
-    ASSERT(mFirstVertex == 0 || (!isDrawElements() || mIndexRange.valid()));
-    return mFirstVertex;
-}
-
 GLsizei DrawCallParams::indexCount() const
 {
     ASSERT(isDrawElements());

src/libANGLE/params.h

@@ -97,7 +97,15 @@ class DrawCallParams final : angle::NonCopyable
     PrimitiveMode mode() const { return mMode; }
 
     // This value is the sum of 'baseVertex' and the first indexed vertex for DrawElements calls.
-    GLint firstVertex() const;
+    GLint firstVertex() const
+    {
+        // In some cases we can know the first vertex will be fixed at zero, if we're on the "fast
+        // path". In these cases the index range is not resolved. If the first vertex is not zero,
+        // however, then it must be because the index range is resolved. This only applies to the
+        // D3D11 back-end currently.
+        ASSERT(mFirstVertex == 0 || (!isDrawElements() || mIndexRange.valid()));
+        return mFirstVertex;
+    }
 
     size_t vertexCount() const
     {

src/libANGLE/renderer/vulkan/CommandGraph.cpp

@@ -52,77 +52,6 @@ angle::Result InitAndBeginCommandBuffer(vk::Context *context,
 
 }  // anonymous namespace
 
-class CommandGraphNode final : angle::NonCopyable
-{
-  public:
-    CommandGraphNode();
-    ~CommandGraphNode();
-
-    // Immutable queries for when we're walking the commands tree.
-    CommandBuffer *getOutsideRenderPassCommands();
-    CommandBuffer *getInsideRenderPassCommands();
-
-    // For outside the render pass (copies, transitions, etc).
-    angle::Result beginOutsideRenderPassRecording(Context *context,
-                                                  const CommandPool &commandPool,
-                                                  CommandBuffer **commandsOut);
-
-    // For rendering commands (draws).
-    angle::Result beginInsideRenderPassRecording(Context *context, CommandBuffer **commandsOut);
-
-    // storeRenderPassInfo and append*RenderTarget store info relevant to the RenderPass.
-    void storeRenderPassInfo(const Framebuffer &framebuffer,
-                             const gl::Rectangle renderArea,
-                             const vk::RenderPassDesc &renderPassDesc,
-                             const std::vector<VkClearValue> &clearValues);
-
-    // Dependency commands order node execution in the command graph.
-    // Once a node has commands that must happen after it, recording is stopped and the node is
-    // frozen forever.
-    static void SetHappensBeforeDependency(CommandGraphNode *beforeNode,
-                                           CommandGraphNode *afterNode);
-    static void SetHappensBeforeDependencies(const std::vector<CommandGraphNode *> &beforeNodes,
-                                             CommandGraphNode *afterNode);
-    bool hasParents() const;
-    bool hasChildren() const;
-
-    // Commands for traversing the node on a flush operation.
-    VisitedState visitedState() const;
-    void visitParents(std::vector<CommandGraphNode *> *stack);
-    angle::Result visitAndExecute(Context *context,
-                                  Serial serial,
-                                  RenderPassCache *renderPassCache,
-                                  CommandBuffer *primaryCommandBuffer);
-
-    const gl::Rectangle &getRenderPassRenderArea() const;
-
-  private:
-    void setHasChildren();
-
-    // Used for testing only.
-    bool isChildOf(CommandGraphNode *parent);
-
-    // Only used if we need a RenderPass for these commands.
-    RenderPassDesc mRenderPassDesc;
-    Framebuffer mRenderPassFramebuffer;
-    gl::Rectangle mRenderPassRenderArea;
-    gl::AttachmentArray<VkClearValue> mRenderPassClearValues;
-
-    // Keep a separate buffers for commands inside and outside a RenderPass.
-    // TODO(jmadill): We might not need inside and outside RenderPass commands separate.
-    CommandBuffer mOutsideRenderPassCommands;
-    CommandBuffer mInsideRenderPassCommands;
-
-    // Parents are commands that must be submitted before 'this' CommandNode can be submitted.
-    std::vector<CommandGraphNode *> mParents;
-
-    // If this is true, other commands exist that must be submitted after 'this' command.
-    bool mHasChildren;
-
-    // Used when traversing the dependency graph.
-    VisitedState mVisitedState;
-};
-
 // CommandGraphResource implementation.
 CommandGraphResource::CommandGraphResource() : mCurrentWritingNode(nullptr)
 {
@@ -152,11 +81,6 @@ Serial CommandGraphResource::getStoredQueueSerial() const
     return mStoredQueueSerial;
 }
 
-bool CommandGraphResource::hasChildlessWritingNode() const
-{
-    return (mCurrentWritingNode != nullptr && !mCurrentWritingNode->hasChildren());
-}
-
 bool CommandGraphResource::hasStartedWriteResource() const
 {
     return hasChildlessWritingNode() &&
@@ -210,11 +134,6 @@ bool CommandGraphResource::appendToStartedRenderPass(RendererVk *renderer,
     }
 }
 
-bool CommandGraphResource::hasStartedRenderPass() const
-{
-    return hasChildlessWritingNode() && mCurrentWritingNode->getInsideRenderPassCommands()->valid();
-}
-
 const gl::Rectangle &CommandGraphResource::getRenderPassRenderArea() const
 {
     ASSERT(hasStartedRenderPass());
@@ -306,12 +225,6 @@ CommandBuffer *CommandGraphNode::getOutsideRenderPassCommands()
     return &mOutsideRenderPassCommands;
 }
 
-CommandBuffer *CommandGraphNode::getInsideRenderPassCommands()
-{
-    ASSERT(!mHasChildren);
-    return &mInsideRenderPassCommands;
-}
-
 angle::Result CommandGraphNode::beginOutsideRenderPassRecording(Context *context,
                                                                 const CommandPool &commandPool,
                                                                 CommandBuffer **commandsOut)
@@ -410,11 +323,6 @@ void CommandGraphNode::setHasChildren()
     mHasChildren = true;
 }
 
-bool CommandGraphNode::hasChildren() const
-{
-    return mHasChildren;
-}
-
 // Do not call this in anything but testing code, since it's slow.
 bool CommandGraphNode::isChildOf(CommandGraphNode *parent)
 {

src/libANGLE/renderer/vulkan/CommandGraph.h

@@ -17,7 +17,89 @@ namespace rx
 
 namespace vk
 {
-class CommandGraphNode;
+enum class VisitedState
+{
+    Unvisited,
+    Ready,
+    Visited,
+};
+
+// Only used internally in the command graph. Kept in the header for better inlining performance.
+class CommandGraphNode final : angle::NonCopyable
+{
+  public:
+    CommandGraphNode();
+    ~CommandGraphNode();
+
+    // Immutable queries for when we're walking the commands tree.
+    CommandBuffer *getOutsideRenderPassCommands();
+
+    CommandBuffer *getInsideRenderPassCommands()
+    {
+        ASSERT(!mHasChildren);
+        return &mInsideRenderPassCommands;
+    }
+
+    // For outside the render pass (copies, transitions, etc).
+    angle::Result beginOutsideRenderPassRecording(Context *context,
+                                                  const CommandPool &commandPool,
+                                                  CommandBuffer **commandsOut);
+
+    // For rendering commands (draws).
+    angle::Result beginInsideRenderPassRecording(Context *context, CommandBuffer **commandsOut);
+
+    // storeRenderPassInfo and append*RenderTarget store info relevant to the RenderPass.
+    void storeRenderPassInfo(const Framebuffer &framebuffer,
+                             const gl::Rectangle renderArea,
+                             const vk::RenderPassDesc &renderPassDesc,
+                             const std::vector<VkClearValue> &clearValues);
+
+    // Dependency commands order node execution in the command graph.
+    // Once a node has commands that must happen after it, recording is stopped and the node is
+    // frozen forever.
+    static void SetHappensBeforeDependency(CommandGraphNode *beforeNode,
+                                           CommandGraphNode *afterNode);
+    static void SetHappensBeforeDependencies(const std::vector<CommandGraphNode *> &beforeNodes,
+                                             CommandGraphNode *afterNode);
+    bool hasParents() const;
+    bool hasChildren() const { return mHasChildren; }
+
+    // Commands for traversing the node on a flush operation.
+    VisitedState visitedState() const;
+    void visitParents(std::vector<CommandGraphNode *> *stack);
+    angle::Result visitAndExecute(Context *context,
+                                  Serial serial,
+                                  RenderPassCache *renderPassCache,
+                                  CommandBuffer *primaryCommandBuffer);
+
+    const gl::Rectangle &getRenderPassRenderArea() const;
+
+  private:
+    void setHasChildren();
+
+    // Used for testing only.
+    bool isChildOf(CommandGraphNode *parent);
+
+    // Only used if we need a RenderPass for these commands.
+    RenderPassDesc mRenderPassDesc;
+    Framebuffer mRenderPassFramebuffer;
+    gl::Rectangle mRenderPassRenderArea;
+    gl::AttachmentArray<VkClearValue> mRenderPassClearValues;
+
+    // Keep a separate buffers for commands inside and outside a RenderPass.
+    // TODO(jmadill): We might not need inside and outside RenderPass commands separate.
+    CommandBuffer mOutsideRenderPassCommands;
+    CommandBuffer mInsideRenderPassCommands;
+
+    // Parents are commands that must be submitted before 'this' CommandNode can be submitted.
+    std::vector<CommandGraphNode *> mParents;
+
+    // If this is true, other commands exist that must be submitted after 'this' command.
+    bool mHasChildren;
+
+    // Used when traversing the dependency graph.
+    VisitedState mVisitedState;
+};
 
 // This is a helper class for back-end objects used in Vk command buffers. It records a serial
 // at command recording times indicating an order in the queue. We use Fences to detect when
@@ -79,10 +161,17 @@ class CommandGraphResource
     void onWriteImpl(CommandGraphNode *writingNode, Serial currentSerial);
 
     // Returns true if this node has a current writing node with no children.
-    bool hasChildlessWritingNode() const;
+    bool hasChildlessWritingNode() const
+    {
+        return (mCurrentWritingNode != nullptr && !mCurrentWritingNode->hasChildren());
+    }
 
     // Checks if we're in a RenderPass without children.
-    bool hasStartedRenderPass() const;
+    bool hasStartedRenderPass() const
+    {
+        return hasChildlessWritingNode() &&
+               mCurrentWritingNode->getInsideRenderPassCommands()->valid();
+    }
 
     // Updates the in-use serial tracked for this resource. Will clear dependencies if the resource
     // was not used in this set of command nodes.
@@ -93,13 +182,6 @@ class CommandGraphResource
     CommandGraphNode *mCurrentWritingNode;
 };
 
-enum class VisitedState
-{
-    Unvisited,
-    Ready,
-    Visited,
-};
-
 // Translating OpenGL commands into Vulkan and submitting them immediately loses out on some
 // of the powerful flexiblity Vulkan offers in RenderPasses. Load/Store ops can automatically
 // clear RenderPass attachments, or preserve the contents. RenderPass automatic layout transitions

src/libANGLE/renderer/vulkan/RendererVk.cpp

@@ -867,11 +867,6 @@ angle::Result RendererVk::submitFrame(vk::Context *context,
     return angle::Result::Continue();
 }
 
-Serial RendererVk::getCurrentQueueSerial() const
-{
-    return mCurrentQueueSerial;
-}
-
 bool RendererVk::isSerialInUse(Serial serial) const
 {
     return serial > mLastCompletedQueueSerial;

src/libANGLE/renderer/vulkan/RendererVk.h

@@ -74,7 +74,7 @@ class RendererVk : angle::NonCopyable
     const gl::Limitations &getNativeLimitations() const;
     uint32_t getMaxActiveTextures();
 
-    Serial getCurrentQueueSerial() const;
+    Serial getCurrentQueueSerial() const { return mCurrentQueueSerial; }
 
     bool isSerialInUse(Serial serial) const;
 

src/libANGLE/renderer/vulkan/vk_utils.cpp

@@ -507,25 +507,6 @@ void CommandBuffer::endRenderPass()
     vkCmdEndRenderPass(mHandle);
 }
 
-void CommandBuffer::draw(uint32_t vertexCount,
-                         uint32_t instanceCount,
-                         uint32_t firstVertex,
-                         uint32_t firstInstance)
-{
-    ASSERT(valid());
-    vkCmdDraw(mHandle, vertexCount, instanceCount, firstVertex, firstInstance);
-}
-
-void CommandBuffer::drawIndexed(uint32_t indexCount,
-                                uint32_t instanceCount,
-                                uint32_t firstIndex,
-                                int32_t vertexOffset,
-                                uint32_t firstInstance)
-{
-    ASSERT(valid());
-    vkCmdDrawIndexed(mHandle, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
-}
-
 void CommandBuffer::bindPipeline(VkPipelineBindPoint pipelineBindPoint,
                                  const vk::Pipeline &pipeline)
 {

src/libANGLE/renderer/vulkan/vk_utils.h

@@ -380,13 +380,22 @@ class CommandBuffer : public WrappedObject<CommandBuffer, VkCommandBuffer>
     void draw(uint32_t vertexCount,
               uint32_t instanceCount,
               uint32_t firstVertex,
-              uint32_t firstInstance);
+              uint32_t firstInstance)
+    {
+        ASSERT(valid());
+        vkCmdDraw(mHandle, vertexCount, instanceCount, firstVertex, firstInstance);
+    }
 
     void drawIndexed(uint32_t indexCount,
                      uint32_t instanceCount,
                      uint32_t firstIndex,
                      int32_t vertexOffset,
-                     uint32_t firstInstance);
+                     uint32_t firstInstance)
+    {
+        ASSERT(valid());
+        vkCmdDrawIndexed(mHandle, indexCount, instanceCount, firstIndex, vertexOffset,
+                         firstInstance);
+    }
 
     void bindPipeline(VkPipelineBindPoint pipelineBindPoint, const Pipeline &pipeline);
     void bindVertexBuffers(uint32_t firstBinding,