megenginelite-sys 1.8.2

A safe megenginelite wrapper in Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

/**
 * \file src/plugin/impl/cpu_dispatch_checker.cpp
 * MegEngine is Licensed under the Apache License, Version 2.0 (the "License")
 *
 * Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 */

#include "megbrain/plugin/cpu_dispatch_checker.h"
#include "megbrain/comp_node_env.h"
#include "megbrain/graph.h"
#include "megbrain/graph/event.h"

using namespace mgb;

CPUDispatchChecker::CPUDispatchChecker(cg::ComputingGraph* graph) : PluginBase(graph) {
    auto on_exec_start = [this](const cg::event::OprExecKernelStart& event) {
        for (auto cn : cg::get_opr_comp_node_set(event.opr)) {
            if (cn.device_type() == CompNode::DeviceType::CPU) {
                auto callback = [this, cn]() { record(cn); };
                event.env->dispatch_on_comp_node(cn, callback);
            }
        }
    };

    auto on_exec_finish = [this](const cg::event::OprExecKernelEnd& event) {
        for (auto cn : cg::get_opr_comp_node_set(event.opr)) {
            if (cn.device_type() == CompNode::DeviceType::CPU) {
                auto callback = [this, cn, opr = event.opr]() { check(cn, opr); };
                event.env->dispatch_on_comp_node(cn, callback);
            }
        }
    };

    auto on_subgraph_associated = [this](const cg::event::SubgraphAssociated& event) {
        mgb_assert(event.par_graph == m_owner_graph);
        auto sub = std::make_unique<CPUDispatchChecker>(event.sub_graph);
        sub->m_failed_oprs = m_failed_oprs;
        sub->m_failed_oprs_mtx = m_failed_oprs_mtx;
        m_sub_graph_checkers.emplace_back(std::move(sub));
    };

    add_event_handler(graph->event().register_receiver<cg::event::OprExecKernelStart>(
            on_exec_start));
    add_event_handler(graph->event().register_receiver<cg::event::OprExecKernelEnd>(
            on_exec_finish));
    add_event_handler(graph->event().register_receiver<cg::event::SubgraphAssociated>(
            on_subgraph_associated));
}

void CPUDispatchChecker::record(CompNode cn) {
    auto num = CompNodeEnv::from_comp_node(cn)
                       .cpu_env()
                       .dispatcher->get_nr_dispatched_tasks();

    MGB_LOCK_GUARD(m_cn2nr_task_mtx);
    m_cn2nr_task[cn] = num;
}

void CPUDispatchChecker::check(CompNode cn, cg::OperatorNodeBase* opr) {
    size_t prev, now;
    {
        MGB_LOCK_GUARD(m_cn2nr_task_mtx);
        prev = m_cn2nr_task.at(cn);
    }
    now = CompNodeEnv::from_comp_node(cn)
                  .cpu_env()
                  .dispatcher->get_nr_dispatched_tasks();
    if (prev == now) {
        fprintf(stderr, "operator %s{%s} does not dispatch kernel on %s\n",
                opr->cname(), opr->dyn_typeinfo()->name, cn.to_string().c_str());
        {
            MGB_LOCK_GUARD(*m_failed_oprs_mtx);
            m_failed_oprs->insert(opr);
        }
    }
}

// vim: syntax=cpp.doxygen foldmethod=marker foldmarker=f{{{,f}}}