Method loadReuseModel

native/agent/ModelReusableAgent.cpp:443–501

According to the given package name, deserialize the serialized model file with the ReuseModel.fbs by FlatBuffers \param packageName The package name of the tested application

    /// by FlatBuffers
    /// \param packageName The package name of the tested application
    void ModelReusableAgent::loadReuseModel(const std::string &packageName) {
        std::string modelFilePath = STORAGE_PREFIX + packageName + ".fbm";

        this->_modelSavePath = modelFilePath;
        if (!this->_modelSavePath.empty()) {
            this->_defaultModelSavePath = STORAGE_PREFIX + packageName + ".tmp.fbm";
        }
        BLOG("begin load model: %s", this->_modelSavePath.c_str());

        std::ifstream modelFile(modelFilePath, std::ios::binary | std::ios::in);
        if (modelFile.fail()) {
            BLOG("read model file %s failed, check if file exists!", modelFilePath.c_str());
            return;
        }

        // load  model file to struct
        std::filebuf *fileBuffer = modelFile.rdbuf();
        // returns the new position of the altered control stream, which is the end of the file
        std::size_t filesize = fileBuffer->pubseekoff(0, modelFile.end, modelFile.in);
        // reset the position of the controlled stream
        fileBuffer->pubseekpos(0, modelFile.in);
        char *modelFileData = new char[filesize];
        //Reads count characters from the input sequence and stores them into a character array.
        fileBuffer->sgetn(modelFileData, static_cast<int>(filesize));
        auto reuseFBModel = GetReuseModel(modelFileData);

        // to std::map
        {
            std::lock_guard<std::mutex> reuseGuard(this->_reuseModelLock);
            this->_reuseModel.clear();
            this->_reuseQValue.clear();
        }
        auto reusedModelDataPtr = reuseFBModel->model();
        if (!reusedModelDataPtr) {
            BLOG("%s", "model data is null");
            return;
        }
        for (int entryIndex = 0; entryIndex < reusedModelDataPtr->size(); entryIndex++) {
            auto reuseEntryInReuseModel = reusedModelDataPtr->Get(entryIndex);
            uint64_t actionHash = reuseEntryInReuseModel->action();
            auto activityEntry = reuseEntryInReuseModel->targets();
            ReuseEntryM entryPtr;
            for (int targetIndex = 0; targetIndex < activityEntry->size(); targetIndex++) {
                auto targetEntry = activityEntry->Get(targetIndex);
                BDLOG("load model hash: %llu %s %d", actionHash,
                      targetEntry->activity()->str().c_str(), (int) targetEntry->times());
                entryPtr.insert(std::make_pair(
                        std::make_shared<std::string>(targetEntry->activity()->str()),
                        (int) targetEntry->times()));
            }
            if (!entryPtr.empty()) {
                std::lock_guard<std::mutex> reuseGuard(this->_reuseModelLock);
//            this->_reuseQValue.insert(std::make_pair(actionHash, reuseEntryInReuseModel->quality()));
                this->_reuseModel.insert(std::make_pair(actionHash, entryPtr));
            }
        }
        BLOG("loaded model contains actions: %zu", this->_reuseModel.size());
        delete[] modelFileData;