1 /* 2 * Copyright (C) 2019 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #ifndef ANDROID_FRAMEWORKS_ML_NN_RUNTIME_TEST_FUZZING_OPERATION_MANAGER_H 18 #define ANDROID_FRAMEWORKS_ML_NN_RUNTIME_TEST_FUZZING_OPERATION_MANAGER_H 19 20 #include <functional> 21 #include <map> 22 #include <string> 23 #include <vector> 24 25 #include "TestHarness.h" 26 #include "TestNeuralNetworksWrapper.h" 27 #include "fuzzing/RandomGraphGenerator.h" 28 #include "fuzzing/RandomVariable.h" 29 30 namespace android { 31 namespace nn { 32 namespace fuzzing_test { 33 34 struct OperandSignature { 35 // Possible values are [INPUT | CONST | OUTPUT]. 36 // If CONST, the generator will avoid feeding the operand with another operation’s output. 37 RandomOperandType type; 38 39 // The operand constructor is invoked before the operation constructor. This is for 40 // setting the data type, quantization parameters, or optionally the scalar value. 41 std::function<void(test_helper::TestOperandType, uint32_t, RandomOperand*)> constructor = 42 nullptr; 43 44 // The operand finalizer is invoked after the graph structure is frozen but before the operation 45 // finalizer. This is for generating the buffer values for the operand. 46 std::function<void(RandomOperand*)> finalizer = nullptr; 47 }; 48 49 // A filter applied to OperationSignatures. An OperationSignature is filtered out if the opType, all 50 // of supportedDataTypes, all of supportedRanks, or the version does not match with any entry in the 51 // corresponding vector in the filter. Use empty vector in the filter for "no filter". 52 // 53 // E.g. 54 // - To get all 1.0 ADD operation signatures 55 // {.opcodes = {TestOperationType::ADD}, .versions = {TestHalVersion::V1_0}} 56 // 57 // - To get all 1.0 and 1.1 operations with rank 2 or 4 58 // {.ranks = {2, 4}, .versions = {TestHalVersion::V1_0, TestHalVersion::V1_1}} 59 // 60 struct OperationFilter { 61 std::vector<test_helper::TestOperationType> opcodes; 62 std::vector<test_helper::TestOperandType> dataTypes; 63 std::vector<uint32_t> ranks; 64 std::vector<test_helper::TestHalVersion> versions; 65 }; 66 67 struct OperationSignature { 68 // Defines the basic metadata of an operation filterable by OperationFilter. 69 // Upon generation, the random graph generator will randomly choose a supported data type and 70 // rank, and pass the information to the constructors. 71 test_helper::TestOperationType opType; 72 std::vector<test_helper::TestOperandType> supportedDataTypes; 73 std::vector<uint32_t> supportedRanks; 74 test_helper::TestHalVersion version; 75 76 // OperandSignatures for inputs and outputs. 77 std::vector<OperandSignature> inputs; 78 std::vector<OperandSignature> outputs; 79 80 // The operation constructor is invoked after the inputs and outputs constructor. This is for 81 // setting the dimension relationship of random operands, and/or generating parameter values at 82 // the operation level, e.g. a parameter depends on or affects another operand in the same 83 // operation. 84 std::function<void(test_helper::TestOperandType, uint32_t, RandomOperation*)> constructor = 85 nullptr; 86 87 // The operation finalizer is invoked after the graph structure is frozen and inputs and outputs 88 // constructors are invoked. This is for generating operand buffers at the operation level, e.g. 89 // an operand buffer that depends on another operand in the same operation. 90 std::function<void(RandomOperation*)> finalizer = nullptr; 91 92 // Check if the OperationSignature matches with the filter. Shrink supported* if needed. 93 bool matchFilter(const OperationFilter& filter); 94 }; 95 96 // A manager manages all available OperationSignatures. 97 class OperationManager { 98 public: 99 // Returns the singleton manager. 100 static OperationManager* get(); 101 102 // Add the signature to the managed mOperationSignatures if matches with mFilter. 103 void addSignature(const std::string& name, const OperationSignature& signature); 104 105 // Reinitialize mFilteredSignatures by applying a filter to all of the operation signatures in 106 // mOperationSignatures. 107 void applyFilter(const OperationFilter& filter); 108 109 // Randomly returns a valid OperationSignature. RandomGraphGenerator uses this method to 110 // generate a random list of operations in the graph. 111 const OperationSignature& getRandomOperation() const; 112 113 protected: 114 OperationManager() = default; 115 116 // Contains all operation signatures defined in operation_signatures/*.cpp. 117 // The signatures are sorted by name to ensure a predictable order. 118 std::map<std::string, const OperationSignature> mOperationSignatures; 119 120 // A subset of mOperationSignatures using by the random graph generator. 121 // This vector should be initialized by applyFilter() before generating the graph. 122 std::vector<OperationSignature> mFilteredSignatures; 123 }; 124 125 } // namespace fuzzing_test 126 } // namespace nn 127 } // namespace android 128 129 #endif // ANDROID_FRAMEWORKS_ML_NN_RUNTIME_TEST_FUZZING_OPERATION_MANAGER_H 130