ArmNN
 25.11
Loading...
Searching...
No Matches
SerializerStrategy Class Reference

#include <Serializer.hpp>

Inheritance diagram for SerializerStrategy:
[legend]
Collaboration diagram for SerializerStrategy:
[legend]

Public Member Functions

void ExecuteStrategy (const armnn::IConnectableLayer *layer, const armnn::BaseDescriptor &descriptor, const std::vector< armnn::ConstTensor > &constants, const char *name, const armnn::LayerBindingId id) override
 SerializerStrategy ()
 ~SerializerStrategy ()
flatbuffers::FlatBufferBuilder & GetFlatBufferBuilder ()
std::vector< int > & GetInputIds ()
std::vector< int > & GetOutputIds ()
std::vector< flatbuffers::Offset< armnnSerializer::AnyLayer > > & GetSerializedLayers ()
flatbuffers::Offset< armnnSerializer::FeatureCompatibilityVersions > GetVersionTable ()
Public Member Functions inherited from IStrategy
virtual void ExecuteStrategy (const IConnectableLayer *layer, const armnn::BaseDescriptor &descriptor, const std::vector< armnn::ConstTensor > &constants, const char *name, const armnn::LayerBindingId id=0)=0
virtual void FinishStrategy ()

Additional Inherited Members

Protected Member Functions inherited from IStrategy
 IStrategy ()
virtual ~IStrategy ()

Detailed Description

Definition at line 22 of file Serializer.hpp.

Constructor & Destructor Documentation

◆ SerializerStrategy()

SerializerStrategy ( )
inline

Definition at line 31 of file Serializer.hpp.

31: m_layerId(0) {}

◆ ~SerializerStrategy()

~SerializerStrategy ( )
inline

Definition at line 32 of file Serializer.hpp.

32{}

Member Function Documentation

◆ ExecuteStrategy()

void ExecuteStrategy ( const armnn::IConnectableLayer * layer,
const armnn::BaseDescriptor & descriptor,
const std::vector< armnn::ConstTensor > & constants,
const char * name,
const armnn::LayerBindingId id )
override

Definition at line 2074 of file Serializer.cpp.

2079{
2080 IgnoreUnused(constants);
2081
2082 switch (layer->GetType())
2083 {
2084 case armnn::LayerType::Activation :
2085 {
2086 const armnn::ActivationDescriptor& layerDescriptor =
2087 static_cast<const armnn::ActivationDescriptor&>(descriptor);
2088 SerializeActivationLayer(layer, layerDescriptor, name);
2089 break;
2090 }
2091 case armnn::LayerType::Addition :
2092 {
2093 SerializeAdditionLayer(layer, name);
2094 break;
2095 }
2096 case armnn::LayerType::ArgMinMax :
2097 {
2098 const armnn::ArgMinMaxDescriptor& layerDescriptor =
2099 static_cast<const armnn::ArgMinMaxDescriptor&>(descriptor);
2100 SerializeArgMinMaxLayer(layer, layerDescriptor, name);
2101 break;
2102 }
2103 case armnn::LayerType::BatchMatMul:
2104 {
2105 const armnn::BatchMatMulDescriptor& layerDescriptor =
2106 static_cast<const armnn::BatchMatMulDescriptor&>(descriptor);
2107 SerializeBatchMatMulLayer(layer,
2108 layerDescriptor,
2109 name);
2110 break;
2111 }
2112 case armnn::LayerType::BatchNormalization :
2113 {
2114 const armnn::BatchNormalizationDescriptor& layerDescriptor =
2115 static_cast<const armnn::BatchNormalizationDescriptor&>(descriptor);
2116 SerializeBatchNormalizationLayer(layer,
2117 layerDescriptor,
2118 constants,
2119 name);
2120 break;
2121 }
2122 case armnn::LayerType::BatchToSpaceNd :
2123 {
2124 const armnn::BatchToSpaceNdDescriptor& layerDescriptor =
2125 static_cast<const armnn::BatchToSpaceNdDescriptor&>(descriptor);
2126 SerializeBatchToSpaceNdLayer(layer,
2127 layerDescriptor,
2128 name);
2129 break;
2130 }
2131 case armnn::LayerType::Cast :
2132 {
2133 SerializeCastLayer(layer, name);
2134 break;
2135 }
2136 case armnn::LayerType::ChannelShuffle :
2137 {
2138 const armnn::ChannelShuffleDescriptor& layerDescriptor =
2139 static_cast<const armnn::ChannelShuffleDescriptor&>(descriptor);
2140 SerializeChannelShuffleLayer(layer,
2141 layerDescriptor,
2142 name);
2143 break;
2144 }
2145 case armnn::LayerType::Comparison :
2146 {
2147 const armnn::ComparisonDescriptor& layerDescriptor =
2148 static_cast<const armnn::ComparisonDescriptor&>(descriptor);
2149 SerializeComparisonLayer(layer,
2150 layerDescriptor,
2151 name);
2152 break;
2153 }
2154 case armnn::LayerType::Concat :
2155 {
2156 const armnn::ConcatDescriptor& layerDescriptor =
2157 static_cast<const armnn::ConcatDescriptor&>(descriptor);
2158 SerializeConcatLayer(layer,
2159 layerDescriptor,
2160 name);
2161 break;
2162 }
2163 case armnn::LayerType::Constant :
2164 {
2165 SerializeConstantLayer(layer,
2166 constants,
2167 name);
2168 break;
2169 }
2170 case armnn::LayerType::Convolution2d :
2171 {
2172 const armnn::Convolution2dDescriptor& layerDescriptor =
2173 static_cast<const armnn::Convolution2dDescriptor&>(descriptor);
2174 SerializeConvolution2dLayer(layer,
2175 layerDescriptor,
2176 name);
2177 break;
2178 }
2179 case armnn::LayerType::Convolution3d :
2180 {
2181 const armnn::Convolution3dDescriptor& layerDescriptor =
2182 static_cast<const armnn::Convolution3dDescriptor&>(descriptor);
2183 SerializeConvolution3dLayer(layer,
2184 layerDescriptor,
2185 name);
2186 break;
2187 }
2188 case armnn::LayerType::DepthToSpace :
2189 {
2190 const armnn::DepthToSpaceDescriptor& layerDescriptor =
2191 static_cast<const armnn::DepthToSpaceDescriptor&>(descriptor);
2192 SerializeDepthToSpaceLayer(layer,
2193 layerDescriptor,
2194 name);
2195 break;
2196 }
2197 case armnn::LayerType::DepthwiseConvolution2d :
2198 {
2199 const armnn::DepthwiseConvolution2dDescriptor& layerDescriptor =
2200 static_cast<const armnn::DepthwiseConvolution2dDescriptor&>(descriptor);
2201 SerializeDepthwiseConvolution2dLayer(layer,
2202 layerDescriptor,
2203 name);
2204 break;
2205 }
2206 case armnn::LayerType::Dequantize :
2207 {
2208 SerializeDequantizeLayer(layer,
2209 name);
2210 break;
2211 }
2212 case armnn::LayerType::DetectionPostProcess :
2213 {
2214 const armnn::DetectionPostProcessDescriptor& layerDescriptor =
2215 static_cast<const armnn::DetectionPostProcessDescriptor&>(descriptor);
2216 SerializeDetectionPostProcessLayer(layer, layerDescriptor, constants, name);
2217 break;
2218 }
2219 case armnn::LayerType::Division :
2220 {
2221 SerializeDivisionLayer(layer, name);
2222 break;
2223 }
2224 case armnn::LayerType::ElementwiseBinary :
2225 {
2226 const armnn::ElementwiseBinaryDescriptor& layerDescriptor =
2227 static_cast<const armnn::ElementwiseBinaryDescriptor&>(descriptor);
2228 SerializeElementwiseBinaryLayer(layer, layerDescriptor, name);
2229 break;
2230 }
2231 case armnn::LayerType::ElementwiseUnary :
2232 {
2233 const armnn::ElementwiseUnaryDescriptor& layerDescriptor =
2234 static_cast<const armnn::ElementwiseUnaryDescriptor&>(descriptor);
2235 SerializeElementwiseUnaryLayer(layer, layerDescriptor, name);
2236 break;
2237 }
2238 case armnn::LayerType::Fill :
2239 {
2240 const armnn::FillDescriptor& layerDescriptor =
2241 static_cast<const armnn::FillDescriptor&>(descriptor);
2242 SerializeFillLayer(layer, layerDescriptor, name);
2243 break;
2244 }
2245 case armnn::LayerType::Floor :
2246 {
2247 SerializeFloorLayer(layer, name);
2248 break;
2249 }
2250 case armnn::LayerType::FullyConnected :
2251 {
2252 const armnn::FullyConnectedDescriptor& layerDescriptor =
2253 static_cast<const armnn::FullyConnectedDescriptor&>(descriptor);
2254 SerializeFullyConnectedLayer(layer, layerDescriptor, name);
2255 break;
2256 }
2257 case armnn::LayerType::Gather :
2258 {
2259 const armnn::GatherDescriptor& layerDescriptor =
2260 static_cast<const armnn::GatherDescriptor&>(descriptor);
2261 SerializeGatherLayer(layer, layerDescriptor, name);
2262 break;
2263 }
2264 case armnn::LayerType::GatherNd :
2265 {
2266 SerializeGatherNdLayer(layer, name);
2267 break;
2268 }
2269 case armnn::LayerType::Input:
2270 {
2271 SerializeInputLayer(layer, id, name);
2272 break;
2273 }
2274 case armnn::LayerType::InstanceNormalization :
2275 {
2276 const armnn::InstanceNormalizationDescriptor& layerDescriptor =
2277 static_cast<const armnn::InstanceNormalizationDescriptor&>(descriptor);
2278 SerializeInstanceNormalizationLayer(layer, layerDescriptor, name);
2279 break;
2280 }
2281 case armnn::LayerType::L2Normalization :
2282 {
2283 const armnn::L2NormalizationDescriptor& layerDescriptor =
2284 static_cast<const armnn::L2NormalizationDescriptor&>(descriptor);
2285 SerializeL2NormalizationLayer(layer, layerDescriptor, name);
2286 break;
2287 }
2288 case armnn::LayerType::LogicalBinary :
2289 {
2290 const armnn::LogicalBinaryDescriptor& layerDescriptor =
2291 static_cast<const armnn::LogicalBinaryDescriptor&>(descriptor);
2292 SerializeLogicalBinaryLayer(layer, layerDescriptor, name);
2293 break;
2294 }
2295 case armnn::LayerType::LogSoftmax :
2296 {
2297 const armnn::LogSoftmaxDescriptor& layerDescriptor =
2298 static_cast<const armnn::LogSoftmaxDescriptor&>(descriptor);
2299 SerializeLogSoftmaxLayer(layer, layerDescriptor, name);
2300 break;
2301 }
2302 case armnn::LayerType::Lstm :
2303 {
2304 const armnn::LstmDescriptor& layerDescriptor =
2305 static_cast<const armnn::LstmDescriptor&>(descriptor);
2306 SerializeLstmLayer(layer, layerDescriptor, constants, name);
2307 break;
2308 }
2309 case armnn::LayerType::QLstm :
2310 {
2311 const armnn::QLstmDescriptor& layerDescriptor =
2312 static_cast<const armnn::QLstmDescriptor&>(descriptor);
2313 SerializeQLstmLayer(layer, layerDescriptor, constants, name);
2314 break;
2315 }
2316 case armnn::LayerType::Maximum :
2317 {
2318 SerializeMaximumLayer(layer, name);
2319 break;
2320 }
2321 case armnn::LayerType::Mean :
2322 {
2323 const armnn::MeanDescriptor& layerDescriptor =
2324 static_cast<const armnn::MeanDescriptor&>(descriptor);
2325 SerializeMeanLayer(layer, layerDescriptor, name);
2326 break;
2327 }
2328 case armnn::LayerType::Merge :
2329 {
2330 SerializeMergeLayer(layer, name);
2331 break;
2332 }
2333 case armnn::LayerType::Minimum :
2334 {
2335 SerializeMinimumLayer(layer, name);
2336 break;
2337 }
2338 case armnn::LayerType::Multiplication :
2339 {
2340 SerializeMultiplicationLayer(layer, name);
2341 break;
2342 }
2343 case armnn::LayerType::Normalization :
2344 {
2345 const armnn::NormalizationDescriptor& layerDescriptor =
2346 static_cast<const armnn::NormalizationDescriptor&>(descriptor);
2347 SerializeNormalizationLayer(layer, layerDescriptor, name);
2348 break;
2349 }
2350 case armnn::LayerType::Output:
2351 {
2352 SerializeOutputLayer(layer, id, name);
2353 break;
2354 }
2355 case armnn::LayerType::Pad :
2356 {
2357 const armnn::PadDescriptor& layerDescriptor =
2358 static_cast<const armnn::PadDescriptor&>(descriptor);
2359 SerializePadLayer(layer, layerDescriptor, name);
2360 break;
2361 }
2362 case armnn::LayerType::Permute :
2363 {
2364 const armnn::PermuteDescriptor& layerDescriptor =
2365 static_cast<const armnn::PermuteDescriptor&>(descriptor);
2366 SerializePermuteLayer(layer, layerDescriptor, name);
2367 break;
2368 }
2369 case armnn::LayerType::Pooling2d :
2370 {
2371 const armnn::Pooling2dDescriptor& layerDescriptor =
2372 static_cast<const armnn::Pooling2dDescriptor&>(descriptor);
2373 SerializePooling2dLayer(layer, layerDescriptor, name);
2374 break;
2375 }
2376 case armnn::LayerType::Pooling3d :
2377 {
2378 const armnn::Pooling3dDescriptor& layerDescriptor =
2379 static_cast<const armnn::Pooling3dDescriptor&>(descriptor);
2380 SerializePooling3dLayer(layer, layerDescriptor, name);
2381 break;
2382 }
2383 case armnn::LayerType::Prelu :
2384 {
2385 SerializePreluLayer(layer, name);
2386 break;
2387 }
2388 case armnn::LayerType::Quantize :
2389 {
2390 SerializeQuantizeLayer(layer, name);
2391 break;
2392 }
2393 case armnn::LayerType::QuantizedLstm:
2394 SerializeQuantizedLstmLayer(layer, constants, name);
2395 break;
2396 case armnn::LayerType::Reshape:
2397 {
2398 const armnn::ReshapeDescriptor &layerDescriptor =
2399 static_cast<const armnn::ReshapeDescriptor &>(descriptor);
2400 SerializeReshapeLayer(layer, layerDescriptor, name);
2401 break;
2402 }
2403 case armnn::LayerType::Rank:
2404 {
2405 SerializeRankLayer(layer, name);
2406 break;
2407 }
2408 case armnn::LayerType::Reduce:
2409 {
2410 const armnn::ReduceDescriptor& layerDescriptor =
2411 static_cast<const armnn::ReduceDescriptor&>(descriptor);
2412 SerializeReduceLayer(layer, layerDescriptor, name);
2413 break;
2414 }
2415 case armnn::LayerType::Resize:
2416 {
2417 const armnn::ResizeDescriptor& layerDescriptor =
2418 static_cast<const armnn::ResizeDescriptor&>(descriptor);
2419 SerializeResizeLayer(layer, layerDescriptor, name);
2420 break;
2421 }
2422 case armnn::LayerType::ReverseV2:
2423 {
2424 SerializeReverseV2Layer(layer, name);
2425 break;
2426 }
2427 case armnn::LayerType::ScatterNd:
2428 {
2429 const armnn::ScatterNdDescriptor& layerDescriptor =
2430 static_cast<const armnn::ScatterNdDescriptor&>(descriptor);
2431 SerializeScatterNdLayer(layer, layerDescriptor, name);
2432 break;
2433 }
2434 case armnn::LayerType::Shape:
2435 {
2436 SerializeShapeLayer(layer, name);
2437 break;
2438 }
2439 case armnn::LayerType::Slice:
2440 {
2441 const armnn::SliceDescriptor& layerDescriptor =
2442 static_cast<const armnn::SliceDescriptor&>(descriptor);
2443 SerializeSliceLayer(layer, layerDescriptor, name);
2444 break;
2445 }
2446 case armnn::LayerType::Softmax:
2447 {
2448 const armnn::SoftmaxDescriptor& layerDescriptor =
2449 static_cast<const armnn::SoftmaxDescriptor&>(descriptor);
2450 SerializeSoftmaxLayer(layer, layerDescriptor, name);
2451 break;
2452 }
2453 case armnn::LayerType::SpaceToBatchNd:
2454 {
2455 const armnn::SpaceToBatchNdDescriptor& layerDescriptor =
2456 static_cast<const armnn::SpaceToBatchNdDescriptor&>(descriptor);
2457 SerializeSpaceToBatchNdLayer(layer, layerDescriptor, name);
2458 break;
2459 }
2460 case armnn::LayerType::SpaceToDepth:
2461 {
2462 const armnn::SpaceToDepthDescriptor& layerDescriptor =
2463 static_cast<const armnn::SpaceToDepthDescriptor&>(descriptor);
2464 SerializeSpaceToDepthLayer(layer, layerDescriptor, name);
2465 break;
2466 }
2467 case armnn::LayerType::Splitter:
2468 {
2469 const armnn::SplitterDescriptor& layerDescriptor =
2470 static_cast<const armnn::SplitterDescriptor&>(descriptor);
2471 SerializeSplitterLayer(layer, layerDescriptor, name);
2472 break;
2473 }
2474 case armnn::LayerType::Stack:
2475 {
2476 const armnn::StackDescriptor& layerDescriptor =
2477 static_cast<const armnn::StackDescriptor&>(descriptor);
2478 SerializeStackLayer(layer, layerDescriptor, name);
2479 break;
2480 }
2481 case armnn::LayerType::StandIn:
2482 {
2483 const armnn::StandInDescriptor& layerDescriptor =
2484 static_cast<const armnn::StandInDescriptor&>(descriptor);
2485 SerializeStandInLayer(layer, layerDescriptor, name);
2486 break;
2487 }
2488 case armnn::LayerType::StridedSlice:
2489 {
2490 const armnn::StridedSliceDescriptor& layerDescriptor =
2491 static_cast<const armnn::StridedSliceDescriptor&>(descriptor);
2492 SerializeStridedSliceLayer(layer, layerDescriptor, name);
2493 break;
2494 }
2495 case armnn::LayerType::Subtraction:
2496 {
2497 SerializeSubtractionLayer(layer, name);
2498 break;
2499 }
2500 case armnn::LayerType::Switch:
2501 {
2502 SerializeSwitchLayer(layer, name);
2503 break;
2504 }
2505 case armnn::LayerType::Tile:
2506 {
2507 const armnn::TileDescriptor& layerDescriptor =
2508 static_cast<const armnn::TileDescriptor&>(descriptor);
2509 SerializeTileLayer(layer, layerDescriptor, name);
2510 break;
2511 }
2512 case armnn::LayerType::Transpose:
2513 {
2514 const armnn::TransposeDescriptor& layerDescriptor =
2515 static_cast<const armnn::TransposeDescriptor&>(descriptor);
2516 SerializeTransposeLayer(layer, layerDescriptor, name);
2517 break;
2518 }
2519 case armnn::LayerType::TransposeConvolution2d:
2520 {
2521 const armnn::TransposeConvolution2dDescriptor& layerDescriptor =
2522 static_cast<const armnn::TransposeConvolution2dDescriptor&>(descriptor);
2523 SerializeTransposeConvolution2dLayer(layer, layerDescriptor, constants, name);
2524 break;
2525 }
2526 case armnn::LayerType::UnidirectionalSequenceLstm :
2527 {
2528 const armnn::UnidirectionalSequenceLstmDescriptor& layerDescriptor =
2529 static_cast<const armnn::UnidirectionalSequenceLstmDescriptor&>(descriptor);
2530 SerializeUnidirectionalSequenceLstmLayer(layer, layerDescriptor, constants, name);
2531 break;
2532 }
2533 default:
2534 {
2535 throw InvalidArgumentException(
2536 fmt::format("A layer of unknown type was given to the serializer. Layer name: {}; Layer Id: {}",
2537 layer->GetName(),
2538 id));
2539 }
2540 }
2541}
armnn::IConnectableLayer::GetType
virtual LayerType GetType() const =0
Returns the armnn::LayerType of this layer.
armnn::IConnectableLayer::GetName
virtual const char * GetName() const =0
Returns the name of the layer.
armnn::LayerType::UnidirectionalSequenceLstm
@ UnidirectionalSequenceLstm
Definition Types.hpp:496
armnn::SplitterDescriptor
ViewsDescriptor SplitterDescriptor
Definition DescriptorsFwd.hpp:65
armnn::DepthToSpaceDescriptor
SpaceToDepthDescriptor DepthToSpaceDescriptor
A DepthToSpaceDescriptor for the DepthToSpaceLayer.
Definition Descriptors.hpp:1099
armnn::ConcatDescriptor
OriginsDescriptor ConcatDescriptor
Definition DescriptorsFwd.hpp:60
armnn::LogSoftmaxDescriptor
SoftmaxDescriptor LogSoftmaxDescriptor
A LogSoftmaxDescriptor for the LogSoftmaxLayer.
Definition Descriptors.hpp:196
armnn::UnidirectionalSequenceLstmDescriptor
LstmDescriptor UnidirectionalSequenceLstmDescriptor
Definition Descriptors.hpp:1169
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition IgnoreUnused.hpp:14

References armnn::Activation, armnn::Addition, armnn::ArgMinMax, armnn::BatchMatMul, armnn::BatchNormalization, armnn::BatchToSpaceNd, armnn::Cast, armnn::ChannelShuffle, armnn::Comparison, armnn::Concat, armnn::Constant, armnn::Convolution2d, armnn::Convolution3d, armnn::DepthToSpace, armnn::DepthwiseConvolution2d, armnn::Dequantize, armnn::DetectionPostProcess, armnn::Division, armnn::ElementwiseBinary, armnn::ElementwiseUnary, ExecuteStrategy(), armnn::Fill, armnn::Floor, armnn::FullyConnected, armnn::Gather, armnn::GatherNd, IConnectableLayer::GetName(), IConnectableLayer::GetType(), armnn::IgnoreUnused(), armnn::Input, armnn::InstanceNormalization, armnn::L2Normalization, armnn::LogicalBinary, armnn::LogSoftmax, armnn::Lstm, armnn::Maximum, armnn::Mean, armnn::Merge, armnn::Minimum, armnn::Multiplication, armnn::Normalization, armnn::Output, armnn::Pad, armnn::Permute, armnn::Pooling2d, armnn::Pooling3d, armnn::Prelu, armnn::QLstm, armnn::Quantize, armnn::QuantizedLstm, armnn::Rank, armnn::Reduce, armnn::Reshape, armnn::Resize, armnn::ReverseV2, armnn::ScatterNd, armnn::Shape, armnn::Slice, armnn::Softmax, armnn::SpaceToBatchNd, armnn::SpaceToDepth, armnn::Splitter, armnn::Stack, armnn::StandIn, armnn::StridedSlice, armnn::Subtraction, armnn::Switch, armnn::Tile, armnn::Transpose, armnn::TransposeConvolution2d, and armnn::UnidirectionalSequenceLstm.

Referenced by ExecuteStrategy().

◆ GetFlatBufferBuilder()

flatbuffers::FlatBufferBuilder & GetFlatBufferBuilder ( )
inline

Definition at line 34 of file Serializer.hpp.

35 {
36 return m_flatBufferBuilder;
37 }

◆ GetInputIds()

std::vector< int > & GetInputIds ( )
inline

Definition at line 39 of file Serializer.hpp.

40 {
41 return m_inputIds;
42 }

◆ GetOutputIds()

std::vector< int > & GetOutputIds ( )
inline

Definition at line 44 of file Serializer.hpp.

45 {
46 return m_outputIds;
47 }

◆ GetSerializedLayers()

std::vector< flatbuffers::Offset< armnnSerializer::AnyLayer > > & GetSerializedLayers ( )
inline

Definition at line 49 of file Serializer.hpp.

50 {
51 return m_serializedLayers;
52 }

◆ GetVersionTable()

flatbuffers::Offset< armnnSerializer::FeatureCompatibilityVersions > GetVersionTable ( )

Definition at line 2017 of file Serializer.cpp.

2018{
2019 flatbuffers::Offset<armnnSerializer::FeatureCompatibilityVersions> versionsTable =
2020 serializer::CreateFeatureCompatibilityVersions(
2021 m_flatBufferBuilder,
2022 1, // Binding ids scheme version
2023 1, // Weights layout scheme version
2024 1 // Constant tensors as inputs version
2025 );
2026 return versionsTable;
2027}

References GetVersionTable().

Referenced by GetVersionTable().

The documentation for this class was generated from the following files: