13 #include <cxxopts.hpp> 33 std::cout <<
"Available models:\n";
36 std::cout << model.m_Name <<
"\n";
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());
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";
104 struct BenchmarkOptions
106 std::string m_StrategyName;
107 std::string m_ModelName;
108 bool m_UseDefaultStrategy =
false;
109 bool m_Validate =
false;
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;
160 int main(
int argc,
char* argv[])
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< armnn::MemBlock > fsrcnn
std::vector< armnn::MemBlock > deeplabv3
std::vector< TestBlock > testBlocks
std::vector< armnn::MemBlock > ssd_mobilenetv2
void SetStrategy(std::shared_ptr< IMemoryOptimizerStrategy > strategy)
std::vector< armnn::MemBlock > inceptionv4
void RunBenchmark(armnn::IMemoryOptimizerStrategy *strategy, std::vector< TestBlock > *models)
std::unique_ptr< IMemoryOptimizerStrategy > GetMemoryOptimizerStrategy(const std::string &strategyName)
std::vector< armnn::MemBlock > deepspeechv1
BenchmarkOptions ParseOptions(int argc, char *argv[])
int main(int argc, char *argv[])
std::vector< armnn::MemBlock > mobilebert
std::vector< armnn::MemBlock > resnetv2
const std::vector< std::string > GetMemoryOptimizerStrategyNames()
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)