summaryrefslogtreecommitdiffstatshomepage
path: root/3rdparty/bgfx/3rdparty/spirv-tools/source/opt/dataflow.h
diff options
context:
space:
mode:
Diffstat (limited to '3rdparty/bgfx/3rdparty/spirv-tools/source/opt/dataflow.h')
-rw-r--r--3rdparty/bgfx/3rdparty/spirv-tools/source/opt/dataflow.h148
1 files changed, 148 insertions, 0 deletions
diff --git a/3rdparty/bgfx/3rdparty/spirv-tools/source/opt/dataflow.h b/3rdparty/bgfx/3rdparty/spirv-tools/source/opt/dataflow.h
new file mode 100644
index 00000000000..be07415db53
--- /dev/null
+++ b/3rdparty/bgfx/3rdparty/spirv-tools/source/opt/dataflow.h
@@ -0,0 +1,148 @@
+// Copyright (c) 2021 Google LLC.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef SOURCE_OPT_DATAFLOW_H_
+#define SOURCE_OPT_DATAFLOW_H_
+
+#include <queue>
+#include <unordered_map>
+#include <vector>
+
+#include "source/opt/instruction.h"
+#include "source/opt/ir_context.h"
+
+namespace spvtools {
+namespace opt {
+
+// Generic data-flow analysis.
+// Maintains a worklist of instructions to process and processes them in a
+// specified order. See also ForwardDataFlowAnalysis, which is specialized for
+// forward data-flow analysis.
+class DataFlowAnalysis {
+ public:
+ // The result of a |Visit| operation on an instruction.
+ // This is used to determine when analysis has reached a fixpoint.
+ enum class VisitResult {
+ // The analysis result for this instruction has changed.
+ // This means that any instructions that depend on it (its successors) must
+ // be recomputed.
+ kResultChanged,
+ // The analysis result for this instruction has not changed.
+ // When all visit operations return |kResultFixed|, the analysis has reached
+ // a fixpoint (converged).
+ kResultFixed,
+ };
+
+ virtual ~DataFlowAnalysis() {}
+
+ // Run this analysis on a given function.
+ // For analyses which work interprocedurally, |function| may be ignored.
+ void Run(Function* function);
+
+ protected:
+ DataFlowAnalysis(IRContext& context) : context_(context) {}
+
+ // Initialize the worklist for a given function.
+ // |is_first_iteration| is true on the first call to |Run| and false
+ // afterwards. All subsequent runs are only necessary to check if the analysis
+ // has converged; if |EnqueueSuccessors| is complete, |InitializeWorklist|
+ // should do nothing after the first iteration.
+ virtual void InitializeWorklist(Function* function,
+ bool is_first_iteration) = 0;
+
+ // Enqueues the successors (instructions which use the analysis result) of
+ // |inst|. This is not required to be complete, but convergence is faster when
+ // it is. This is called whenever |Visit| returns |kResultChanged|.
+ virtual void EnqueueSuccessors(Instruction* inst) = 0;
+
+ // Visits the given instruction, recomputing the analysis result. This is
+ // called once per instruction queued in |InitializeWorklist| and afterward
+ // when a predecessor is changed, through |EnqueueSuccessors|.
+ virtual VisitResult Visit(Instruction* inst) = 0;
+
+ // Enqueues the given instruction to be visited. Ignored if already in the
+ // worklist.
+ bool Enqueue(Instruction* inst);
+
+ IRContext& context() { return context_; }
+
+ private:
+ // Runs one pass, calling |InitializeWorklist| and then iterating through the
+ // worklist until all fixed.
+ VisitResult RunOnce(Function* function, bool is_first_iteration);
+
+ IRContext& context_;
+ std::unordered_map<Instruction*, bool> on_worklist_;
+ // The worklist, which contains the list of instructions to be visited.
+ //
+ // The choice of data structure was influenced by the data in "Iterative
+ // Data-flow Analysis, Revisited" (Cooper et al, 2002).
+ // https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.125.1549&rep=rep1&type=pdf
+ // The paper shows that the overall performance benefit of a priority queue
+ // over a regular queue or stack is relatively small (or negative).
+ //
+ // A queue has the advantage that nodes are visited in the same order they are
+ // enqueued, which relieves the analysis from inserting nodes "backwards", for
+ // example in worklist initialization. Also, as the paper claims that sorting
+ // successors does not improve runtime, we can use a single queue which is
+ // modified during iteration.
+ std::queue<Instruction*> worklist_;
+};
+
+// A generic data flow analysis, specialized for forward analysis.
+class ForwardDataFlowAnalysis : public DataFlowAnalysis {
+ public:
+ // Indicates where labels should be in the worklist RPO ordering.
+ enum class LabelPosition {
+ // Labels should be placed at the beginning of their blocks.
+ kLabelsAtBeginning,
+ // Labels should be placed at the end of their blocks.
+ kLabelsAtEnd,
+ // Labels should not be in the worklist.
+ kNoLabels,
+ // Only labels should be placed in the worklist.
+ kLabelsOnly,
+ };
+
+ ForwardDataFlowAnalysis(IRContext& context, LabelPosition label_position)
+ : DataFlowAnalysis(context), label_position_(label_position) {}
+
+ protected:
+ // Initializes the worklist in reverse postorder, regardless of
+ // |is_first_iteration|. Labels are placed according to the label position
+ // specified in the constructor.
+ void InitializeWorklist(Function* function, bool is_first_iteration) override;
+
+ // Enqueues the users and block successors of the given instruction.
+ // See |EnqueueUsers| and |EnqueueBlockSuccessors|.
+ void EnqueueSuccessors(Instruction* inst) override {
+ EnqueueUsers(inst);
+ EnqueueBlockSuccessors(inst);
+ }
+
+ // Enqueues the users of the given instruction.
+ void EnqueueUsers(Instruction* inst);
+
+ // Enqueues the labels of the successors of the block corresponding to the
+ // given label instruction. Does nothing for other instructions.
+ void EnqueueBlockSuccessors(Instruction* inst);
+
+ private:
+ LabelPosition label_position_;
+};
+
+} // namespace opt
+} // namespace spvtools
+
+#endif // SOURCE_OPT_DATAFLOW_H_