1 // Copyright (C) 2020 The Android Open Source Project 2 // 3 // Licensed under the Apache License, Version 2.0 (the "License"); 4 // you may not use this file except in compliance with the License. 5 // You may obtain a copy of the License at 6 // 7 // http://www.apache.org/licenses/LICENSE-2.0 8 // 9 // Unless required by applicable law or agreed to in writing, software 10 // distributed under the License is distributed on an "AS IS" BASIS, 11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 // See the License for the specific language governing permissions and 13 // limitations under the License. 14 15 #ifndef COMPUTEPIPE_RUNNER_GRAPH_GRPC_GRAPH_H 16 #define COMPUTEPIPE_RUNNER_GRAPH_GRPC_GRAPH_H 17 18 #include <functional> 19 #include <shared_mutex> 20 #include <string> 21 22 #include "ClientConfig.pb.h" 23 #include "InputFrame.h" 24 #include "Options.pb.h" 25 #include "PrebuiltEngineInterface.h" 26 #include "PrebuiltGraph.h" 27 #include "RunnerComponent.h" 28 #include "types/Status.h" 29 30 namespace android { 31 namespace automotive { 32 namespace computepipe { 33 namespace graph { 34 35 class LocalPrebuiltGraph : public PrebuiltGraph { 36 37 private: 38 // Private constructor LocalPrebuiltGraph()39 LocalPrebuiltGraph() { 40 } 41 42 public: 43 ~LocalPrebuiltGraph(); 44 45 // No copy or move constructors or operators are available. 46 LocalPrebuiltGraph(const LocalPrebuiltGraph&) = delete; 47 LocalPrebuiltGraph& operator=(const LocalPrebuiltGraph&) = delete; 48 49 // Override RunnerComponent interface functions for applying configs, 50 // starting the graph and stopping the graph. 51 Status handleConfigPhase(const runner::ClientConfig& e) override; 52 Status handleExecutionPhase(const runner::RunnerEvent& e) override; 53 Status handleStopWithFlushPhase(const runner::RunnerEvent& e) override; 54 Status handleStopImmediatePhase(const runner::RunnerEvent& e) override; 55 Status handleResetPhase(const runner::RunnerEvent& e) override; 56 57 static LocalPrebuiltGraph* GetPrebuiltGraphFromLibrary( 58 const std::string& prebuiltLib, std::weak_ptr<PrebuiltEngineInterface> engineInterface); 59 GetGraphType()60 PrebuiltGraphType GetGraphType() const override { 61 return PrebuiltGraphType::LOCAL; 62 } 63 GetGraphState()64 PrebuiltGraphState GetGraphState() const override { 65 return mGraphState; 66 } 67 68 Status GetStatus() const override; 69 70 std::string GetErrorMessage() const override; 71 72 // Gets the supported graph config options. GetSupportedGraphConfigs()73 const proto::Options& GetSupportedGraphConfigs() const override { 74 return mGraphConfig; 75 } 76 77 // Sets input stream data. The string is expected to be a serialized proto 78 // the definition of which is known to the graph. 79 Status SetInputStreamData(int streamIndex, int64_t timestamp, 80 const std::string& streamData) override; 81 82 // Sets pixel data to the specified input stream index. 83 Status SetInputStreamPixelData(int streamIndex, int64_t timestamp, 84 const runner::InputFrame& inputFrame) override; 85 86 Status StartGraphProfiling() override; 87 88 Status StopGraphProfiling() override; 89 90 // Collects debugging and profiling information for the graph. The graph 91 // needs to be started with debugging enabled in order to get valid info. 92 std::string GetDebugInfo() override; 93 94 private: 95 // Starts the graph execution. 96 Status StartGraphExecution(bool debuggingEnabled); 97 98 // Stops the graph execution. 99 Status StopGraphExecution(bool flushOutputFrames); 100 101 // Callback functions. The class has a C++ function callback interface while it deals with pure 102 // C functions underneath that do not have object context. We need to have these static 103 // functions that need to be passed to the C interface. 104 static void OutputPixelStreamCallbackFunction(void* cookie, int streamIndex, int64_t timestamp, 105 const uint8_t* pixels, int width, int height, 106 int step, int format); 107 static void OutputStreamCallbackFunction(void* cookie, int streamIndex, int64_t timestamp, 108 const unsigned char* data, size_t dataSize); 109 static void GraphTerminationCallbackFunction(void* cookie, 110 const unsigned char* terminationMessage, 111 size_t terminationMessageSize); 112 113 // Cached callback interface that is passed in from the runner. 114 std::weak_ptr<PrebuiltEngineInterface> mEngineInterface; 115 116 static std::mutex mCreationMutex; 117 static LocalPrebuiltGraph* mPrebuiltGraphInstance; 118 119 // Even though mutexes are generally preferred over atomics, the only varialble in this class 120 // that changes after initialization is graph state and that is the only vairable that needs 121 // to be guarded. The prebuilt is internally assumed to be thread safe, so that concurrent 122 // calls into the library will automatically be handled in a thread safe manner by the it. 123 std::atomic<PrebuiltGraphState> mGraphState = PrebuiltGraphState::UNINITIALIZED; 124 125 // Dynamic library handle 126 void* mHandle; 127 128 // Repeated function calls need not be made to get the graph version and the config is this is 129 // constant through the operation of the graph. These values are just cached as strings. 130 std::string mGraphVersion; 131 proto::Options mGraphConfig; 132 133 // Cached functions from the dynamic library. 134 void* mFnGetErrorCode; 135 void* mFnGetErrorMessage; 136 void* mFnUpdateGraphConfig; 137 void* mFnResetGraph; 138 void* mFnSetInputStreamData; 139 void* mFnSetInputStreamPixelData; 140 void* mFnSetOutputStreamCallback; 141 void* mFnSetOutputPixelStreamCallback; 142 void* mFnSetGraphTerminationCallback; 143 void* mFnStartGraphExecution; 144 void* mFnStopGraphExecution; 145 void* mFnStartGraphProfiling; 146 void* mFnStopGraphProfiling; 147 void* mFnGetDebugInfo; 148 }; 149 150 } // namespace graph 151 } // namespace computepipe 152 } // namespace automotive 153 } // namespace android 154 155 #endif // #define COMPUTEPIPE_RUNNER_GRAPH_GRPC_GRAPH_H 156