ResourceManager.h Source File (original) (raw)

49 ResourceStrategy(const ResourceStrategy &) = delete;

50 ResourceStrategy &operator=(const ResourceStrategy &) = delete;

52public:

64};

73 const uint64_t ResourceUnitMask;

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118 uint64_t RemovedFromNextInSequence;

119

120public:

122 : ResourceUnitMask(UnitMask), NextInSequenceMask(UnitMask),

123 RemovedFromNextInSequence(0) {}

125

128};

137

138 const unsigned ProcResourceDescIndex;

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

165

166

167

168

169

170

171

172

173

174

175

177

178

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194 const int BufferSize;

195

196

197 unsigned AvailableSlots;

198

199

200

201

202

203

204

206

207 const bool IsAGroup;

208

209

210 bool isSubResourceReady(uint64_t SubResMask) const {

211 return ReadyMask & SubResMask;

212 }

213

214public:

217

218 unsigned getProcResourceID() const { return ProcResourceDescIndex; }

219 uint64_t getResourceMask() const { return ResourceMask; }

220 uint64_t getReadyMask() const { return ReadyMask; }

221 int getBufferSize() const { return BufferSize; }

222

223 bool isBuffered() const { return BufferSize > 0; }

224 bool isInOrder() const { return BufferSize == 1; }

225

226

227 bool isADispatchHazard() const { return BufferSize == 0; }

228 bool isReserved() const { return Unavailable; }

229

230 void setReserved() { Unavailable = true; }

231 void clearReserved() { Unavailable = false; }

232

233

234

235 LLVM_ABI bool isReady(unsigned NumUnits = 1) const;

236

238

239 bool isAResourceGroup() const { return IsAGroup; }

240

241 bool containsResource(uint64_t ID) const { return ResourceMask & ID; }

242

243 void markSubResourceAsUsed(uint64_t ID) {

244 assert(isSubResourceReady(ID));

245 ReadyMask ^= ID;

246 }

247

248 void releaseSubResource(uint64_t ID) {

249 assert(!isSubResourceReady(ID));

250 ReadyMask ^= ID;

251 }

252

253 unsigned getNumUnits() const {

254 return isAResourceGroup() ? 1U : llvm::popcount(ResourceSizeMask);

255 }

256

257

258

259

260

261

262

263

264

265

267

268

269

270

271

272 bool reserveBuffer() {

273 if (BufferSize <= 0)

274 return true;

275

276 --AvailableSlots;

277 assert(AvailableSlots <= static_cast<unsigned>(BufferSize));

278 return AvailableSlots;

279 }

280

281

282 void releaseBuffer() {

283

284 if (BufferSize <= 0)

285 return;

286

287 ++AvailableSlots;

288 assert(AvailableSlots <= static_cast<unsigned>(BufferSize));

289 }

290

291#ifndef NDEBUG

292 void dump() const;

293#endif

294};

295

296

297

298

299

300

301typedef std::pair<uint64_t, uint64_t> ResourceRef;

302

303

304

305typedef std::pair<unsigned, unsigned> BufferUsageEntry;

306

307

308

309

310

311

312

313

314

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343 std::vector<std::unique_ptr> Resources;

344 std::vector<std::unique_ptr> Strategies;

345

346

347 std::vector<uint64_t> Resource2Groups;

348

349

351

352

353

355

356

357

359

360

362

363

364 uint64_t AvailableProcResUnits;

365

366

367 uint64_t ReservedResourceGroups;

368

369

370

372

373

375

376

378

381

382 unsigned getNumUnits(uint64_t ResourceID) const;

383

384

385

386 LLVM_ABI void setCustomStrategyImpl(std::unique_ptr S,

388

389public:

392

393

394

395 void setCustomStrategy(std::unique_ptr S,

396 unsigned ResourceID) {

397 assert(ResourceID < ProcResID2Mask.size() &&

398 "Invalid resource index in input!");

399 return setCustomStrategyImpl(std::move(S), ProcResID2Mask[ResourceID]);

400 }

401

402

403

404 LLVM_ABI ResourceStateEvent canBeDispatched(uint64_t ConsumedBuffers) const;

405

406

408

409

410

412

413

414

415

416

418

419

420

422

423

425

426

427

428

429

431

432 uint64_t getProcResUnitMask() const { return ProcResUnitMask; }

433 uint64_t getAvailableProcResUnits() const { return AvailableProcResUnits; }

434

435 using ResourceWithCycles = std::pair<ResourceRef, ReleaseAtCycles>;

436

437 void issueInstruction(const InstrDesc &Desc,

438 SmallVectorImpl &Pipes) {

439 if (Desc.HasPartiallyOverlappingGroups)

440 return issueInstructionImpl(Desc, Pipes);

441

442 return fastIssueInstruction(Desc, Pipes);

443 }

444

445

446

447

448

449

450

452 fastIssueInstruction(const InstrDesc &Desc,

453 SmallVectorImpl &Pipes);

454

455

456

457

458

459

461 issueInstructionImpl(const InstrDesc &Desc,

462 SmallVectorImpl &Pipes);

463

464 LLVM_ABI void cycleEvent(SmallVectorImpl &ResourcesFreed);

465

466#ifndef NDEBUG

467 void dump() const {

468 for (const std::unique_ptr &Resource : Resources)

469 Resource->dump();

470 }

471#endif

472};