MimIR 0.1
MimIR is my Intermediate Representation
Loading...
Searching...
No Matches
schedule.h
Go to the documentation of this file.
1#pragma once
2
3#include "mim/nest.h"
4
5namespace mim {
6
7/// References a user.
8/// A Def `u` which uses Def `d` as `i^th` operand is a Use with Use::index `i` of Def `d`.
9class Use {
10public:
11 static constexpr size_t Type = -1_s;
12
13 Use() {}
14 Use(const Def* def, size_t index)
15 : def_(def)
16 , index_(index) {}
17
18 size_t index() const { return index_; }
19 const Def* def() const { return def_; }
20 operator const Def*() const { return def_; }
21 const Def* operator->() const { return def_; }
22 bool operator==(Use other) const { return this->def_ == other.def_ && this->index_ == other.index_; }
23
24private:
25 const Def* def_;
26 size_t index_;
27};
28
29struct UseHash {
30 inline size_t operator()(Use use) const {
31 if constexpr (sizeof(size_t) == 8)
32 return hash((u64(use.index())) << 32_u64 | u64(use->gid()));
33 else
34 return hash_combine(hash_begin(u16(use.index())), use->gid());
35 }
36};
37
38struct UseEq {
39 bool operator()(Use u1, Use u2) const { return u1 == u2; }
40};
41
42using Uses = absl::flat_hash_set<Use, UseHash, UseEq>;
43
44class Scheduler {
45public:
46 /// @name Construction
47 ///@{
48 Scheduler() = default;
49 explicit Scheduler(const Nest&);
50 Scheduler(const Scheduler&) = delete;
51 Scheduler(Scheduler&& other) noexcept
52 : Scheduler() {
53 swap(*this, other);
54 }
55 Scheduler& operator=(Scheduler other) noexcept { return swap(*this, other), *this; }
56 ///@}
57
58 /// @name Getters
59 ///@{
60 World& world() { return nest().world(); }
61 const Nest& nest() const { return *nest_; }
62 Def* root() const { return nest_->root()->mut(); }
63 const Uses& uses(const Def* def) const {
64 if (auto i = def2uses_.find(def); i != def2uses_.end()) return i->second;
65 return empty_;
66 }
67 ///@}
68
69 /// @name Compute Schedules
70 ///@{
71 const Nest::Node* early(const Def*);
72 const Nest::Node* late(Def* curr, const Def*);
73 const Nest::Node* smart(Def* curr, const Def*);
74 ///@}
75
76 /// @name Schedule Mutabales
77 /// Order of Mutables within a Scope.
78 ///@{
80 static Schedule schedule(const Nest&);
81 ///@}
82
83 friend void swap(Scheduler& s1, Scheduler& s2) noexcept {
84 using std::swap;
85 swap(s1.nest_, s2.nest_);
86 swap(s1.early_, s2.early_);
87 swap(s1.late_, s2.late_);
88 swap(s1.smart_, s2.smart_);
89 swap(s1.def2uses_, s2.def2uses_);
90 }
91
92private:
93 const Nest* nest_ = nullptr;
94 Uses empty_;
95 DefMap<const Nest::Node*> early_, late_, smart_;
96 DefMap<Uses> def2uses_;
97};
98
99} // namespace mim
Base class for all Defs.
Definition def.h:212
constexpr u32 gid() const noexcept
Definition def.h:231
Def * mut() const
The mutable capsulated in this Node or nullptr, if it's a virtual root comprising several Nodes.
Definition nest.h:22
Builds a nesting tree of all immutables‍/binders.
Definition nest.h:11
World & world() const
Definition nest.h:128
const Node * root() const
Definition nest.h:129
Def * root() const
Definition schedule.h:62
const Nest::Node * smart(Def *curr, const Def *)
Definition schedule.cpp:79
Scheduler(Scheduler &&other) noexcept
Definition schedule.h:51
Scheduler(const Scheduler &)=delete
Scheduler & operator=(Scheduler other) noexcept
Definition schedule.h:55
const Nest::Node * late(Def *curr, const Def *)
Definition schedule.cpp:58
const Uses & uses(const Def *def) const
Definition schedule.h:63
static Schedule schedule(const Nest &)
Definition schedule.cpp:114
World & world()
Definition schedule.h:60
const Nest & nest() const
Definition schedule.h:61
const Nest::Node * early(const Def *)
Definition schedule.cpp:42
friend void swap(Scheduler &s1, Scheduler &s2) noexcept
Definition schedule.h:83
Scheduler()=default
References a user.
Definition schedule.h:9
Use(const Def *def, size_t index)
Definition schedule.h:14
size_t index() const
Definition schedule.h:18
const Def * operator->() const
Definition schedule.h:21
bool operator==(Use other) const
Definition schedule.h:22
const Def * def() const
Definition schedule.h:19
The World represents the whole program and manages creation of MimIR nodes (Defs).
Definition world.h:33
Definition ast.h:14
GIDMap< const Def *, To > DefMap
Definition def.h:58
size_t hash_combine(size_t seed, T v)
Definition hash.h:58
absl::flat_hash_set< Use, UseHash, UseEq > Uses
Definition schedule.h:42
size_t hash(size_t h)
Definition hash.h:32
uint64_t u64
Definition types.h:34
size_t hash_begin()
Definition hash.h:71
uint16_t u16
Definition types.h:34
bool operator()(Use u1, Use u2) const
Definition schedule.h:39
size_t operator()(Use use) const
Definition schedule.h:30