Skip to content

Commit 14290c5

Browse files
Ivan Karachunbader
Ivan Karachun
authored and
bader
committed
[SYCL][NFC] Fixed typos in variable names (#912)
Signed-off-by: Ivan Karachun <[email protected]>
1 parent 9053642 commit 14290c5

File tree

3 files changed

+44
-43
lines changed

3 files changed

+44
-43
lines changed

‎sycl/include/CL/sycl/detail/scheduler/scheduler.hpp

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -36,10 +36,10 @@ struct MemObjRecord {
3636
std::vector<AllocaCommandBase *> MAllocaCommands;
3737

3838
// Contains latest read only commands working with memory object.
39-
std::vector<Command *> MReadLeafs;
39+
std::vector<Command *> MReadLeaves;
4040

4141
// Contains latest write commands working with memory object.
42-
std::vector<Command *> MWriteLeafs;
42+
std::vector<Command *> MWriteLeaves;
4343

4444
// The context which has the latest state of the memory object.
4545
ContextImplPtr MCurContext;
@@ -140,13 +140,13 @@ class Scheduler {
140140
// Removes MemObjRecord for memory object passed.
141141
void removeRecordForMemObj(SYCLMemObjI *MemObject);
142142

143-
// Add new command to leafs if needed.
144-
void AddNodeToLeafs(MemObjRecord *Record, Command *Cmd,
145-
access::mode AccessMode);
143+
// Add new command to leaves if needed.
144+
void AddNodeToLeaves(MemObjRecord *Record, Command *Cmd,
145+
access::mode AccessMode);
146146

147-
// Removes commands from leafs.
148-
void UpdateLeafs(const std::set<Command *> &Cmds, MemObjRecord *Record,
149-
access::mode AccessMode);
147+
// Removes commands from leaves.
148+
void UpdateLeaves(const std::set<Command *> &Cmds, MemObjRecord *Record,
149+
access::mode AccessMode);
150150

151151
std::vector<SYCLMemObjI *> MMemObjs;
152152

‎sycl/source/detail/scheduler/graph_builder.cpp

Lines changed: 34 additions & 33 deletions
Original file line numberDiff line numberDiff line change
@@ -121,41 +121,42 @@ Scheduler::GraphBuilder::getOrInsertMemObjRecord(const QueueImplPtr &Queue,
121121
return Record;
122122

123123
MemObject->MRecord.reset(new MemObjRecord{/*MAllocaCommands*/ {},
124-
/*MReadLeafs*/ {},
125-
/*MWriteLeafs*/ {},
124+
/*MReadLeaves*/ {},
125+
/*MWriteLeaves*/ {},
126126
Queue->get_context_impl(),
127127
/*MMemModified*/ false});
128128

129129
MMemObjs.push_back(MemObject);
130130
return MemObject->MRecord.get();
131131
}
132132

133-
// Helper function which removes all values in Cmds from Leafs
134-
void Scheduler::GraphBuilder::UpdateLeafs(const std::set<Command *> &Cmds,
135-
MemObjRecord *Record,
136-
access::mode AccessMode) {
133+
// Helper function which removes all values in Cmds from Leaves
134+
void Scheduler::GraphBuilder::UpdateLeaves(const std::set<Command *> &Cmds,
135+
MemObjRecord *Record,
136+
access::mode AccessMode) {
137137

138138
const bool ReadOnlyReq = AccessMode == access::mode::read;
139139
if (ReadOnlyReq)
140140
return;
141141

142142
for (const Command *Cmd : Cmds) {
143-
auto NewEnd =
144-
std::remove(Record->MReadLeafs.begin(), Record->MReadLeafs.end(), Cmd);
145-
Record->MReadLeafs.erase(NewEnd, Record->MReadLeafs.end());
143+
auto NewEnd = std::remove(Record->MReadLeaves.begin(),
144+
Record->MReadLeaves.end(), Cmd);
145+
Record->MReadLeaves.erase(NewEnd, Record->MReadLeaves.end());
146146

147-
NewEnd = std::remove(Record->MWriteLeafs.begin(), Record->MWriteLeafs.end(),
148-
Cmd);
149-
Record->MWriteLeafs.erase(NewEnd, Record->MWriteLeafs.end());
147+
NewEnd = std::remove(Record->MWriteLeaves.begin(),
148+
Record->MWriteLeaves.end(), Cmd);
149+
Record->MWriteLeaves.erase(NewEnd, Record->MWriteLeaves.end());
150150
}
151151
}
152152

153-
void Scheduler::GraphBuilder::AddNodeToLeafs(MemObjRecord *Record, Command *Cmd,
154-
access::mode AccessMode) {
153+
void Scheduler::GraphBuilder::AddNodeToLeaves(MemObjRecord *Record,
154+
Command *Cmd,
155+
access::mode AccessMode) {
155156
if (AccessMode == access::mode::read)
156-
Record->MReadLeafs.push_back(Cmd);
157+
Record->MReadLeaves.push_back(Cmd);
157158
else
158-
Record->MWriteLeafs.push_back(Cmd);
159+
Record->MWriteLeaves.push_back(Cmd);
159160
}
160161

161162
UpdateHostRequirementCommand *Scheduler::GraphBuilder::insertUpdateHostReqCmd(
@@ -175,8 +176,8 @@ UpdateHostRequirementCommand *Scheduler::GraphBuilder::insertUpdateHostReqCmd(
175176
UpdateCommand->addDep(DepDesc{Dep, StoredReq, AllocaCmd});
176177
Dep->addUser(UpdateCommand);
177178
}
178-
UpdateLeafs(Deps, Record, Req->MAccessMode);
179-
AddNodeToLeafs(Record, UpdateCommand, Req->MAccessMode);
179+
UpdateLeaves(Deps, Record, Req->MAccessMode);
180+
AddNodeToLeaves(Record, UpdateCommand, Req->MAccessMode);
180181
return UpdateCommand;
181182
}
182183

@@ -261,8 +262,8 @@ Command *Scheduler::GraphBuilder::insertMemoryMove(MemObjRecord *Record,
261262
NewCmd->addDep(DepDesc{Dep, NewCmd->getRequirement(), AllocaCmdDst});
262263
Dep->addUser(NewCmd);
263264
}
264-
UpdateLeafs(Deps, Record, access::mode::read_write);
265-
AddNodeToLeafs(Record, NewCmd, access::mode::read_write);
265+
UpdateLeaves(Deps, Record, access::mode::read_write);
266+
AddNodeToLeaves(Record, NewCmd, access::mode::read_write);
266267
Record->MCurContext = Queue->get_context_impl();
267268
return NewCmd;
268269
}
@@ -299,8 +300,8 @@ Command *Scheduler::GraphBuilder::addCopyBack(Requirement *Req) {
299300
Dep->addUser(MemCpyCmd);
300301
}
301302

302-
UpdateLeafs(Deps, Record, Req->MAccessMode);
303-
AddNodeToLeafs(Record, MemCpyCmd, Req->MAccessMode);
303+
UpdateLeaves(Deps, Record, Req->MAccessMode);
304+
AddNodeToLeaves(Record, MemCpyCmd, Req->MAccessMode);
304305
if (MPrintOptionsArray[AfterAddCopyBack])
305306
printGraphAsDot("after_addCopyBack");
306307
return MemCpyCmd;
@@ -339,8 +340,8 @@ Command *Scheduler::GraphBuilder::addHostAccessor(Requirement *Req) {
339340
EmptyCmd->MCanEnqueue = false;
340341
EmptyCmd->MBlockReason = "A Buffer is locked by the host accessor";
341342

342-
UpdateLeafs({UpdateHostAccCmd}, Record, Req->MAccessMode);
343-
AddNodeToLeafs(Record, EmptyCmd, Req->MAccessMode);
343+
UpdateLeaves({UpdateHostAccCmd}, Record, Req->MAccessMode);
344+
AddNodeToLeaves(Record, EmptyCmd, Req->MAccessMode);
344345

345346
Req->MBlockedCmd = EmptyCmd;
346347

@@ -378,11 +379,11 @@ Scheduler::GraphBuilder::findDepsForReq(MemObjRecord *Record, Requirement *Req,
378379

379380
std::vector<Command *> ToAnalyze;
380381

381-
ToAnalyze = Record->MWriteLeafs;
382+
ToAnalyze = Record->MWriteLeaves;
382383

383384
if (!ReadOnlyReq)
384-
ToAnalyze.insert(ToAnalyze.begin(), Record->MReadLeafs.begin(),
385-
Record->MReadLeafs.end());
385+
ToAnalyze.insert(ToAnalyze.begin(), Record->MReadLeaves.begin(),
386+
Record->MReadLeaves.end());
386387

387388
while (!ToAnalyze.empty()) {
388389
Command *DepCmd = ToAnalyze.back();
@@ -464,8 +465,8 @@ AllocaCommandBase *Scheduler::GraphBuilder::getOrCreateAllocaForReq(
464465
auto *ParentAlloca =
465466
getOrCreateAllocaForReq(Record, &ParentRequirement, Queue);
466467
AllocaCmd = new AllocaSubBufCommand(Queue, *Req, ParentAlloca);
467-
UpdateLeafs(findDepsForReq(Record, Req, Queue->get_context_impl()),
468-
Record, access::mode::read_write);
468+
UpdateLeaves(findDepsForReq(Record, Req, Queue->get_context_impl()),
469+
Record, access::mode::read_write);
469470
} else {
470471

471472
const Requirement FullReq(/*Offset*/ {0, 0, 0}, Req->MMemoryRange,
@@ -523,7 +524,7 @@ AllocaCommandBase *Scheduler::GraphBuilder::getOrCreateAllocaForReq(
523524
}
524525

525526
Record->MAllocaCommands.push_back(AllocaCmd);
526-
Record->MWriteLeafs.push_back(AllocaCmd);
527+
Record->MWriteLeaves.push_back(AllocaCmd);
527528
}
528529
return AllocaCmd;
529530
}
@@ -578,13 +579,13 @@ Scheduler::GraphBuilder::addCG(std::unique_ptr<detail::CG> CommandGroup,
578579
NewCmd->addDep(DepDesc{Dep, Req, AllocaCmd});
579580
}
580581

581-
// Set new command as user for dependencies and update leafs.
582+
// Set new command as user for dependencies and update leaves.
582583
for (DepDesc &Dep : NewCmd->MDeps) {
583584
Dep.MDepCommand->addUser(NewCmd.get());
584585
const Requirement *Req = Dep.MDepRequirement;
585586
MemObjRecord *Record = getMemObjRecord(Req->MSYCLMemObj);
586-
UpdateLeafs({Dep.MDepCommand}, Record, Req->MAccessMode);
587-
AddNodeToLeafs(Record, NewCmd.get(), Req->MAccessMode);
587+
UpdateLeaves({Dep.MDepCommand}, Record, Req->MAccessMode);
588+
AddNodeToLeaves(Record, NewCmd.get(), Req->MAccessMode);
588589
}
589590

590591
// Register all the events as dependencies

‎sycl/source/detail/scheduler/scheduler.cpp

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -21,14 +21,14 @@ namespace sycl {
2121
namespace detail {
2222

2323
void Scheduler::waitForRecordToFinish(MemObjRecord *Record) {
24-
for (Command *Cmd : Record->MReadLeafs) {
24+
for (Command *Cmd : Record->MReadLeaves) {
2525
EnqueueResultT Res;
2626
bool Enqueued = GraphProcessor::enqueueCommand(Cmd, Res);
2727
if (!Enqueued && EnqueueResultT::FAILED == Res.MResult)
2828
throw runtime_error("Enqueue process failed.");
2929
GraphProcessor::waitForEvent(Cmd->getEvent());
3030
}
31-
for (Command *Cmd : Record->MWriteLeafs) {
31+
for (Command *Cmd : Record->MWriteLeaves) {
3232
EnqueueResultT Res;
3333
bool Enqueued = GraphProcessor::enqueueCommand(Cmd, Res);
3434
if (!Enqueued && EnqueueResultT::FAILED == Res.MResult)

0 commit comments

Comments
 (0)