void OutputHelper::PrintResults()

in Tools/WinMLRunner/src/OutputHelper.cpp [159:413]


void OutputHelper::PrintResults(const Profiler<WINML_MODEL_TEST_PERF>& profiler, uint32_t numIterations, DeviceType deviceType,
                    InputBindingType inputBindingType, InputDataType inputDataType,
                    DeviceCreationLocation deviceCreationLocation, bool isPerformanceConsoleOutputVerbose) const
{
    double loadTime = profiler[LOAD_MODEL].GetAverage(CounterType::TIMER);
    double createSessionTime = profiler[CREATE_SESSION].GetAverage(CounterType::TIMER);

    double averageBindTime = profiler[BIND_VALUE].GetAverage(CounterType::TIMER);
    double stdevBindTime = profiler[BIND_VALUE].GetStdev(CounterType::TIMER);
    double minBindTime = profiler[BIND_VALUE].GetMin(CounterType::TIMER);
    double maxBindTime = profiler[BIND_VALUE].GetMax(CounterType::TIMER);
    double firstBindTime = profiler[BIND_VALUE_FIRST_RUN].GetAverage(CounterType::TIMER);

    double averageEvalTime = profiler[EVAL_MODEL].GetAverage(CounterType::TIMER);
    double stdevEvalTime = profiler[EVAL_MODEL].GetStdev(CounterType::TIMER);
    double minEvalTime = profiler[EVAL_MODEL].GetMin(CounterType::TIMER);
    double maxEvalTime = profiler[EVAL_MODEL].GetMax(CounterType::TIMER);
    double firstEvalTime = profiler[EVAL_MODEL_FIRST_RUN].GetAverage(CounterType::TIMER);

    double firstLoadWorkingSetMemoryUsage = profiler[LOAD_MODEL].GetAverage(CounterType::WORKING_SET_USAGE);
    double firstLoadSharedMemoryUsage = profiler[LOAD_MODEL].GetAverage(CounterType::GPU_SHARED_MEM_USAGE);
    double firstLoadDedicatedMemoryUsage = profiler[LOAD_MODEL].GetAverage(CounterType::GPU_DEDICATED_MEM_USAGE);
    double firstLoadPeakWorkingSetUsage = profiler[LOAD_MODEL].GetAverage(CounterType::PEAK_WORKING_SET_USAGE);

    double firstSessionCreationWorkingSetMemoryUsage =
        profiler[CREATE_SESSION].GetAverage(CounterType::WORKING_SET_USAGE);
    double firstSessionCreationSharedMemoryUsage =
        profiler[CREATE_SESSION].GetAverage(CounterType::GPU_SHARED_MEM_USAGE);
    double firstSessionCreationDedicatedMemoryUsage =
        profiler[CREATE_SESSION].GetAverage(CounterType::GPU_DEDICATED_MEM_USAGE);
    double firstSessionPeakWorkingSetUsage =
        profiler[CREATE_SESSION].GetAverage(CounterType::PEAK_WORKING_SET_USAGE);

    double averageBindMemoryUsage = profiler[BIND_VALUE].GetAverage(CounterType::WORKING_SET_USAGE);
    double stdevBindMemoryUsage = profiler[BIND_VALUE].GetStdev(CounterType::WORKING_SET_USAGE);
    double minBindMemoryUsage = profiler[BIND_VALUE].GetMin(CounterType::WORKING_SET_USAGE);
    double maxBindMemoryUsage = profiler[BIND_VALUE].GetMax(CounterType::WORKING_SET_USAGE);
    double firstBindMemoryUsage = profiler[BIND_VALUE_FIRST_RUN].GetAverage(CounterType::WORKING_SET_USAGE);
    double firstBindPeakMemoryUsage =
        profiler[BIND_VALUE_FIRST_RUN].GetAverage(CounterType::PEAK_WORKING_SET_USAGE);

    double averageEvalMemoryUsage = profiler[EVAL_MODEL].GetAverage(CounterType::WORKING_SET_USAGE);
    double stdevEvalMemoryUsage = profiler[EVAL_MODEL].GetStdev(CounterType::WORKING_SET_USAGE);
    double minEvalMemoryUsage = profiler[EVAL_MODEL].GetMin(CounterType::WORKING_SET_USAGE);
    double maxEvalMemoryUsage = profiler[EVAL_MODEL].GetMax(CounterType::WORKING_SET_USAGE);
    double firstEvalMemoryUsage = profiler[EVAL_MODEL_FIRST_RUN].GetAverage(CounterType::WORKING_SET_USAGE);
    double firstEvalPeakMemoryUsage =
        profiler[EVAL_MODEL_FIRST_RUN].GetAverage(CounterType::PEAK_WORKING_SET_USAGE);

    double averageBindDedicatedMemoryUsage = profiler[BIND_VALUE].GetAverage(CounterType::GPU_DEDICATED_MEM_USAGE);
    double stdevBindDedicatedMemoryUsage = profiler[BIND_VALUE].GetStdev(CounterType::GPU_DEDICATED_MEM_USAGE);
    double minBindDedicatedMemoryUsage = profiler[BIND_VALUE].GetMin(CounterType::GPU_DEDICATED_MEM_USAGE);
    double maxBindDedicatedMemoryUsage = profiler[BIND_VALUE].GetMax(CounterType::GPU_DEDICATED_MEM_USAGE);
    double firstBindDedicatedMemoryUsage =
        profiler[BIND_VALUE_FIRST_RUN].GetAverage(CounterType::GPU_DEDICATED_MEM_USAGE);

    double averageEvalDedicatedMemoryUsage = profiler[EVAL_MODEL].GetAverage(CounterType::GPU_DEDICATED_MEM_USAGE);
    double stdevEvalDedicatedMemoryUsage = profiler[EVAL_MODEL].GetStdev(CounterType::GPU_DEDICATED_MEM_USAGE);
    double minEvalDedicatedMemoryUsage = profiler[EVAL_MODEL].GetMin(CounterType::GPU_DEDICATED_MEM_USAGE);
    double maxEvalDedicatedMemoryUsage = profiler[EVAL_MODEL].GetMax(CounterType::GPU_DEDICATED_MEM_USAGE);
    double firstEvalDedicatedMemoryUsage =
        profiler[EVAL_MODEL_FIRST_RUN].GetAverage(CounterType::GPU_DEDICATED_MEM_USAGE);

    double averageBindSharedMemoryUsage = profiler[BIND_VALUE].GetAverage(CounterType::GPU_SHARED_MEM_USAGE);
    double stdevBindSharedMemoryUsage = profiler[BIND_VALUE].GetStdev(CounterType::GPU_SHARED_MEM_USAGE);
    double minBindSharedMemoryUsage = profiler[BIND_VALUE].GetMin(CounterType::GPU_SHARED_MEM_USAGE);
    double maxBindSharedMemoryUsage = profiler[BIND_VALUE].GetMax(CounterType::GPU_SHARED_MEM_USAGE);
    double firstBindSharedMemoryUsage =
        profiler[BIND_VALUE_FIRST_RUN].GetAverage(CounterType::GPU_SHARED_MEM_USAGE);

    double averageEvalSharedMemoryUsage = profiler[EVAL_MODEL].GetAverage(CounterType::GPU_SHARED_MEM_USAGE);
    double stdevEvalSharedMemoryUsage = profiler[EVAL_MODEL].GetStdev(CounterType::GPU_SHARED_MEM_USAGE);
    double minEvalSharedMemoryUsage = profiler[EVAL_MODEL].GetMin(CounterType::GPU_SHARED_MEM_USAGE);
    double maxEvalSharedMemoryUsage = profiler[EVAL_MODEL].GetMax(CounterType::GPU_SHARED_MEM_USAGE);
    double firstEvalSharedMemoryUsage =
        profiler[EVAL_MODEL_FIRST_RUN].GetAverage(CounterType::GPU_SHARED_MEM_USAGE);

    double firstIterationWorkingSetMemoryUsage =
        profiler[LOAD_MODEL].GetAverage(CounterType::WORKING_SET_USAGE) +
        profiler[CREATE_SESSION].GetAverage(CounterType::WORKING_SET_USAGE) +
        profiler[BIND_VALUE_FIRST_RUN].GetAverage(CounterType::WORKING_SET_USAGE) +
        profiler[EVAL_MODEL_FIRST_RUN].GetAverage(CounterType::WORKING_SET_USAGE);

    double firstIterationSharedMemoryUsage =
        profiler[LOAD_MODEL].GetAverage(CounterType::GPU_SHARED_MEM_USAGE) +
        profiler[CREATE_SESSION].GetAverage(CounterType::GPU_SHARED_MEM_USAGE) +
        profiler[BIND_VALUE_FIRST_RUN].GetAverage(CounterType::GPU_SHARED_MEM_USAGE) +
        profiler[EVAL_MODEL_FIRST_RUN].GetAverage(CounterType::GPU_SHARED_MEM_USAGE);

    double firstIterationDedicatedMemoryUsage =
        profiler[LOAD_MODEL].GetAverage(CounterType::GPU_DEDICATED_MEM_USAGE) +
        profiler[CREATE_SESSION].GetAverage(CounterType::GPU_DEDICATED_MEM_USAGE) +
        profiler[BIND_VALUE_FIRST_RUN].GetAverage(CounterType::GPU_DEDICATED_MEM_USAGE) +
        profiler[EVAL_MODEL_FIRST_RUN].GetAverage(CounterType::GPU_DEDICATED_MEM_USAGE);

    double firstIterationPeakWorkingSet = firstLoadPeakWorkingSetUsage + firstSessionPeakWorkingSetUsage +
                                            firstBindPeakMemoryUsage + firstEvalPeakMemoryUsage;

    printf("\nResults (device = %s, numIterations = %d, inputBinding = %s, inputDataType = %s, "
            "deviceCreationLocation = %s):\n",
            TypeHelper::Stringify(deviceType).c_str(), numIterations,
            TypeHelper::Stringify(inputBindingType).c_str(), TypeHelper::Stringify(inputDataType).c_str(),
            TypeHelper::Stringify(deviceCreationLocation).c_str());

    std::cout << "\nFirst Iteration Performance (load, bind, session creation, and evaluate): " << std::endl;
    std::cout << "  Load: " << loadTime << " ms" << std::endl;
    std::cout << "  Bind: " << firstBindTime << " ms" << std::endl;
    std::cout << "  Session Creation: " << createSessionTime << " ms" << std::endl;
    std::cout << "  Evaluate: " << firstEvalTime << " ms" << std::endl;

    if (isPerformanceConsoleOutputVerbose)
    {
        std::cout << "\n  Working Set Memory usage (load): " << firstLoadWorkingSetMemoryUsage << " MB"
                    << std::endl;
        std::cout << "  Working Set Memory usage (session creation): " << firstSessionCreationWorkingSetMemoryUsage
                    << " MB" << std::endl;
        std::cout << "  Working Set Memory usage (bind): " << firstBindMemoryUsage << " MB" << std::endl;
    }
    else
    {
        std::cout << std::endl;
    }
    std::cout << "  Working Set Memory usage (evaluate): " << firstEvalMemoryUsage << " MB" << std::endl;
    std::cout << "  Working Set Memory usage (load, bind, session creation, and evaluate): "
                << firstIterationWorkingSetMemoryUsage << " MB" << std::endl;

    if (isPerformanceConsoleOutputVerbose)
    {
        std::cout << std::endl;
        std::cout << "  Peak Working Set Memory Difference (from start to load): " << firstLoadPeakWorkingSetUsage
                    << " MB" << std::endl;
        std::cout << "  Peak Working Set Memory Difference (from model load to session creation): "
                    << firstSessionPeakWorkingSetUsage << " MB" << std::endl;
        std::cout << "  Peak Working Set Memory Difference (from session to bind): " << firstBindPeakMemoryUsage
                    << " MB" << std::endl;
        std::cout << "  Peak Working Set Memory Difference (from bind to evaluate): " << firstEvalPeakMemoryUsage
                    << " MB" << std::endl;
    }

    std::cout << "  Peak Working Set Memory Difference (load, bind, session creation, and evaluate): "
                << firstIterationPeakWorkingSet << " MB" << std::endl;

    if (isPerformanceConsoleOutputVerbose)
    {
        std::cout << "\n  Dedicated Memory usage (load): " << firstLoadDedicatedMemoryUsage << " MB" << std::endl;
        std::cout << "  Dedicated Memory usage (session creation): " << firstSessionCreationDedicatedMemoryUsage
                    << " MB" << std::endl;
        std::cout << "  Dedicated Memory usage (bind): " << firstBindDedicatedMemoryUsage << " MB" << std::endl;
    }
    else
    {
        std::cout << std::endl;
    }
    std::cout << "  Dedicated Memory usage (evaluate): " << firstEvalDedicatedMemoryUsage << " MB" << std::endl;
    std::cout << "  Dedicated Memory usage (load, bind, session creation, and evaluate): "
                << firstIterationDedicatedMemoryUsage << " MB" << std::endl;

    if (isPerformanceConsoleOutputVerbose)
    {
        std::cout << "\n  Shared Memory usage (load): " << firstLoadSharedMemoryUsage << " MB" << std::endl;
        std::cout << "  Shared Memory usage (session creation): " << firstSessionCreationSharedMemoryUsage << " MB"
                    << std::endl;
        std::cout << "  Shared Memory usage (bind): " << firstBindSharedMemoryUsage << " MB" << std::endl;
    }
    else
    {
        std::cout << std::endl;
    }
    std::cout << "  Shared Memory usage (evaluate): " << firstEvalSharedMemoryUsage << " MB" << std::endl;
    std::cout << "  Shared Memory usage (load, bind, session creation, and evaluate): "
                << firstIterationSharedMemoryUsage << " MB" << std::endl;

    if (numIterations > 1)
    {
        printf("\nAverage Performance excluding first iteration. Iterations %d to %d. (Iterations greater than 1 "
                "only bind and evaluate)\n",
                2, numIterations);
        std::cout << "  Average Bind: " << averageBindTime << " ms" << std::endl;
        if (isPerformanceConsoleOutputVerbose)
        {
            std::cout << "  Minimum Bind: " << minBindTime << " ms" << std::endl;
            std::cout << "  Maximum Bind: " << maxBindTime << " ms" << std::endl;
            std::cout << "  Standard Deviation Bind: " << stdevBindTime << " ms" << std::endl;
        }
        std::cout << "  Average Evaluate: " << averageEvalTime << " ms" << std::endl;
        if (isPerformanceConsoleOutputVerbose)
        {
            std::cout << "  Minimum Evaluate: " << minEvalTime << " ms" << std::endl;
            std::cout << "  Maximum Evaluate: " << maxEvalTime << " ms" << std::endl;
            std::cout << "  Standard Deviation Evaluate: " << stdevEvalTime << " ms" << std::endl;
        }

        std::cout << "\n  Average Working Set Memory usage (bind): " << averageBindMemoryUsage << " MB"
                    << std::endl;
        if (isPerformanceConsoleOutputVerbose)
        {
            std::cout << "  Min Working Set Memory usage (bind): " << minBindMemoryUsage << " MB" << std::endl;
            std::cout << "  Max Working Set Memory usage (bind): " << maxBindMemoryUsage << " MB" << std::endl;
            std::cout << "  Standard Deviation Working Set Memory usage (bind): " << stdevBindMemoryUsage << " MB"
                        << std::endl;
        }
        std::cout << "  Average Working Set Memory usage (evaluate): " << averageEvalMemoryUsage << " MB"
                    << std::endl;
        if (isPerformanceConsoleOutputVerbose)
        {
            std::cout << "  Min Working Set Memory usage (evaluate): " << minEvalMemoryUsage << " MB" << std::endl;
            std::cout << "  Max Working Set Memory usage (evaluate): " << maxEvalMemoryUsage << " MB" << std::endl;
            std::cout << "  Standard Deviation Working Set Memory usage (evaluate): " << stdevEvalMemoryUsage
                        << " MB" << std::endl;
        }

        std::cout << "\n  Average Dedicated Memory usage (bind): " << averageBindDedicatedMemoryUsage << " MB"
                    << std::endl;
        if (isPerformanceConsoleOutputVerbose)
        {
            std::cout << "  Min Dedicated Memory usage (bind): " << minBindDedicatedMemoryUsage << " MB"
                        << std::endl;
            std::cout << "  Max Dedicated Memory usage (bind): " << maxBindDedicatedMemoryUsage << " MB"
                        << std::endl;
            std::cout << "  Standard Deviation Working Set Memory usage (evaluate): "
                        << stdevBindDedicatedMemoryUsage << " MB" << std::endl;
        }
        std::cout << "  Average Dedicated Memory usage (evaluate): " << averageEvalDedicatedMemoryUsage << " MB"
                    << std::endl;
        if (isPerformanceConsoleOutputVerbose)
        {
            std::cout << "  Min Dedicated Memory usage (evaluate): " << minEvalDedicatedMemoryUsage << " MB"
                        << std::endl;
            std::cout << "  Max Dedicated Memory usage (evaluate): " << maxEvalDedicatedMemoryUsage << " MB"
                        << std::endl;
            std::cout << "  Standard Deviation Dedicated Memory usage (evaluate): " << stdevEvalDedicatedMemoryUsage
                        << " MB" << std::endl;
        }

        std::cout << "\n  Average Shared Memory usage (bind): " << averageBindSharedMemoryUsage << " MB"
                    << std::endl;
        if (isPerformanceConsoleOutputVerbose)
        {
            std::cout << "  Min Shared Memory usage (bind): " << minBindSharedMemoryUsage << " MB" << std::endl;
            std::cout << "  Max Shared Memory usage (bind): " << maxBindSharedMemoryUsage << " MB" << std::endl;
            std::cout << "  Standard Deviation Shared Memory usage (bind): " << stdevBindSharedMemoryUsage << " MB"
                        << std::endl;
        }
        std::cout << "  Average Shared Memory usage (evaluate): " << averageEvalSharedMemoryUsage << " MB"
                    << std::endl;
        if (isPerformanceConsoleOutputVerbose)
        {
            std::cout << "  Min Shared Memory usage (evaluate): " << minEvalSharedMemoryUsage << " MB" << std::endl;
            std::cout << "  Max Shared Memory usage (evaluate): " << maxEvalSharedMemoryUsage << " MB" << std::endl;
            std::cout << "  Standard Deviation Shared Memory usage (evaluate): " << stdevEvalSharedMemoryUsage
                        << " MB" << std::endl;
        }
    }
    std::cout << std::endl << std::endl << std::endl;
}