Method _gradForCommandMatMul

tools/train/source/grad/LoopGrad.cpp:21–135

        return gradValue;
    }
    static void _gradForCommandMatMul(const RegionCommandT* command, const std::map<int, int>& backwardMap, int tensorNumber, std::map<int, VARP>& extraInputs, std::map<int, VARP>& extraOutputs, std::vector<std::unique_ptr<RegionCommandT>>& dstCommands) {
        auto AIndex = command->indexes[1];
        auto BIndex = command->indexes[2];
        auto CIndex = command->indexes[0];
        auto transA = command->op->main.AsMatMul()->transposeA;
        auto transB = command->op->main.AsMatMul()->transposeB;
        int e = command->size[0];
        int l = command->size[1];
        int h = command->size[2];

        if (backwardMap.find(CIndex) == backwardMap.end()) {
            return;
        }
        std::map<int, int> originIndexMap;
        for (int i=0; i<command->indexes.size(); ++i) {
            auto index = command->indexes[i];
            originIndexMap.insert(std::make_pair(index, i));
            auto bkIter = backwardMap.find(index);
            if (bkIter != backwardMap.end()) {
                originIndexMap.insert(std::make_pair(bkIter->second, i));
            }
        }
        auto CDiffIndex = backwardMap.find(CIndex)->second;
        if (backwardMap.find(AIndex) != backwardMap.end()) {
            auto ADiffIndex = backwardMap.find(AIndex)->second;
            // Compute A Diff
            std::unique_ptr<RegionCommandT> currentCommand(new RegionCommandT);
            currentCommand->op.reset(new OpT);
            currentCommand->op->type = OpType_MatMul;
            currentCommand->op->main.value = new MatMulT;
            currentCommand->op->main.type = OpParameter_MatMul;
            currentCommand->indexes = {ADiffIndex, CDiffIndex, BIndex};
            currentCommand->view.resize(3);
            for (int j=0; j<currentCommand->view.size(); ++j) {
                currentCommand->view[j].reset(new ViewT);
            }
            currentCommand->iterIndexes.resize(3);
            currentCommand->steps.resize(3);
            for (int j=0; j<currentCommand->indexes.size(); ++j) {
                // Compute output info
                auto index = currentCommand->indexes[j];
                currentCommand->iterIndexes[j] = command->iterIndexes[originIndexMap[index]];
                currentCommand->steps[j] = command->steps[originIndexMap[index]];
                *currentCommand->view[j] = *command->view[originIndexMap[index]];
            }
            // TODO: Optimize fuse option
            currentCommand->fuse = BinaryOpOperation_ADD;

            // Reorder the view's stride by size order change to e, h, l
            std::vector<int> order = {0, 2, 1};
            currentCommand->size = {e, h, l};
            for (int j=0; j<currentCommand->indexes.size(); ++j) {
                auto view = currentCommand->view[j].get();
                auto originStride = view->stride;
                for (int k=0; k<3; ++k) {
                    view->stride[k]  = originStride[order[k]];
                }
            }