#include "TestBlocks.hpp"
#include "TestStrategy.hpp"
#include <IMemoryOptimizerStrategy.hpp>
#include <MemoryOptimizerStrategyLibrary.hpp>
#include <strategies/StrategyValidator.hpp>
#include <cxxopts.hpp>
#include <iostream>
#include <algorithm>
#include <iomanip>
Go to the source code of this file.
◆ GetMinPossibleMemorySize()
size_t GetMinPossibleMemorySize |
( |
const std::vector< armnn::MemBlock > & |
blocks | ) |
|
Definition at line 41 of file MemoryStrategyBenchmark.cpp.
Referenced by RunBenchmark().
43 unsigned int maxLifetime = 0;
44 for (
auto& block: blocks)
46 maxLifetime = std::max(maxLifetime, block.m_EndOfLife);
50 std::vector<size_t> lifetimes(maxLifetime);
51 for (
const auto& block : blocks)
53 for (
auto lifetime = block.m_StartOfLife; lifetime <= block.m_EndOfLife; ++lifetime)
55 lifetimes[lifetime] += block.m_MemSize;
58 return *std::max_element(lifetimes.begin(), lifetimes.end());
◆ main()
int main |
( |
int |
argc, |
|
|
char * |
argv[] |
|
) |
| |
Definition at line 160 of file MemoryStrategyBenchmark.cpp.
References armnn::GetMemoryOptimizerStrategy(), ParseOptions(), RunBenchmark(), StrategyValidator::SetStrategy(), and testBlocks.
162 BenchmarkOptions benchmarkOptions =
ParseOptions(argc, argv);
164 std::shared_ptr<armnn::IMemoryOptimizerStrategy> strategy;
166 if (benchmarkOptions.m_UseDefaultStrategy)
168 strategy = std::make_shared<armnn::TestStrategy>();
176 std::cout <<
"Strategy name not found\n";
181 std::vector<TestBlock> model;
182 std::vector<TestBlock>* modelsToTest = &
testBlocks;
183 if (benchmarkOptions.m_ModelName.size() != 0)
187 return testBlock.m_Name == benchmarkOptions.m_ModelName;
192 std::cout <<
"Model name not found\n";
197 model.push_back(*it);
198 modelsToTest = &model;
202 if (benchmarkOptions.m_Validate)
std::vector< TestBlock > testBlocks
void SetStrategy(std::shared_ptr< IMemoryOptimizerStrategy > strategy)
void RunBenchmark(armnn::IMemoryOptimizerStrategy *strategy, std::vector< TestBlock > *models)
std::unique_ptr< IMemoryOptimizerStrategy > GetMemoryOptimizerStrategy(const std::string &strategyName)
BenchmarkOptions ParseOptions(int argc, char *argv[])
◆ ParseOptions()
BenchmarkOptions ParseOptions |
( |
int |
argc, |
|
|
char * |
argv[] |
|
) |
| |
Definition at line 112 of file MemoryStrategyBenchmark.cpp.
References armnn::GetMemoryOptimizerStrategyNames(), and PrintModels().
Referenced by main().
114 cxxopts::Options options(
"Memory Benchmark",
"Tests memory optimization strategies on different models");
116 options.add_options()
117 (
"s, strategy",
"Strategy name, do not specify to use default strategy", cxxopts::value<std::string>())
118 (
"m, model",
"Model name", cxxopts::value<std::string>())
119 (
"v, validate",
"Validate strategy", cxxopts::value<bool>()->default_value(
"false")->implicit_value(
"true"))
120 (
"h,help",
"Display usage information");
122 auto result = options.parse(argc, argv);
123 if (result.count(
"help"))
125 std::cout << options.help() << std::endl;
128 std::cout <<
"\nAvailable strategies:\n";
132 std::cout << s <<
"\n";
137 BenchmarkOptions benchmarkOptions;
139 if(result.count(
"strategy"))
141 benchmarkOptions.m_StrategyName = result[
"strategy"].as<std::string>();
145 std::cout <<
"No Strategy given, using default strategy";
147 benchmarkOptions.m_UseDefaultStrategy =
true;
150 if(result.count(
"model"))
152 benchmarkOptions.m_ModelName = result[
"model"].as<std::string>();
155 benchmarkOptions.m_Validate = result[
"validate"].as<
bool>();
157 return benchmarkOptions;
const std::vector< std::string > GetMemoryOptimizerStrategyNames()
◆ PrintModels()
◆ RunBenchmark()
Definition at line 61 of file MemoryStrategyBenchmark.cpp.
References GetMinPossibleMemorySize(), IMemoryOptimizerStrategy::GetName(), and IMemoryOptimizerStrategy::Optimize().
Referenced by main().
63 using Clock = std::chrono::high_resolution_clock;
64 float avgEfficiency = 0;
65 std::chrono::duration<double, std::milli> avgDuration{};
66 std::cout <<
"\nMemory Strategy: " << strategy->
GetName()<<
"\n";
67 std::cout <<
"===============================================\n";
68 for (
auto& model : *models)
70 auto now = Clock::now();
71 const std::vector<armnn::MemBin> result = strategy->
Optimize(model.m_Blocks);
72 auto duration = std::chrono::duration<double, std::milli>(Clock::now() - now);
74 avgDuration += duration;
75 size_t memoryUsage = 0;
76 for (
auto bin : result)
78 memoryUsage += bin.m_MemSize;
82 float efficiency =
static_cast<float>(minSize) / static_cast<float>(memoryUsage);
84 avgEfficiency += efficiency;
85 std::cout <<
"\nModel: " << model.m_Name <<
"\n";
87 std::cout <<
"Strategy execution time: " << std::setprecision(4) << duration.count() <<
" milliseconds\n";
89 std::cout <<
"Memory usage: " << memoryUsage/1024 <<
" kb\n";
91 std::cout <<
"Minimum possible usage: " << minSize/1024 <<
" kb\n";
93 std::cout <<
"Memory efficiency: " << std::setprecision(3) << efficiency <<
"%\n";
96 avgDuration/=
static_cast<double>(models->size());
97 avgEfficiency/=
static_cast<float>(models->size());
99 std::cout <<
"\n===============================================\n";
100 std::cout <<
"Average memory duration: " << std::setprecision(4) << avgDuration.count() <<
" milliseconds\n";
101 std::cout <<
"Average memory efficiency: " << std::setprecision(3) << avgEfficiency <<
"%\n";
virtual std::vector< MemBin > Optimize(std::vector< MemBlock > &memBlocks)=0
virtual std::string GetName() const =0
size_t GetMinPossibleMemorySize(const std::vector< armnn::MemBlock > &blocks)
◆ testBlocks
Initial value:{
}
std::vector< armnn::MemBlock > fsrcnn
std::vector< armnn::MemBlock > deeplabv3
std::vector< armnn::MemBlock > ssd_mobilenetv2
std::vector< armnn::MemBlock > inceptionv4
std::vector< armnn::MemBlock > deepspeechv1
std::vector< armnn::MemBlock > mobilebert
std::vector< armnn::MemBlock > resnetv2
Definition at line 20 of file MemoryStrategyBenchmark.cpp.
Referenced by main(), and PrintModels().