1//===---------------- IncrementalSourceMgr.h --------------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8/// \file
9/// This file contains IncrementalSourceMgr, an implementation of SourceMgr
10/// that allows users to add new instructions incrementally / dynamically.
11///
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_MCA_INCREMENTALSOURCEMGR_H
15#define LLVM_MCA_INCREMENTALSOURCEMGR_H
16
17#include "llvm/MCA/SourceMgr.h"
18#include <deque>
19
20namespace llvm {
21namespace mca {
22
23/// An implementation of \a SourceMgr that allows users to add new instructions
24/// incrementally / dynamically.
25/// Note that this SourceMgr takes ownership of all \a mca::Instruction.
26class IncrementalSourceMgr : public SourceMgr {
27 /// Owner of all mca::Instruction instances. Note that we use std::deque here
28 /// to have a better throughput, in comparison to std::vector or
29 /// llvm::SmallVector, as they usually pay a higher re-allocation cost when
30 /// there is a large number of instructions.
31 std::deque<UniqueInst> InstStorage;
32
33 /// Instructions that are ready to be used. Each of them is a pointer of an
34 /// \a UniqueInst inside InstStorage.
35 std::deque<Instruction *> Staging;
36
37 /// Current instruction index.
38 unsigned TotalCounter = 0U;
39
40 /// End-of-stream flag.
41 bool EOS = false;
42
43 /// Called when an instruction is no longer needed.
44 using InstFreedCallback = std::function<void(Instruction *)>;
45 InstFreedCallback InstFreedCB;
46
47public:
48 IncrementalSourceMgr() = default;
49
50 void clear();
51
52 /// Set a callback that is invoked when a mca::Instruction is
53 /// no longer needed. This is usually used for recycling the
54 /// instruction.
55 void setOnInstFreedCallback(InstFreedCallback CB) { InstFreedCB = CB; }
56
57 ArrayRef<UniqueInst> getInstructions() const override {
58 llvm_unreachable("Not applicable");
59 }
60
61 bool hasNext() const override { return !Staging.empty(); }
62 bool isEnd() const override { return EOS; }
63
64 SourceRef peekNext() const override {
65 assert(hasNext());
66 return SourceRef(TotalCounter, *Staging.front());
67 }
68
69 /// Add a new instruction.
70 void addInst(UniqueInst &&Inst) {
71 InstStorage.emplace_back(args: std::move(Inst));
72 Staging.push_back(x: InstStorage.back().get());
73 }
74
75 /// Add a recycled instruction.
76 void addRecycledInst(Instruction *Inst) { Staging.push_back(x: Inst); }
77
78 void updateNext() override;
79
80 /// Mark the end of instruction stream.
81 void endOfStream() { EOS = true; }
82
83#ifndef NDEBUG
84 /// Print statistic about instruction recycling stats.
85 void printStatistic(raw_ostream &OS);
86#endif
87};
88
89} // end namespace mca
90} // end namespace llvm
91
92#endif // LLVM_MCA_INCREMENTALSOURCEMGR_H
93