Lines Matching defs:ScheduleData
1338 struct ScheduleData;
3594 std::optional<ScheduleData *> Bundle,
3611 std::optional<ScheduleData *> Bundle,
3676 ScheduleData *BundleMember = *Bundle;
3895 /// A ScheduleData either represents a single instruction or a member of an
3898 struct ScheduleData {
3903 ScheduleData() = default;
3927 for (const ScheduleData *BundleMember = this; BundleMember;
3991 for (const ScheduleData *BundleMember = this; BundleMember;
4005 ScheduleData *SD = NextInBundle;
4025 ScheduleData *FirstInBundle = nullptr;
4029 ScheduleData *NextInBundle = nullptr;
4033 ScheduleData *NextLoadStore = nullptr;
4037 SmallVector<ScheduleData *, 4> MemoryDependencies;
4043 SmallVector<ScheduleData *, 4> ControlDependencies;
4045 /// This ScheduleData is in the current scheduling region if this matches
4071 const BoUpSLP::ScheduleData &SD) {
4089 /// ScheduleData is assigned for each instruction in between the boundaries of
4092 /// their correct scheduling. The ScheduleData is not allocated for the
4115 // Make a new scheduling region, i.e. all existing ScheduleData is not
4120 ScheduleData *getScheduleData(Instruction *I) {
4124 ScheduleData *SD = ScheduleDataMap.lookup(I);
4130 ScheduleData *getScheduleData(Value *V) {
4136 bool isInSchedulingRegion(ScheduleData *SD) const {
4143 void schedule(ScheduleData *SD, ReadyListType &ReadyList) {
4147 for (ScheduleData *BundleMember = SD; BundleMember;
4154 ScheduleData *OpDef = getScheduleData(I);
4160 ScheduleData *DepBundle = OpDef->FirstInBundle;
4202 for (ScheduleData *MemoryDepSD : BundleMember->MemoryDependencies) {
4207 ScheduleData *DepBundle = MemoryDepSD->FirstInBundle;
4216 for (ScheduleData *DepSD : BundleMember->ControlDependencies) {
4220 ScheduleData *DepBundle = DepSD->FirstInBundle;
4262 ScheduleData *SD = getScheduleData(I);
4272 /// Build a bundle from the ScheduleData nodes corresponding to the
4274 ScheduleData *buildBundle(ArrayRef<Value *> VL);
4281 std::optional<ScheduleData *>
4289 ScheduleData *allocateScheduleDataChunks();
4295 /// Initialize the ScheduleData structures for new instructions in the
4298 ScheduleData *PrevLoadStore,
4299 ScheduleData *NextLoadStore);
4303 void calculateDependencies(ScheduleData *SD, bool InsertInReadyList,
4311 /// Simple memory allocation for ScheduleData.
4312 SmallVector<std::unique_ptr<ScheduleData[]>> ScheduleDataChunks;
4314 /// The size of a ScheduleData array in ScheduleDataChunks.
4321 /// Attaches ScheduleData to Instruction.
4323 /// ScheduleData structures are recycled.
4324 DenseMap<Instruction *, ScheduleData *> ScheduleDataMap;
4327 SetVector<ScheduleData *> ReadyInsts;
4337 ScheduleData *FirstLoadStoreInRegion = nullptr;
4341 ScheduleData *LastLoadStoreInRegion = nullptr;
4355 /// is incremented which "removes" all ScheduleData from the region.
4357 /// initial SchedulingRegionID in ScheduleData (which is 0).
8430 std::optional<ScheduleData *> Bundle =
13860 // bundle. The end of the bundle is marked by null ScheduleData.
13872 // for BB in BlocksSchedules or there's no ScheduleData available for
13875 // size is reached, etc.). ScheduleData is initialized in the scheduling
17079 BoUpSLP::ScheduleData *
17081 ScheduleData *Bundle = nullptr;
17082 ScheduleData *PrevInBundle = nullptr;
17086 ScheduleData *BundleMember = getScheduleData(V);
17088 "no ScheduleData for bundle member "
17108 std::optional<BoUpSLP::ScheduleData *>
17122 ScheduleData *Bundle) {
17130 if (ScheduleData *SD = getScheduleData(I))
17151 ScheduleData *Picked = ReadyInsts.pop_back_val();
17179 ScheduleData *BundleMember = getScheduleData(V);
17181 "no ScheduleData for bundle member (maybe not in same basic block)");
17214 ScheduleData *Bundle = getScheduleData(OpValue);
17227 ScheduleData *BundleMember = Bundle;
17231 ScheduleData *Next = BundleMember->NextInBundle;
17241 BoUpSLP::ScheduleData *BoUpSLP::BlockScheduling::allocateScheduleDataChunks() {
17242 // Allocate a new ScheduleData for the instruction.
17244 ScheduleDataChunks.push_back(std::make_unique<ScheduleData[]>(ChunkSize));
17322 ScheduleData *PrevLoadStore,
17323 ScheduleData *NextLoadStore) {
17324 ScheduleData *CurrentLoadStore = PrevLoadStore;
17329 ScheduleData *SD = ScheduleDataMap.lookup(I);
17335 "new ScheduleData already in scheduling region");
17364 void BoUpSLP::BlockScheduling::calculateDependencies(ScheduleData *SD,
17369 SmallVector<ScheduleData *, 10> WorkList;
17373 ScheduleData *SD = WorkList.pop_back_val();
17374 for (ScheduleData *BundleMember = SD; BundleMember;
17387 if (ScheduleData *UseSD = getScheduleData(cast<Instruction>(U))) {
17389 ScheduleData *DestBundle = UseSD->FirstInBundle;
17402 ScheduleData *DestBundle = DepDest->FirstInBundle;
17470 ScheduleData *DepDest = BundleMember->NextLoadStore;
17503 ScheduleData *DestBundle = DepDest->FirstInBundle;
17542 if (ScheduleData *SD = getScheduleData(I)) {
17544 "ScheduleData not in scheduling region");
17571 bool operator()(ScheduleData *SD1, ScheduleData *SD2) const {
17575 std::set<ScheduleData *, ScheduleDataCompare> ReadyInsts;
17582 if (ScheduleData *SD = BS->getScheduleData(I)) {
17601 ScheduleData *Picked = *ReadyInsts.begin();
17606 for (ScheduleData *BundleMember = Picked; BundleMember;
17625 ScheduleData *SD = BS->getScheduleData(I);