int run()

in Tools/WinMLRunner/src/Run.cpp [527:625]
88 lines of code
19 McCabe index (conditional complexity)

int run(CommandLineArgs& args,
        Profiler<WINML_MODEL_TEST_PERF>& profiler,
        const std::vector<LearningModelDeviceWithMetadata>& deviceList,
        const LearningModelSessionOptions& sessionOptions) try
{
    // Initialize COM in a multi-threaded environment.
    winrt::init_apartment();
    OutputHelper output(args.NumIterations());

#if defined(_AMD64_)
    PrintIfPIXToolAttached(output);
#endif

    // Profiler is a wrapper class that captures and stores timing and memory usage data on the
    // CPU and GPU.
    profiler.Enable();

    output.SetCSVFileName(args.OutputPath());
    if (args.IsSaveTensor() || args.IsPerIterationCapture())
    {
        output.SetDefaultPerIterationFolder(args.PerIterationDataPath());
        output.SetDefaultCSVFileNamePerIteration();
    }

    if (!args.ModelPath().empty() || !args.FolderPath().empty())
    {
        std::vector<InputBindingType> inputBindingTypes = args.FetchInputBindingTypes();
        std::vector<InputDataType> inputDataTypes = args.FetchInputDataTypes();
        std::vector<std::wstring> modelPaths = args.ModelPath().empty()
                                                   ? GetModelsInDirectory(args, &output)
                                                   : std::vector<std::wstring>(1, args.ModelPath());
        HRESULT lastHr = S_OK;
        if (args.IsConcurrentLoad())
        {
            ConcurrentLoadModel(modelPaths, args.NumThreads(), args.ThreadInterval(), true);
            return 0;
        }
        for (const auto& path : modelPaths)
        {
            LearningModel model = nullptr;

            LoadModel(model, path, args.IsPerformanceCapture() || args.IsPerIterationCapture(), output, args, 0,
                      profiler);
            for (auto& learningModelDevice : deviceList)
            {
                lastHr = CheckIfModelAndConfigurationsAreSupported(model, path, learningModelDevice.DeviceType, inputDataTypes);
                if (FAILED(lastHr))
                {
                    continue;
                }
#if defined(_AMD64_)
                StartPIXCapture(output);
#endif
                LearningModelSession session = nullptr;
                for (auto inputDataType : inputDataTypes)
                {
                    for (auto inputBindingType : inputBindingTypes)
                    {
                        // Clear up session, bind, eval performance metrics after configuration iteration
                        if (args.IsPerformanceCapture() || args.IsPerIterationCapture())
                        {
                            // Resets all values from profiler for bind and evaluate.
                            profiler.Reset(WINML_MODEL_TEST_PERF::BIND_VALUE, WINML_MODEL_TEST_PERF::COUNT);
                        }
                        for (uint32_t sessionCreationIteration = 0;
                            sessionCreationIteration < args.NumSessionCreationIterations();
                            sessionCreationIteration++)
                        {
                            lastHr = CreateSession(session, model, learningModelDevice,args, output, profiler, sessionOptions);
                            if (FAILED(lastHr))
                            {
                                continue;
                            }
                            if (args.IsImageInput())
                            {
                                for (const std::wstring& inputImagePath : args.ImagePaths())
                                {
                                    RunConfiguration(args, output, session, lastHr, inputBindingType, inputDataType,
                                                     profiler, path, inputImagePath, sessionCreationIteration,
                                                     learningModelDevice);
                                }
                            }
                            else
                            {
                                RunConfiguration(args, output, session, lastHr, inputBindingType, inputDataType,
                                                 profiler, path, L"", sessionCreationIteration,
                                                 learningModelDevice);
                            }
                            // Close and destroy session
                            session.Close();
                        }
                    }
                }
            }
        }
        return lastHr;
    }
    return 0;
}