MLECO-4072: Minor bug fix23.08-rc1

* Adding call to the new ops resolver in inference runner usecase
* Change variable names to match code style

Signed-off-by: Richard Burton<richard.burton@arm.com>
Change-Id: I0537cc18296294ac9d778434c257ad4f4e479310

2 files changed, 102 insertions, 101 deletions

diff --git a/source/application/api/use_case/inference_runner/include/MicroMutableAllOpsResolver.hpp b/source/application/api/use_case/inference_runner/include/MicroMutableAllOpsResolver.hpp
index df55a83..96ac28d 100644
--- a/source/application/api/use_case/inference_runner/include/MicroMutableAllOpsResolver.hpp
+++ b/source/application/api/use_case/inference_runner/include/MicroMutableAllOpsResolver.hpp
@@ -24,108 +24,109 @@ constexpr int kNumberOperators = 97;
 namespace arm {
 namespace app {
 
-    inline tflite::MicroMutableOpResolver<kNumberOperators> get_resolver() {
-        tflite::MicroMutableOpResolver<kNumberOperators> micro_op_resolver;
+    /* Create our own AllOpsResolver by adding all Ops to MicroMutableOpResolver. */
+    inline tflite::MicroMutableOpResolver<kNumberOperators> CreateAllOpsResolver() {
+        tflite::MicroMutableOpResolver<kNumberOperators> mutableAllOpResolver;
 
-        micro_op_resolver.AddAbs();
-        micro_op_resolver.AddAdd();
-        micro_op_resolver.AddAddN();
-        micro_op_resolver.AddArgMax();
-        micro_op_resolver.AddArgMin();
-        micro_op_resolver.AddAssignVariable();
-        micro_op_resolver.AddAveragePool2D();
-        micro_op_resolver.AddBatchToSpaceNd();
-        micro_op_resolver.AddBroadcastArgs();
-        micro_op_resolver.AddBroadcastTo();
-        micro_op_resolver.AddCallOnce();
-        micro_op_resolver.AddCast();
-        micro_op_resolver.AddCeil();
-        micro_op_resolver.AddCircularBuffer();
-        micro_op_resolver.AddConcatenation();
-        micro_op_resolver.AddConv2D();
-        micro_op_resolver.AddCos();
-        micro_op_resolver.AddCumSum();
-        micro_op_resolver.AddDepthToSpace();
-        micro_op_resolver.AddDepthwiseConv2D();
-        micro_op_resolver.AddDequantize();
-        micro_op_resolver.AddDetectionPostprocess();
-        micro_op_resolver.AddDiv();
-        micro_op_resolver.AddElu();
-        micro_op_resolver.AddEqual();
-        micro_op_resolver.AddEthosU();
-        micro_op_resolver.AddExp();
-        micro_op_resolver.AddExpandDims();
-        micro_op_resolver.AddFill();
-        micro_op_resolver.AddFloor();
-        micro_op_resolver.AddFloorDiv();
-        micro_op_resolver.AddFloorMod();
-        micro_op_resolver.AddFullyConnected();
-        micro_op_resolver.AddGather();
-        micro_op_resolver.AddGatherNd();
-        micro_op_resolver.AddGreater();
-        micro_op_resolver.AddGreaterEqual();
-        micro_op_resolver.AddHardSwish();
-        micro_op_resolver.AddIf();
-        micro_op_resolver.AddL2Normalization();
-        micro_op_resolver.AddL2Pool2D();
-        micro_op_resolver.AddLeakyRelu();
-        micro_op_resolver.AddLess();
-        micro_op_resolver.AddLessEqual();
-        micro_op_resolver.AddLog();
-        micro_op_resolver.AddLogicalAnd();
-        micro_op_resolver.AddLogicalNot();
-        micro_op_resolver.AddLogicalOr();
-        micro_op_resolver.AddLogistic();
-        micro_op_resolver.AddLogSoftmax();
-        micro_op_resolver.AddMaxPool2D();
-        micro_op_resolver.AddMaximum();
-        micro_op_resolver.AddMean();
-        micro_op_resolver.AddMinimum();
-        micro_op_resolver.AddMirrorPad();
-        micro_op_resolver.AddMul();
-        micro_op_resolver.AddNeg();
-        micro_op_resolver.AddNotEqual();
-        micro_op_resolver.AddPack();
-        micro_op_resolver.AddPad();
-        micro_op_resolver.AddPadV2();
-        micro_op_resolver.AddPrelu();
-        micro_op_resolver.AddQuantize();
-        micro_op_resolver.AddReadVariable();
-        micro_op_resolver.AddReduceMax();
-        micro_op_resolver.AddRelu();
-        micro_op_resolver.AddRelu6();
-        micro_op_resolver.AddReshape();
-        micro_op_resolver.AddResizeBilinear();
-        micro_op_resolver.AddResizeNearestNeighbor();
-        micro_op_resolver.AddRound();
-        micro_op_resolver.AddRsqrt();
-        micro_op_resolver.AddSelectV2();
-        micro_op_resolver.AddShape();
-        micro_op_resolver.AddSin();
-        micro_op_resolver.AddSlice();
-        micro_op_resolver.AddSoftmax();
-        micro_op_resolver.AddSpaceToBatchNd();
-        micro_op_resolver.AddSpaceToDepth();
-        micro_op_resolver.AddSplit();
-        micro_op_resolver.AddSplitV();
-        micro_op_resolver.AddSqrt();
-        micro_op_resolver.AddSquare();
-        micro_op_resolver.AddSquaredDifference();
-        micro_op_resolver.AddSqueeze();
-        micro_op_resolver.AddStridedSlice();
-        micro_op_resolver.AddSub();
-        micro_op_resolver.AddSum();
-        micro_op_resolver.AddSvdf();
-        micro_op_resolver.AddTanh();
-        micro_op_resolver.AddTranspose();
-        micro_op_resolver.AddTransposeConv();
-        micro_op_resolver.AddUnidirectionalSequenceLSTM();
-        micro_op_resolver.AddUnpack();
-        micro_op_resolver.AddVarHandle();
-        micro_op_resolver.AddWhile();
-        micro_op_resolver.AddZerosLike();
+        mutableAllOpResolver.AddAbs();
+        mutableAllOpResolver.AddAdd();
+        mutableAllOpResolver.AddAddN();
+        mutableAllOpResolver.AddArgMax();
+        mutableAllOpResolver.AddArgMin();
+        mutableAllOpResolver.AddAssignVariable();
+        mutableAllOpResolver.AddAveragePool2D();
+        mutableAllOpResolver.AddBatchToSpaceNd();
+        mutableAllOpResolver.AddBroadcastArgs();
+        mutableAllOpResolver.AddBroadcastTo();
+        mutableAllOpResolver.AddCallOnce();
+        mutableAllOpResolver.AddCast();
+        mutableAllOpResolver.AddCeil();
+        mutableAllOpResolver.AddCircularBuffer();
+        mutableAllOpResolver.AddConcatenation();
+        mutableAllOpResolver.AddConv2D();
+        mutableAllOpResolver.AddCos();
+        mutableAllOpResolver.AddCumSum();
+        mutableAllOpResolver.AddDepthToSpace();
+        mutableAllOpResolver.AddDepthwiseConv2D();
+        mutableAllOpResolver.AddDequantize();
+        mutableAllOpResolver.AddDetectionPostprocess();
+        mutableAllOpResolver.AddDiv();
+        mutableAllOpResolver.AddElu();
+        mutableAllOpResolver.AddEqual();
+        mutableAllOpResolver.AddEthosU();
+        mutableAllOpResolver.AddExp();
+        mutableAllOpResolver.AddExpandDims();
+        mutableAllOpResolver.AddFill();
+        mutableAllOpResolver.AddFloor();
+        mutableAllOpResolver.AddFloorDiv();
+        mutableAllOpResolver.AddFloorMod();
+        mutableAllOpResolver.AddFullyConnected();
+        mutableAllOpResolver.AddGather();
+        mutableAllOpResolver.AddGatherNd();
+        mutableAllOpResolver.AddGreater();
+        mutableAllOpResolver.AddGreaterEqual();
+        mutableAllOpResolver.AddHardSwish();
+        mutableAllOpResolver.AddIf();
+        mutableAllOpResolver.AddL2Normalization();
+        mutableAllOpResolver.AddL2Pool2D();
+        mutableAllOpResolver.AddLeakyRelu();
+        mutableAllOpResolver.AddLess();
+        mutableAllOpResolver.AddLessEqual();
+        mutableAllOpResolver.AddLog();
+        mutableAllOpResolver.AddLogicalAnd();
+        mutableAllOpResolver.AddLogicalNot();
+        mutableAllOpResolver.AddLogicalOr();
+        mutableAllOpResolver.AddLogistic();
+        mutableAllOpResolver.AddLogSoftmax();
+        mutableAllOpResolver.AddMaxPool2D();
+        mutableAllOpResolver.AddMaximum();
+        mutableAllOpResolver.AddMean();
+        mutableAllOpResolver.AddMinimum();
+        mutableAllOpResolver.AddMirrorPad();
+        mutableAllOpResolver.AddMul();
+        mutableAllOpResolver.AddNeg();
+        mutableAllOpResolver.AddNotEqual();
+        mutableAllOpResolver.AddPack();
+        mutableAllOpResolver.AddPad();
+        mutableAllOpResolver.AddPadV2();
+        mutableAllOpResolver.AddPrelu();
+        mutableAllOpResolver.AddQuantize();
+        mutableAllOpResolver.AddReadVariable();
+        mutableAllOpResolver.AddReduceMax();
+        mutableAllOpResolver.AddRelu();
+        mutableAllOpResolver.AddRelu6();
+        mutableAllOpResolver.AddReshape();
+        mutableAllOpResolver.AddResizeBilinear();
+        mutableAllOpResolver.AddResizeNearestNeighbor();
+        mutableAllOpResolver.AddRound();
+        mutableAllOpResolver.AddRsqrt();
+        mutableAllOpResolver.AddSelectV2();
+        mutableAllOpResolver.AddShape();
+        mutableAllOpResolver.AddSin();
+        mutableAllOpResolver.AddSlice();
+        mutableAllOpResolver.AddSoftmax();
+        mutableAllOpResolver.AddSpaceToBatchNd();
+        mutableAllOpResolver.AddSpaceToDepth();
+        mutableAllOpResolver.AddSplit();
+        mutableAllOpResolver.AddSplitV();
+        mutableAllOpResolver.AddSqrt();
+        mutableAllOpResolver.AddSquare();
+        mutableAllOpResolver.AddSquaredDifference();
+        mutableAllOpResolver.AddSqueeze();
+        mutableAllOpResolver.AddStridedSlice();
+        mutableAllOpResolver.AddSub();
+        mutableAllOpResolver.AddSum();
+        mutableAllOpResolver.AddSvdf();
+        mutableAllOpResolver.AddTanh();
+        mutableAllOpResolver.AddTranspose();
+        mutableAllOpResolver.AddTransposeConv();
+        mutableAllOpResolver.AddUnidirectionalSequenceLSTM();
+        mutableAllOpResolver.AddUnpack();
+        mutableAllOpResolver.AddVarHandle();
+        mutableAllOpResolver.AddWhile();
+        mutableAllOpResolver.AddZerosLike();
 
-        return micro_op_resolver;
+        return mutableAllOpResolver;
     }
 
 } /* namespace app */
diff --git a/source/application/api/use_case/inference_runner/include/TestModel.hpp b/source/application/api/use_case/inference_runner/include/TestModel.hpp
index bc6a0fb..455e244 100644
--- a/source/application/api/use_case/inference_runner/include/TestModel.hpp
+++ b/source/application/api/use_case/inference_runner/include/TestModel.hpp
@@ -35,7 +35,7 @@ namespace app {
     private:
 
         /* No need to define individual ops at the cost of extra memory. */
-        tflite::MicroMutableOpResolver<kNumberOperators> m_opResolver;
+        tflite::MicroMutableOpResolver<kNumberOperators> m_opResolver = CreateAllOpsResolver();
     };
 
 } /* namespace app */