Method run

test/expr/ModuleTest.cpp:1047–1125

class MutlThreadConstReplaceTest : public MNNTestCase {
public:
    virtual bool run(int precision) {
        auto executor = cloneCurrentExecutor();
        ExecutorScope scope(executor);
        auto func = [precision](VARP y, int thread) {
            flatbuffers::FlatBufferBuilder builderOutput(1024);
            {
                std::unique_ptr<MNN::NetT> net(new NetT);
                Variable::save({y}, net.get());
                auto len = MNN::Net::Pack(builderOutput, net.get());
                builderOutput.Finish(len);
            }
            int sizeOutput    = builderOutput.GetSize();
            auto bufferOutput = builderOutput.GetBufferPointer();
            MNN::Express::Module::Config modConfig;
            modConfig.rearrange = true;
            std::shared_ptr<MNN::Express::Module> net(MNN::Express::Module::load(std::vector<std::string>{}, std::vector<std::string>{}, bufferOutput, sizeOutput, &modConfig), MNN::Express::Module::destroy);

            ScheduleConfig config;
            BackendConfig bnConfig;
            bnConfig.precision = (MNN::BackendConfig::PrecisionMode)precision;
            config.numThread = 1;
            config.type = ExecutorScope::Current()->getAttr()->firstType;
            config.backendConfig = &bnConfig;

            std::vector<std::thread> threads;
            std::vector<float> summer(thread);
            std::mutex moduleMutex;

            for (int t = 0; t<thread; ++t) {
                threads.emplace_back([&, t]() {
                    auto newExe = Executor::newExecutor(config.type, bnConfig, 1);
                    ExecutorScope scope(newExe);
                    std::shared_ptr<Module> tempModule;
                    {
                        std::unique_lock<std::mutex> _l(moduleMutex);
                        tempModule.reset(Module::clone(net.get()), Module::destroy);
                    }
                    // Create Input
                    auto x = MNN::Express::_Input({1, 100}, NCHW);
                    auto xPtr = x->writeMap<float>();
                    for (int j=0; j<100; ++j) {
                        xPtr[j] = j / 100.0f;
                    }
                    x->unMap();
                    auto y = tempModule->onForward({x});
                    auto yPtr = y[0]->readMap<float>();
                    auto ySize = y[0]->getInfo()->size;
                    float sum = 0.0f;
                    for (int j=0; j<ySize; ++j) {
                        sum += yPtr[j];
                    }
                    y[0]->unMap();
                    {
                        std::unique_lock<std::mutex> _l(moduleMutex);
                        summer[t] = sum;
                    }
                });
            }