BranchProbability.h Source File (original) (raw)

13#ifndef LLVM_SUPPORT_BRANCHPROBABILITY_H

14#define LLVM_SUPPORT_BRANCHPROBABILITY_H

19#include

20#include

21#include

22#include

24namespace llvm {

32class BranchProbability {

37 static constexpr uint32_t D = 1u << 31;

38 static constexpr uint32_t UnknownN = UINT32_MAX;

44public:

48 bool isZero() const { return N == 0; }

49 bool isUnknown() const { return N == UnknownN; }

65 template

67 ProbabilityIter End);

69 template

76 double toDouble() const { return static_cast<double>(N) / D; }

83#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)

85#endif

100

102

103

105

107 assert(N != UnknownN && RHS.N != UnknownN &&

108 "Unknown probability cannot participate in arithmetics.");

109

111 return *this;

112 }

113

115 assert(N != UnknownN && RHS.N != UnknownN &&

116 "Unknown probability cannot participate in arithmetics.");

117

118 N = N < RHS.N ? 0 : N - RHS.N;

119 return *this;

120 }

121

123 assert(N != UnknownN && RHS.N != UnknownN &&

124 "Unknown probability cannot participate in arithmetics.");

125 N = (static_cast<uint64_t>(N) * RHS.N + D / 2) / D;

126 return *this;

127 }

128

130 assert(N != UnknownN &&

131 "Unknown probability cannot participate in arithmetics.");

133 return *this;

134 }

135

137 assert(N != UnknownN && RHS.N != UnknownN &&

138 "Unknown probability cannot participate in arithmetics.");

139 N = (static_cast<uint64_t>(N) * D + RHS.N / 2) / RHS.N;

140 return *this;

141 }

142

144 assert(N != UnknownN &&

145 "Unknown probability cannot participate in arithmetics.");

146 assert(RHS > 0 && "The divider cannot be zero.");

147 N /= RHS;

148 return *this;

149 }

150

151 BranchProbability operator+(BranchProbability RHS) const {

152 BranchProbability Prob(*this);

153 Prob += RHS;

154 return Prob;

155 }

156

157 BranchProbability operator-(BranchProbability RHS) const {

158 BranchProbability Prob(*this);

159 Prob -= RHS;

160 return Prob;

161 }

162

163 BranchProbability operator*(BranchProbability RHS) const {

164 BranchProbability Prob(*this);

165 Prob *= RHS;

166 return Prob;

167 }

168

170 BranchProbability Prob(*this);

171 Prob *= RHS;

172 return Prob;

173 }

174

175 BranchProbability operator/(BranchProbability RHS) const {

176 BranchProbability Prob(*this);

177 Prob /= RHS;

178 return Prob;

179 }

180

182 BranchProbability Prob(*this);

183 Prob /= RHS;

184 return Prob;

185 }

186

189

191 assert(N != UnknownN && RHS.N != UnknownN &&

192 "Unknown probability cannot participate in comparisons.");

193 return N < RHS.N;

194 }

195

197 assert(N != UnknownN && RHS.N != UnknownN &&

198 "Unknown probability cannot participate in comparisons.");

199 return RHS < *this;

200 }

201

203 assert(N != UnknownN && RHS.N != UnknownN &&

204 "Unknown probability cannot participate in comparisons.");

205 return !(RHS < *this);

206 }

207

209 assert(N != UnknownN && RHS.N != UnknownN &&

210 "Unknown probability cannot participate in comparisons.");

211 return !(*this < RHS);

212 }

213};

214

216 return Prob.print(OS);

217}

218

219template

221 ProbabilityIter End) {

222 if (Begin == End)

223 return;

224

225 unsigned UnknownProbCount = 0;

227 [&](uint64_t S, const BranchProbability &BP) {

229 return S + BP.N;

230 UnknownProbCount++;

231 return S;

232 });

233

234 if (UnknownProbCount > 0) {

236

237

238

242

243 std::replace_if(Begin, End,

244 [](const BranchProbability &BP) { return BP.isUnknown(); },

245 ProbForUnknown);

246

248 return;

249 }

250

251 if (Sum == 0) {

252 BranchProbability BP(1, std::distance(Begin, End));

253 std::fill(Begin, End, BP);

254 return;

255 }

256

257 for (auto I = Begin; I != End; ++I)

258 I->N = (I->N * uint64_t(D) + Sum / 2) / Sum;

259}

260

261}

262

263#endif

assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")

#define LLVM_DUMP_METHOD

Mark debug helper function definitions like dump() that should not be stripped from debug builds.

Definition BranchProbability.h:32

LLVM_DUMP_METHOD void dump() const

static LLVM_ABI BranchProbability getBranchProbability(uint64_t Numerator, uint64_t Denominator)

BranchProbability operator-(BranchProbability RHS) const

Definition BranchProbability.h:157

BranchProbability & operator-=(BranchProbability RHS)

Definition BranchProbability.h:114

static uint32_t getDenominator()

Definition BranchProbability.h:75

bool operator<(BranchProbability RHS) const

Definition BranchProbability.h:190

bool operator!=(BranchProbability RHS) const

Definition BranchProbability.h:188

static BranchProbability getRaw(uint32_t N)

Definition BranchProbability.h:56

bool operator==(BranchProbability RHS) const

Definition BranchProbability.h:187

BranchProbability operator/(uint32_t RHS) const

Definition BranchProbability.h:181

BranchProbability & operator/=(BranchProbability RHS)

Definition BranchProbability.h:136

BranchProbability pow(unsigned N) const

Compute pow(Probability, N).

bool operator<=(BranchProbability RHS) const

Definition BranchProbability.h:202

static BranchProbability getOne()

Definition BranchProbability.h:52

LLVM_ABI raw_ostream & print(raw_ostream &OS) const

BranchProbability & operator*=(BranchProbability RHS)

Definition BranchProbability.h:122

LLVM_ABI uint64_t scaleByInverse(uint64_t Num) const

Scale a large integer by the inverse.

bool isZero() const

Definition BranchProbability.h:48

BranchProbability operator*(BranchProbability RHS) const

Definition BranchProbability.h:163

static BranchProbability getUnknown()

Definition BranchProbability.h:53

BranchProbability operator/(BranchProbability RHS) const

Definition BranchProbability.h:175

uint32_t getNumerator() const

Definition BranchProbability.h:74

bool isUnknown() const

Definition BranchProbability.h:49

LLVM_ABI uint64_t scale(uint64_t Num) const

Scale a large integer.

BranchProbability()

Definition BranchProbability.h:45

static void normalizeProbabilities(ProbabilityContainer &&R)

Definition BranchProbability.h:70

BranchProbability operator+(BranchProbability RHS) const

Definition BranchProbability.h:151

bool operator>=(BranchProbability RHS) const

Definition BranchProbability.h:208

BranchProbability operator*(uint32_t RHS) const

Definition BranchProbability.h:169

BranchProbability & operator*=(uint32_t RHS)

Definition BranchProbability.h:129

BranchProbability getCompl() const

Definition BranchProbability.h:79

BranchProbability & operator+=(BranchProbability RHS)

Definition BranchProbability.h:106

double toDouble() const

Definition BranchProbability.h:76

BranchProbability & operator/=(uint32_t RHS)

Definition BranchProbability.h:143

static BranchProbability getZero()

Definition BranchProbability.h:51

bool operator>(BranchProbability RHS) const

Definition BranchProbability.h:196

static void normalizeProbabilities(ProbabilityIter Begin, ProbabilityIter End)

Definition BranchProbability.h:220

This class implements an extremely fast bulk output stream that can only output to a stream.

This is an optimization pass for GlobalISel generic memory operations.

constexpr auto adl_begin(RangeT &&range) -> decltype(adl_detail::begin_impl(std::forward< RangeT >(range)))

Returns the begin iterator to range using std::begin and function found through Argument-Dependent Lo...

constexpr auto adl_end(RangeT &&range) -> decltype(adl_detail::end_impl(std::forward< RangeT >(range)))

Returns the end iterator to range using std::end and functions found through Argument-Dependent Looku...

raw_ostream & operator<<(raw_ostream &OS, const APFixedPoint &FX)