IntenseWebs/openvino
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[IE CLDNN] Revert fix for profiling of multiple kernel implementations (#2219) (#2595)

Browse Source
This commit is contained in:
Jedrzej Hajduczenia 2020-10-13 15:40:30 +02:00 committed by GitHub
parent 565b504c1c
commit 4d138307f4
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
5 changed files with 41 additions and 124 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

81
inference-engine/thirdparty/clDNN/src/gpu/ocl_base_event.cpp vendored
View File

@ -121,73 +121,40 @@ bool base_events::is_set_impl() {
}
bool base_events::get_profiling_info_impl(std::list<instrumentation::profiling_interval>& info) {
// For every profiling period (i.e. submission / starting / executing),
// the goal is to sum up all disjoint durations of its projection on the time axis
std::map<std::string, std::vector<std::pair<unsigned long long, unsigned long long>>> all_durations;
cl_ulong min_queue = CL_ULONG_MAX;
cl_ulong min_sub = CL_ULONG_MAX;
cl_ulong min_start = CL_ULONG_MAX;
uint64_t execution_time = 0;
for (size_t i = 0; i < _events.size(); i++) {
auto be = dynamic_cast<base_event*>(_events[i].get());
if (!is_event_profiled(be->_event))
continue;
for (auto& period : profiling_periods) {
cl_ulong ev_start;
cl_ulong ev_end;
be->_event.getProfilingInfo(period.start, &ev_start);
be->_event.getProfilingInfo(period.stop, &ev_end);
auto ev_duration = std::make_pair(static_cast<unsigned long long>(ev_start),
static_cast<unsigned long long>(ev_end));
cl_ulong curr_queue;
cl_ulong curr_sub;
cl_ulong curr_start;
cl_ulong curr_end;
be->_event.getProfilingInfo(CL_PROFILING_COMMAND_QUEUED, &curr_queue);
be->_event.getProfilingInfo(CL_PROFILING_COMMAND_SUBMIT, &curr_sub);
be->_event.getProfilingInfo(CL_PROFILING_COMMAND_START, &curr_start);
be->_event.getProfilingInfo(CL_PROFILING_COMMAND_END, &curr_end);
auto& durations = all_durations[period.name];
bool ev_duration_merged = false;
auto it = durations.begin();
if (curr_queue < min_queue)
min_queue = curr_queue;
while (it != durations.end()) {
auto& duration = *it;
if ((duration.second >= ev_duration.first) && (duration.first <= ev_duration.second)) {
if ((duration.first == ev_duration.first) && (duration.second == ev_duration.second)) {
if (!ev_duration_merged) {
ev_duration_merged = true;
break;
} else {
it = durations.erase(it);
}
} else {
if (!ev_duration_merged) {
duration.first = std::min(duration.first, ev_duration.first);
duration.second = std::max(duration.second, ev_duration.second);
ev_duration = duration;
ev_duration_merged = true;
it++;
} else {
if (duration.second > ev_duration.second) {
ev_duration.second = duration.second;
it--;
it->second = ev_duration.second;
it++;
}
it = durations.erase(it);
}
}
} else {
it++;
}
}
if (curr_sub < min_sub)
min_sub = curr_sub;
if (!ev_duration_merged) {
durations.insert(it, ev_duration);
}
}
if (curr_start < min_start)
min_start = curr_start;
execution_time += curr_end - curr_start;
}
for (auto& period : profiling_periods) {
unsigned long long sum = 0;
for (auto& duration : all_durations[period.name]) {
sum += (duration.second - duration.first);
}
info.push_back(get_profiling_interval(period.name, 0, sum));
}
info.push_back(get_profiling_interval(profiling_periods[0].name, min_sub, min_queue));
info.push_back(get_profiling_interval(profiling_periods[1].name, min_start, min_sub));
info.push_back(get_profiling_interval(profiling_periods[2].name, 0, execution_time));
return true;
}

26
inference-engine/thirdparty/clDNN/src/gpu/ocl_base_event.h vendored
View File

@ -77,17 +77,7 @@ protected:
struct base_events : virtual public ocl_base_event {
public:
base_events(std::shared_ptr<gpu_toolkit> ctx, std::vector<event_impl::ptr> const& ev)
: ocl_base_event(0, true), _ctx(ctx) {
for (size_t i = 0; i < ev.size(); i++) {
auto multiple_events = dynamic_cast<base_events*>(ev[i].get());
if (multiple_events) {
for (size_t j = 0; j < multiple_events->_events.size(); j++) {
_events.push_back(multiple_events->_events[j]);
}
} else {
_events.push_back(ev[i]);
}
}
: ocl_base_event(0, true), _ctx(ctx), _events(ev) {
set_queue_stamp();
}
@ -96,28 +86,18 @@ public:
void attach_events(const std::vector<event_impl::ptr>& ev) {
if (_attached)
throw std::runtime_error("Trying to attach events to valid event object.");
for (size_t i = 0; i < ev.size(); i++) {
auto multiple_events = dynamic_cast<base_events*>(ev[i].get());
if (multiple_events) {
for (size_t j = 0; j < multiple_events->_events.size(); j++) {
_events.push_back(multiple_events->_events[j]);
}
} else {
_events.push_back(ev[i]);
}
}
_events = ev;
_attached = true;
set_queue_stamp();
}
std::shared_ptr<gpu_toolkit> get_context() const { return _ctx; }
const std::vector<event_impl::ptr>& get_events() { return _events; };
private:
void set_queue_stamp() {
uint64_t _queue_stamp_max = 0;
for (size_t i = 0; i < _events.size(); i++) {
auto* _base_event = dynamic_cast<ocl_base_event*>(_events[i].get());
auto* _base_event = dynamic_cast<base_event*>(_events[i].get());
if (_base_event->get_queue_stamp() > _queue_stamp_max)
_queue_stamp_max = _base_event->get_queue_stamp();
}

30
inference-engine/thirdparty/clDNN/src/gpu/ocl_queue_wrapper.cpp vendored
View File

@ -79,18 +79,9 @@ event_impl::ptr gpu_queue::enqueue_kernel(kernels_cache::kernel_type const& kern
std::vector<cl::Event> dep_events;
auto dep_events_ptr = &dep_events;
if (!context()->get_configuration().host_out_of_order) {
for (auto& dep : deps) {
auto multiple_events = dynamic_cast<base_events*>(dep.get());
if (multiple_events) {
for (size_t i = 0; i < multiple_events->get_events().size(); i++) {
if (auto base_ev = dynamic_cast<base_event*>(multiple_events->get_events()[i].get()))
dep_events.push_back(base_ev->get());
}
} else {
if (auto base_ev = dynamic_cast<base_event*>(dep.get()))
dep_events.push_back(base_ev->get());
}
}
for (auto& dep : deps)
if (auto ocl_ev = dynamic_cast<base_event*>(dep.get()))
dep_events.push_back(ocl_ev->get());
} else {
dep_events_ptr = nullptr;
@ -122,18 +113,9 @@ event_impl::ptr gpu_queue::enqueue_marker(std::vector<event_impl::ptr> const& de
cl::Event ret_ev;
if (!enabled_single_kernel) {
std::vector<cl::Event> dep_events;
for (auto& dep : deps) {
auto multiple_events = dynamic_cast<base_events*>(dep.get());
if (multiple_events) {
for (size_t i = 0; i < multiple_events->get_events().size(); i++) {
if (auto base_ev = dynamic_cast<base_event*>(multiple_events->get_events()[i].get()))
dep_events.push_back(base_ev->get());
}
} else {
if (auto base_ev = dynamic_cast<base_event*>(dep.get()))
dep_events.push_back(base_ev->get());
}
}
for (auto& dep : deps)
if (auto ocl_ev = dynamic_cast<base_event*>(dep.get()))
dep_events.push_back(ocl_ev->get());
try {
_command_queue.enqueueMarkerWithWaitList(&dep_events, &ret_ev);

15
inference-engine/thirdparty/clDNN/src/gpu/ocl_toolkit.cpp vendored
View File

@ -229,18 +229,9 @@ void gpu_toolkit::release_pending_memory(uint32_t queue_id) { get_command_queue(
void gpu_toolkit::wait_for_events(std::vector<event_impl::ptr> const& events) {
std::vector<cl::Event> clevents;
for (auto& ev : events) {
auto multiple_events = dynamic_cast<base_events*>(ev.get());
if (multiple_events) {
for (size_t i = 0; i < multiple_events->get_events().size(); i++) {
if (auto base_ev = dynamic_cast<base_event*>(multiple_events->get_events()[i].get()))
clevents.push_back(base_ev->get());
}
} else {
if (auto base_ev = dynamic_cast<base_event*>(ev.get()))
clevents.push_back(base_ev->get());
}
}
for (auto& ev : events)
if (auto ocl_ev = dynamic_cast<base_event*>(ev.get()))
clevents.push_back(ocl_ev->get());
try {
cl::WaitForEvents(clevents);

13
inference-engine/thirdparty/clDNN/src/gpu/primitive_gpu_base.h vendored
View File

@ -107,11 +107,12 @@ protected:
virtual bool get_depthwise_sep_opt() const { return false; }
event_impl::ptr aggregate_events(const std::vector<event_impl::ptr>& events,
uint32_t net_id) const {
uint32_t net_id,
bool group = false) const {
if (events.size() == 1)
return events[0];
if (events.size() > 1)
if (group)
return _outer.get_program().get_engine().get_context()->group_events(net_id, events);
return events_waiter(_outer.get_program().get_engine().get_context()).run(net_id, events);
@ -160,7 +161,6 @@ protected:
}
std::vector<event_impl::ptr> tmp_events(events);
std::vector<event_impl::ptr> all_events;
// TODO - split should be handle in kernel selector by providing multiple kernels.
auto split = get_split();
@ -181,16 +181,13 @@ protected:
auto event = _kernels[k].run(net_id, _kernel_data.kernels[k], tmp_events);
new_events.push_back(event);
all_events.push_back(event);
}
tmp_events = new_events;
}
if ((all_events.size() == 0) && (tmp_events.size() > 0))
return aggregate_events(tmp_events, net_id);
return aggregate_events(all_events, net_id);
bool group_events = split > 1 ? true : false;
return aggregate_events(tmp_events, net_id, group_events);
}
};