From 1dc83febfb76d6a770bdf3ba16c4034a970c2320 Mon Sep 17 00:00:00 2001 From: Nikhil Raj Date: Thu, 16 May 2024 09:47:51 +0100 Subject: IVGCVSW-8260 Update Doxgen Docu for 24.05 Signed-off-by: Nikhil Raj Change-Id: If4bc983bf2793a27ded8e26ac2b29523fc1e4711 --- latest/inherit_graph_129.svg | 4798 +++++++++++++++++++++--------------------- 1 file changed, 2438 insertions(+), 2360 deletions(-) (limited to 'latest/inherit_graph_129.svg') diff --git a/latest/inherit_graph_129.svg b/latest/inherit_graph_129.svg index 89c411f820..43de492d12 100644 --- a/latest/inherit_graph_129.svg +++ b/latest/inherit_graph_129.svg @@ -4,17 +4,17 @@ - - + + Graphical Class Hierarchy - + Node0 - -IWorkload + +IWorkload @@ -22,7200 +22,7278 @@ Node1 - -BaseWorkload< QueueDescriptor > + +BaseWorkload< QueueDescriptor > Node0->Node1 - - + + Node28 - -NullWorkload + +NullWorkload Node0->Node28 - - + + Node29 - -BaseWorkload< AbsQueueDescriptor > + +BaseWorkload< AbsQueueDescriptor > Node0->Node29 - - + + Node34 - -BaseWorkload< Activation -QueueDescriptor > + +BaseWorkload< Activation +QueueDescriptor > Node0->Node34 - - + + Node41 - -BaseWorkload< AdditionQueue -Descriptor > + +BaseWorkload< AdditionQueue +Descriptor > Node0->Node41 - - + + Node46 - -BaseWorkload< ArgMinMaxQueue -Descriptor > + +BaseWorkload< ArgMinMaxQueue +Descriptor > Node0->Node46 - - + + Node53 - -BaseWorkload< armnn -::AdditionQueueDescriptor > + +BaseWorkload< armnn +::AdditionQueueDescriptor > Node0->Node53 - - + + Node55 - -BaseWorkload< BatchMatMul -QueueDescriptor > + +BaseWorkload< BatchMatMul +QueueDescriptor > Node0->Node55 - - + + Node62 - -BaseWorkload< BatchNormalization -QueueDescriptor > + +BaseWorkload< BatchNormalization +QueueDescriptor > Node0->Node62 - - + + Node67 - -BaseWorkload< BatchToSpace -NdQueueDescriptor > + +BaseWorkload< BatchToSpace +NdQueueDescriptor > Node0->Node67 - - + + Node74 - -BaseWorkload< BroadcastTo -QueueDescriptor > + +BaseWorkload< BroadcastTo +QueueDescriptor > Node0->Node74 - - + + Node77 - -BaseWorkload< CastQueueDescriptor > + +BaseWorkload< CastQueueDescriptor > Node0->Node77 - - + + Node84 - -BaseWorkload< ChannelShuffle -QueueDescriptor > + +BaseWorkload< ChannelShuffle +QueueDescriptor > Node0->Node84 - - + + Node91 - -BaseWorkload< Comparison -QueueDescriptor > + +BaseWorkload< Comparison +QueueDescriptor > Node0->Node91 - - + + Node98 - -BaseWorkload< ConcatQueue -Descriptor > + +BaseWorkload< ConcatQueue +Descriptor > Node0->Node98 - - + + Node105 - -BaseWorkload< ConstantQueue -Descriptor > + +BaseWorkload< ConstantQueue +Descriptor > Node0->Node105 - - + + Node114 - -BaseWorkload< Convolution2d -QueueDescriptor > + +BaseWorkload< Convolution2d +QueueDescriptor > Node0->Node114 - - + + Node121 - -BaseWorkload< Convolution3d -QueueDescriptor > + +BaseWorkload< Convolution3d +QueueDescriptor > Node0->Node121 - - + + Node128 - -BaseWorkload< DebugQueue -Descriptor > + +BaseWorkload< DebugQueue +Descriptor > Node0->Node128 - - + + Node131 - -BaseWorkload< DepthToSpace -QueueDescriptor > + +BaseWorkload< DepthToSpace +QueueDescriptor > Node0->Node131 - - + + Node138 - -BaseWorkload< DepthwiseConvolution2d -QueueDescriptor > + +BaseWorkload< DepthwiseConvolution2d +QueueDescriptor > Node0->Node138 - - + + Node145 - -BaseWorkload< Dequantize -QueueDescriptor > + +BaseWorkload< Dequantize +QueueDescriptor > Node0->Node145 - - + + Node152 - -BaseWorkload< DetectionPost -ProcessQueueDescriptor > + +BaseWorkload< DetectionPost +ProcessQueueDescriptor > Node0->Node152 - - + + Node157 - -BaseWorkload< DivisionQueue -Descriptor > + +BaseWorkload< DivisionQueue +Descriptor > Node0->Node157 - - + + Node162 - -BaseWorkload< Elementwise -BinaryQueueDescriptor > + +BaseWorkload< Elementwise +BinaryQueueDescriptor > Node0->Node162 - - + + Node169 - -BaseWorkload< Elementwise -UnaryQueueDescriptor > + +BaseWorkload< Elementwise +UnaryQueueDescriptor > Node0->Node169 - - + + Node187 - -BaseWorkload< FillQueueDescriptor > + +BaseWorkload< FillQueueDescriptor > Node0->Node187 - - + + Node194 - -BaseWorkload< FloorQueue -Descriptor > + +BaseWorkload< FloorQueue +Descriptor > Node0->Node194 - - + + Node197 - -BaseWorkload< FullyConnected -QueueDescriptor > + +BaseWorkload< FullyConnected +QueueDescriptor > Node0->Node197 - - + + Node204 - -BaseWorkload< FusedQueue -Descriptor > + +BaseWorkload< FusedQueue +Descriptor > Node0->Node204 - - + + Node207 - -BaseWorkload< GatherNdQueue -Descriptor > + +BaseWorkload< GatherNdQueue +Descriptor > Node0->Node207 - - + + Node214 - -BaseWorkload< GatherQueue -Descriptor > + +BaseWorkload< GatherQueue +Descriptor > Node0->Node214 - - + + Node221 - -BaseWorkload< InstanceNormalization -QueueDescriptor > + +BaseWorkload< InstanceNormalization +QueueDescriptor > Node0->Node221 - - + + Node228 - -BaseWorkload< L2Normalization -QueueDescriptor > + +BaseWorkload< L2Normalization +QueueDescriptor > Node0->Node228 - - + + Node231 - -BaseWorkload< LogicalBinary -QueueDescriptor > + +BaseWorkload< LogicalBinary +QueueDescriptor > Node0->Node231 - - + + Node240 - -BaseWorkload< LogSoftmax -QueueDescriptor > + +BaseWorkload< LogSoftmax +QueueDescriptor > Node0->Node240 - - + + Node247 - -BaseWorkload< LstmQueueDescriptor > + +BaseWorkload< LstmQueueDescriptor > Node0->Node247 - - + + Node250 - -BaseWorkload< MapQueueDescriptor > + +BaseWorkload< MapQueueDescriptor > Node0->Node250 - - + + Node252 - -BaseWorkload< MaximumQueue -Descriptor > + +BaseWorkload< MaximumQueue +Descriptor > Node0->Node252 - - + + Node257 - -BaseWorkload< MeanQueueDescriptor > + +BaseWorkload< MeanQueueDescriptor > Node0->Node257 - - + + Node264 - -BaseWorkload< MemCopyQueue -Descriptor > + +BaseWorkload< MemCopyQueue +Descriptor > Node0->Node264 - - + + Node266 - -BaseWorkload< MemImportQueue -Descriptor > + +BaseWorkload< MemImportQueue +Descriptor > Node0->Node266 - - + + Node268 - -BaseWorkload< MemSyncQueue -Descriptor > + +BaseWorkload< MemSyncQueue +Descriptor > Node0->Node268 - - + + Node270 - -BaseWorkload< MinimumQueue -Descriptor > + +BaseWorkload< MinimumQueue +Descriptor > Node0->Node270 - - + + Node275 - -BaseWorkload< Multiplication -QueueDescriptor > + +BaseWorkload< Multiplication +QueueDescriptor > Node0->Node275 - - + + Node280 - -BaseWorkload< Normalization -QueueDescriptor > + +BaseWorkload< Normalization +QueueDescriptor > Node0->Node280 - - + + Node283 - -BaseWorkload< PadQueueDescriptor > + +BaseWorkload< PadQueueDescriptor > Node0->Node283 - - + + Node290 - -BaseWorkload< ParentDescriptor > + +BaseWorkload< ParentDescriptor > Node0->Node290 - - + + Node293 - -BaseWorkload< PermuteQueue -Descriptor > + +BaseWorkload< PermuteQueue +Descriptor > Node0->Node293 - - + + Node300 - -BaseWorkload< Pooling2dQueue -Descriptor > + +BaseWorkload< Pooling2dQueue +Descriptor > Node0->Node300 - - + + Node307 - -BaseWorkload< Pooling3dQueue -Descriptor > + +BaseWorkload< Pooling3dQueue +Descriptor > Node0->Node307 - - + + Node314 - -BaseWorkload< PreCompiled -QueueDescriptor > + +BaseWorkload< PreCompiled +QueueDescriptor > Node0->Node314 - - + + Node317 - -BaseWorkload< PreluQueue -Descriptor > + +BaseWorkload< PreluQueue +Descriptor > Node0->Node317 - - + + Node324 - -BaseWorkload< QLstmQueue -Descriptor > + +BaseWorkload< QLstmQueue +Descriptor > Node0->Node324 - - + + Node331 - -BaseWorkload< QuantizedLstm -QueueDescriptor > + +BaseWorkload< QuantizedLstm +QueueDescriptor > Node0->Node331 - - + + Node336 - -BaseWorkload< QuantizeQueue -Descriptor > + +BaseWorkload< QuantizeQueue +Descriptor > Node0->Node336 - - + + Node343 - -BaseWorkload< RankQueueDescriptor > + +BaseWorkload< RankQueueDescriptor > Node0->Node343 - - + + Node350 - -BaseWorkload< ReduceQueue -Descriptor > + +BaseWorkload< ReduceQueue +Descriptor > Node0->Node350 - - + + Node357 - -BaseWorkload< ReshapeQueue -Descriptor > + +BaseWorkload< ReshapeQueue +Descriptor > Node0->Node357 - - + + Node364 - -BaseWorkload< ResizeQueue -Descriptor > + +BaseWorkload< ResizeQueue +Descriptor > Node0->Node364 - - + + Node371 - -BaseWorkload< ReverseV2Queue -Descriptor > + +BaseWorkload< ReverseV2Queue +Descriptor > Node0->Node371 - - + + Node376 - -BaseWorkload< RsqrtQueue -Descriptor > + +BaseWorkload< RsqrtQueue +Descriptor > Node0->Node376 - - + + Node381 - -BaseWorkload< ShapeQueue -Descriptor > + +BaseWorkload< ScatterNdQueue +Descriptor > Node0->Node381 - - + + - - -Node384 - + + +Node386 + + +BaseWorkload< ShapeQueue +Descriptor > + + + + + +Node0->Node386 + + + + + +Node389 + BaseWorkload< SliceQueue Descriptor > - - -Node0->Node384 - - + + +Node0->Node389 + + - - -Node391 - - -BaseWorkload< SoftmaxQueue -Descriptor > + + +Node396 + + +BaseWorkload< SoftmaxQueue +Descriptor > - - -Node0->Node391 - - + + +Node0->Node396 + + - - -Node398 - + + +Node403 + BaseWorkload< SpaceToBatch NdQueueDescriptor > - - -Node0->Node398 - - + + +Node0->Node403 + + - - -Node405 - - -BaseWorkload< SpaceToDepth -QueueDescriptor > + + +Node410 + + +BaseWorkload< SpaceToDepth +QueueDescriptor > - - -Node0->Node405 - - + + +Node0->Node410 + + - - -Node412 - - -BaseWorkload< SplitterQueue -Descriptor > + + +Node417 + + +BaseWorkload< SplitterQueue +Descriptor > - - -Node0->Node412 - - + + +Node0->Node417 + + - - -Node419 - + + +Node424 + BaseWorkload< StackQueue Descriptor > - - -Node0->Node419 - - + + +Node0->Node424 + + - - -Node426 - + + +Node431 + BaseWorkload< StridedSlice QueueDescriptor > - - -Node0->Node426 - - - - - -Node433 - - -BaseWorkload< Subtraction -QueueDescriptor > - - - - - -Node0->Node433 - - + + +Node0->Node431 + + Node438 - -BaseWorkload< TileQueueDescriptor > + +BaseWorkload< Subtraction +QueueDescriptor > Node0->Node438 - - + + Node443 - -BaseWorkload< TransposeConvolution2d -QueueDescriptor > + +BaseWorkload< TileQueueDescriptor > Node0->Node443 - - + + - - -Node450 - + + +Node448 + + +BaseWorkload< TransposeConvolution2d +QueueDescriptor > + + + + + +Node0->Node448 + + + + + +Node455 + BaseWorkload< TransposeQueue Descriptor > - - -Node0->Node450 - - + + +Node0->Node455 + + - - -Node457 - + + +Node462 + BaseWorkload< Unidirectional SequenceLstmQueueDescriptor > - - -Node0->Node457 - - + + +Node0->Node462 + + - - -Node462 - + + +Node467 + BaseWorkload< UnmapQueue Descriptor > - - -Node0->Node462 - - + + +Node0->Node467 + + Node2 - -ClBaseWorkload< QueueDescriptor > + +ClBaseWorkload< QueueDescriptor > Node1->Node2 - - + + Node3 - -FirstInputTypedWorkload -< QueueDescriptor, DataType > + +FirstInputTypedWorkload +< QueueDescriptor, DataType > Node1->Node3 - - + + Node4 - -GpuFsaBaseWorkload -< QueueDescriptor > + +GpuFsaBaseWorkload +< QueueDescriptor > Node1->Node4 - - + + Node5 - -MultiTypedWorkload -< QueueDescriptor, InputData -Type, OutputDataType > + +MultiTypedWorkload +< QueueDescriptor, InputData +Type, OutputDataType > Node1->Node5 - - + + Node12 - -NeonBaseWorkload< QueueDescriptor > + +NeonBaseWorkload< QueueDescriptor > Node1->Node12 - - + + Node13 - -RefBaseWorkload< QueueDescriptor > + +RefBaseWorkload< QueueDescriptor > Node1->Node13 - - + + Node14 - -TosaRefBaseWorkload -< QueueDescriptor > + +TosaRefBaseWorkload +< QueueDescriptor > Node1->Node14 - - + + Node15 - -TypedWorkload< QueueDescriptor, - DataTypes > + +TypedWorkload< QueueDescriptor, + DataTypes > Node1->Node15 - - + + Node6 - -ClConvertFp16ToFp32Workload + +ClConvertFp16ToFp32Workload Node5->Node6 - - + + Node7 - -ClConvertFp32ToFp16Workload + +ClConvertFp32ToFp16Workload Node5->Node7 - - + + Node8 - -NeonConvertFp16ToFp32Workload + +NeonConvertFp16ToFp32Workload Node5->Node8 - - + + Node9 - -NeonConvertFp32ToFp16Workload + +NeonConvertFp32ToFp16Workload Node5->Node9 - - + + Node10 - -RefConvertFp16ToFp32Workload + +RefConvertFp16ToFp32Workload Node5->Node10 - - + + Node11 - -RefConvertFp32ToFp16Workload + +RefConvertFp32ToFp16Workload Node5->Node11 - - + + Node16 - -ClBatchNormalizationFloat -Workload + +ClBatchNormalizationFloat +Workload Node15->Node16 - - + + Node17 - -ClFloorFloatWorkload + +ClFloorFloatWorkload Node15->Node17 - - + + Node18 - -ClL2NormalizationFloatWorkload + +ClL2NormalizationFloatWorkload Node15->Node18 - - + + Node19 - -ClLstmFloatWorkload + +ClLstmFloatWorkload Node15->Node19 - - + + Node20 - -ClNormalizationFloatWorkload + +ClNormalizationFloatWorkload Node15->Node20 - - + + Node21 - -ClUnidirectionalSequence -LstmFloatWorkload + +ClUnidirectionalSequence +LstmFloatWorkload Node15->Node21 - - + + Node22 - -NeonFloorFloatWorkload + +NeonFloorFloatWorkload Node15->Node22 - - + + Node23 - -NeonL2NormalizationFloat -Workload + +NeonL2NormalizationFloat +Workload Node15->Node23 - - + + Node24 - -NeonLstmFloatWorkload + +NeonLstmFloatWorkload Node15->Node24 - - + + Node25 - -NeonNormalizationFloatWorkload + +NeonNormalizationFloatWorkload Node15->Node25 - - + + Node26 - -NeonUnidirectionalSequence -LstmFloatWorkload + +NeonUnidirectionalSequence +LstmFloatWorkload Node15->Node26 - - + + Node27 - -RefFakeQuantizationFloat32 -Workload + +RefFakeQuantizationFloat32 +Workload Node15->Node27 - - + + Node30 - -ClBaseWorkload< AbsQueue -Descriptor > + +ClBaseWorkload< AbsQueue +Descriptor > Node29->Node30 - - + + Node32 - -NeonBaseWorkload< AbsQueue -Descriptor > + +NeonBaseWorkload< AbsQueue +Descriptor > Node29->Node32 - - + + Node31 - -ClAbsWorkload + +ClAbsWorkload Node30->Node31 - - + + Node33 - -NeonAbsWorkload + +NeonAbsWorkload Node32->Node33 - - + + Node35 - -ClBaseWorkload< Activation -QueueDescriptor > + +ClBaseWorkload< Activation +QueueDescriptor > Node34->Node35 - - + + Node37 - -NeonBaseWorkload< Activation -QueueDescriptor > + +NeonBaseWorkload< Activation +QueueDescriptor > Node34->Node37 - - + + Node39 - -RefBaseWorkload< Activation -QueueDescriptor > + +RefBaseWorkload< Activation +QueueDescriptor > Node34->Node39 - - + + Node36 - -ClActivationWorkload + +ClActivationWorkload Node35->Node36 - - + + Node38 - -NeonActivationWorkload + +NeonActivationWorkload Node37->Node38 - - + + Node40 - -RefActivationWorkload + +RefActivationWorkload Node39->Node40 - - + + Node42 - -ClBaseWorkload< Addition -QueueDescriptor > + +ClBaseWorkload< Addition +QueueDescriptor > Node41->Node42 - - + + Node44 - -NeonBaseWorkload< Addition -QueueDescriptor > + +NeonBaseWorkload< Addition +QueueDescriptor > Node41->Node44 - - + + Node43 - -ClAdditionWorkload + +ClAdditionWorkload Node42->Node43 - - + + Node45 - -NeonAdditionWorkload + +NeonAdditionWorkload Node44->Node45 - - + + Node47 - -ClBaseWorkload< ArgMinMax -QueueDescriptor > + +ClBaseWorkload< ArgMinMax +QueueDescriptor > Node46->Node47 - - + + Node49 - -NeonBaseWorkload< ArgMin -MaxQueueDescriptor > + +NeonBaseWorkload< ArgMin +MaxQueueDescriptor > Node46->Node49 - - + + Node51 - -RefBaseWorkload< ArgMinMax -QueueDescriptor > + +RefBaseWorkload< ArgMinMax +QueueDescriptor > Node46->Node51 - - + + Node48 - -ClArgMinMaxWorkload + +ClArgMinMaxWorkload Node47->Node48 - - + + Node50 - -NeonArgMinMaxWorkload + +NeonArgMinMaxWorkload Node49->Node50 - - + + Node52 - -RefArgMinMaxWorkload + +RefArgMinMaxWorkload Node51->Node52 - - + + Node54 - -SampleDynamicAdditionWorkload + +SampleDynamicAdditionWorkload Node53->Node54 - - + + Node56 - -ClBaseWorkload< BatchMat -MulQueueDescriptor > + +ClBaseWorkload< BatchMat +MulQueueDescriptor > Node55->Node56 - - + + Node58 - -NeonBaseWorkload< BatchMat -MulQueueDescriptor > + +NeonBaseWorkload< BatchMat +MulQueueDescriptor > Node55->Node58 - - + + Node60 - -RefBaseWorkload< BatchMat -MulQueueDescriptor > + +RefBaseWorkload< BatchMat +MulQueueDescriptor > Node55->Node60 - - + + Node57 - -ClBatchMatMulWorkload + +ClBatchMatMulWorkload Node56->Node57 - - + + Node59 - -NeonBatchMatMulWorkload + +NeonBatchMatMulWorkload Node58->Node59 - - + + Node61 - -RefBatchMatMulWorkload + +RefBatchMatMulWorkload Node60->Node61 - - + + Node63 - -NeonBaseWorkload< BatchNormalization -QueueDescriptor > + +NeonBaseWorkload< BatchNormalization +QueueDescriptor > Node62->Node63 - - + + Node65 - -RefBaseWorkload< BatchNormalization -QueueDescriptor > + +RefBaseWorkload< BatchNormalization +QueueDescriptor > Node62->Node65 - - + + Node64 - -NeonBatchNormalizationWorkload + +NeonBatchNormalizationWorkload Node63->Node64 - - + + Node66 - -RefBatchNormalizationWorkload + +RefBatchNormalizationWorkload Node65->Node66 - - + + Node68 - -ClBaseWorkload< BatchToSpace -NdQueueDescriptor > + +ClBaseWorkload< BatchToSpace +NdQueueDescriptor > Node67->Node68 - - + + Node70 - -NeonBaseWorkload< BatchTo -SpaceNdQueueDescriptor > + +NeonBaseWorkload< BatchTo +SpaceNdQueueDescriptor > Node67->Node70 - - + + Node72 - -RefBaseWorkload< BatchTo -SpaceNdQueueDescriptor > + +RefBaseWorkload< BatchTo +SpaceNdQueueDescriptor > Node67->Node72 - - + + Node69 - -ClBatchToSpaceNdWorkload + +ClBatchToSpaceNdWorkload Node68->Node69 - - + + Node71 - -NeonBatchToSpaceNdWorkload + +NeonBatchToSpaceNdWorkload Node70->Node71 - - + + Node73 - -RefBatchToSpaceNdWorkload + +RefBatchToSpaceNdWorkload Node72->Node73 - - + + Node75 - -RefBaseWorkload< Broadcast -ToQueueDescriptor > + +RefBaseWorkload< Broadcast +ToQueueDescriptor > Node74->Node75 - - + + Node76 - -RefBroadcastToWorkload + +RefBroadcastToWorkload Node75->Node76 - - + + Node78 - -ClBaseWorkload< CastQueue -Descriptor > + +ClBaseWorkload< CastQueue +Descriptor > Node77->Node78 - - + + Node80 - -NeonBaseWorkload< CastQueue -Descriptor > + +NeonBaseWorkload< CastQueue +Descriptor > Node77->Node80 - - + + Node82 - -RefBaseWorkload< CastQueue -Descriptor > + +RefBaseWorkload< CastQueue +Descriptor > Node77->Node82 - - + + Node79 - -ClCastWorkload + +ClCastWorkload Node78->Node79 - - + + Node81 - -NeonCastWorkload + +NeonCastWorkload Node80->Node81 - - + + Node83 - -RefCastWorkload + +RefCastWorkload Node82->Node83 - - + + Node85 - -ClBaseWorkload< ChannelShuffle -QueueDescriptor > + +ClBaseWorkload< ChannelShuffle +QueueDescriptor > Node84->Node85 - - + + Node87 - -NeonBaseWorkload< Channel -ShuffleQueueDescriptor > + +NeonBaseWorkload< Channel +ShuffleQueueDescriptor > Node84->Node87 - - + + Node89 - -RefBaseWorkload< Channel -ShuffleQueueDescriptor > + +RefBaseWorkload< Channel +ShuffleQueueDescriptor > Node84->Node89 - - + + Node86 - -ClChannelShuffleWorkload + +ClChannelShuffleWorkload Node85->Node86 - - + + Node88 - -NeonChannelShuffleWorkload + +NeonChannelShuffleWorkload Node87->Node88 - - + + Node90 - -RefChannelShuffleWorkload + +RefChannelShuffleWorkload Node89->Node90 - - + + Node92 - -ClBaseWorkload< Comparison -QueueDescriptor > + +ClBaseWorkload< Comparison +QueueDescriptor > Node91->Node92 - - + + Node94 - -NeonBaseWorkload< Comparison -QueueDescriptor > + +NeonBaseWorkload< Comparison +QueueDescriptor > Node91->Node94 - - + + Node96 - -RefBaseWorkload< Comparison -QueueDescriptor > + +RefBaseWorkload< Comparison +QueueDescriptor > Node91->Node96 - - + + Node93 - -ClComparisonWorkload + +ClComparisonWorkload Node92->Node93 - - + + Node95 - -NeonComparisonWorkload + +NeonComparisonWorkload Node94->Node95 - - + + Node97 - -RefComparisonWorkload + +RefComparisonWorkload Node96->Node97 - - + + Node99 - -ClBaseWorkload< ConcatQueue -Descriptor > + +ClBaseWorkload< ConcatQueue +Descriptor > Node98->Node99 - - + + Node101 - -NeonBaseWorkload< Concat -QueueDescriptor > + +NeonBaseWorkload< Concat +QueueDescriptor > Node98->Node101 - - + + Node103 - -RefBaseWorkload< ConcatQueue -Descriptor > + +RefBaseWorkload< ConcatQueue +Descriptor > Node98->Node103 - - + + Node100 - -ClConcatWorkload + +ClConcatWorkload Node99->Node100 - - + + Node102 - -NeonConcatWorkload + +NeonConcatWorkload Node101->Node102 - - + + Node104 - -RefConcatWorkload + +RefConcatWorkload Node103->Node104 - - + + Node106 - -ClBaseWorkload< Constant -QueueDescriptor > + +ClBaseWorkload< Constant +QueueDescriptor > Node105->Node106 - - + + Node108 - -GpuFsaBaseWorkload -< ConstantQueueDescriptor > + +GpuFsaBaseWorkload +< ConstantQueueDescriptor > Node105->Node108 - - + + Node110 - -NeonBaseWorkload< Constant -QueueDescriptor > + +NeonBaseWorkload< Constant +QueueDescriptor > Node105->Node110 - - + + Node112 - -RefBaseWorkload< Constant -QueueDescriptor > + +RefBaseWorkload< Constant +QueueDescriptor > Node105->Node112 - - + + Node107 - -ClConstantWorkload + +ClConstantWorkload Node106->Node107 - - + + Node109 - -GpuFsaConstantWorkload + +GpuFsaConstantWorkload Node108->Node109 - - + + Node111 - -NeonConstantWorkload + +NeonConstantWorkload Node110->Node111 - - + + Node113 - -RefConstantWorkload + +RefConstantWorkload Node112->Node113 - - + + Node115 - -ClBaseWorkload< Convolution2d -QueueDescriptor > + +ClBaseWorkload< Convolution2d +QueueDescriptor > Node114->Node115 - - + + Node117 - -NeonBaseWorkload< Convolution2d -QueueDescriptor > + +NeonBaseWorkload< Convolution2d +QueueDescriptor > Node114->Node117 - - + + Node119 - -RefBaseWorkload< Convolution2d -QueueDescriptor > + +RefBaseWorkload< Convolution2d +QueueDescriptor > Node114->Node119 - - + + Node116 - -ClConvolution2dWorkload + +ClConvolution2dWorkload Node115->Node116 - - + + Node118 - -NeonConvolution2dWorkload + +NeonConvolution2dWorkload Node117->Node118 - - + + Node120 - -RefConvolution2dWorkload + +RefConvolution2dWorkload Node119->Node120 - - + + Node122 - -ClBaseWorkload< Convolution3d -QueueDescriptor > + +ClBaseWorkload< Convolution3d +QueueDescriptor > Node121->Node122 - - + + Node124 - -NeonBaseWorkload< Convolution3d -QueueDescriptor > + +NeonBaseWorkload< Convolution3d +QueueDescriptor > Node121->Node124 - - + + Node126 - -RefBaseWorkload< Convolution3d -QueueDescriptor > + +RefBaseWorkload< Convolution3d +QueueDescriptor > Node121->Node126 - - + + Node123 - -ClConvolution3dWorkload + +ClConvolution3dWorkload Node122->Node123 - - + + Node125 - -NeonConvolution3dWorkload + +NeonConvolution3dWorkload Node124->Node125 - - + + Node127 - -RefConvolution3dWorkload + +RefConvolution3dWorkload Node126->Node127 - - + + Node129 - -TypedWorkload< DebugQueue -Descriptor, DataType > + +TypedWorkload< DebugQueue +Descriptor, DataType > Node128->Node129 - - + + Node130 - -RefDebugWorkload< DataType > + +RefDebugWorkload< DataType > Node129->Node130 - - + + Node132 - -ClBaseWorkload< DepthToSpace -QueueDescriptor > + +ClBaseWorkload< DepthToSpace +QueueDescriptor > Node131->Node132 - - + + Node134 - -NeonBaseWorkload< DepthTo -SpaceQueueDescriptor > + +NeonBaseWorkload< DepthTo +SpaceQueueDescriptor > Node131->Node134 - - + + Node136 - -RefBaseWorkload< DepthTo -SpaceQueueDescriptor > + +RefBaseWorkload< DepthTo +SpaceQueueDescriptor > Node131->Node136 - - + + Node133 - -ClDepthToSpaceWorkload + +ClDepthToSpaceWorkload Node132->Node133 - - + + Node135 - -NeonDepthToSpaceWorkload + +NeonDepthToSpaceWorkload Node134->Node135 - - + + Node137 - -RefDepthToSpaceWorkload + +RefDepthToSpaceWorkload Node136->Node137 - - + + Node139 - -ClBaseWorkload< Depthwise -Convolution2dQueueDescriptor > + +ClBaseWorkload< Depthwise +Convolution2dQueueDescriptor > Node138->Node139 - - + + Node141 - -NeonBaseWorkload< Depthwise -Convolution2dQueueDescriptor > + +NeonBaseWorkload< Depthwise +Convolution2dQueueDescriptor > Node138->Node141 - - + + Node143 - -RefBaseWorkload< Depthwise -Convolution2dQueueDescriptor > + +RefBaseWorkload< Depthwise +Convolution2dQueueDescriptor > Node138->Node143 - - + + Node140 - -ClDepthwiseConvolutionWorkload + +ClDepthwiseConvolutionWorkload Node139->Node140 - - + + Node142 - -NeonDepthwiseConvolution -Workload + +NeonDepthwiseConvolution +Workload Node141->Node142 - - + + Node144 - -RefDepthwiseConvolution2d -Workload + +RefDepthwiseConvolution2d +Workload Node143->Node144 - - + + Node146 - -ClBaseWorkload< Dequantize -QueueDescriptor > + +ClBaseWorkload< Dequantize +QueueDescriptor > Node145->Node146 - - + + Node148 - -NeonBaseWorkload< Dequantize -QueueDescriptor > + +NeonBaseWorkload< Dequantize +QueueDescriptor > Node145->Node148 - - + + Node150 - -RefBaseWorkload< Dequantize -QueueDescriptor > + +RefBaseWorkload< Dequantize +QueueDescriptor > Node145->Node150 - - + + Node147 - -ClDequantizeWorkload + +ClDequantizeWorkload Node146->Node147 - - + + Node149 - -NeonDequantizeWorkload + +NeonDequantizeWorkload Node148->Node149 - - + + Node151 - -RefDequantizeWorkload + +RefDequantizeWorkload Node150->Node151 - - + + Node153 - -NeonBaseWorkload< Detection -PostProcessQueueDescriptor > + +NeonBaseWorkload< Detection +PostProcessQueueDescriptor > Node152->Node153 - - + + Node155 - -RefBaseWorkload< Detection -PostProcessQueueDescriptor > + +RefBaseWorkload< Detection +PostProcessQueueDescriptor > Node152->Node155 - - + + Node154 - -NeonDetectionPostProcess -Workload + +NeonDetectionPostProcess +Workload Node153->Node154 - - + + Node156 - -RefDetectionPostProcessWorkload + +RefDetectionPostProcessWorkload Node155->Node156 - - + + Node158 - -ClBaseWorkload< Division -QueueDescriptor > + +ClBaseWorkload< Division +QueueDescriptor > Node157->Node158 - - + + Node160 - -NeonBaseWorkload< Division -QueueDescriptor > + +NeonBaseWorkload< Division +QueueDescriptor > Node157->Node160 - - + + Node159 - -ClDivisionWorkload + +ClDivisionWorkload Node158->Node159 - - + + Node161 - -NeonDivisionWorkload + +NeonDivisionWorkload Node160->Node161 - - + + Node163 - -ClBaseWorkload< Elementwise -BinaryQueueDescriptor > + +ClBaseWorkload< Elementwise +BinaryQueueDescriptor > Node162->Node163 - - + + Node165 - -NeonBaseWorkload< Elementwise -BinaryQueueDescriptor > + +NeonBaseWorkload< Elementwise +BinaryQueueDescriptor > Node162->Node165 - - + + Node167 - -RefBaseWorkload< Elementwise -BinaryQueueDescriptor > + +RefBaseWorkload< Elementwise +BinaryQueueDescriptor > Node162->Node167 - - + + Node164 - -ClElementwiseBinaryWorkload + +ClElementwiseBinaryWorkload Node163->Node164 - - + + Node166 - -NeonElementwiseBinaryWorkload + +NeonElementwiseBinaryWorkload Node165->Node166 - - + + Node168 - -RefElementwiseBinaryWorkload + +RefElementwiseBinaryWorkload Node167->Node168 - - + + Node170 - -ClBaseWorkload< Elementwise -UnaryQueueDescriptor > + +ClBaseWorkload< Elementwise +UnaryQueueDescriptor > Node169->Node170 - - + + Node177 - -NeonBaseWorkload< Elementwise -UnaryQueueDescriptor > + +NeonBaseWorkload< Elementwise +UnaryQueueDescriptor > Node169->Node177 - - + + Node184 - -RefBaseWorkload< Elementwise -UnaryQueueDescriptor > + +RefBaseWorkload< Elementwise +UnaryQueueDescriptor > Node169->Node184 - - + + Node171 - -ClExpWorkload + +ClExpWorkload Node170->Node171 - - + + Node172 - -ClLogicalNotWorkload + +ClLogicalNotWorkload Node170->Node172 - - + + Node173 - -ClLogWorkload + +ClLogWorkload Node170->Node173 - - + + Node174 - -ClNegWorkload + +ClNegWorkload Node170->Node174 - - + + Node175 - -ClSinWorkload + +ClSinWorkload Node170->Node175 - - + + Node176 - -ClSqrtWorkload + +ClSqrtWorkload Node170->Node176 - - + + Node178 - -NeonExpWorkload + +NeonExpWorkload Node177->Node178 - - + + Node179 - -NeonLogicalNotWorkload + +NeonLogicalNotWorkload Node177->Node179 - - + + Node180 - -NeonLogWorkload + +NeonLogWorkload Node177->Node180 - - + + Node181 - -NeonNegWorkload + +NeonNegWorkload Node177->Node181 - - + + Node182 - -NeonSinWorkload + +NeonSinWorkload Node177->Node182 - - + + Node183 - -NeonSqrtWorkload + +NeonSqrtWorkload Node177->Node183 - - + + Node185 - -RefElementwiseUnaryWorkload + +RefElementwiseUnaryWorkload Node184->Node185 - - + + Node186 - -RefLogicalUnaryWorkload + +RefLogicalUnaryWorkload Node184->Node186 - - + + Node188 - -ClBaseWorkload< FillQueue -Descriptor > + +ClBaseWorkload< FillQueue +Descriptor > Node187->Node188 - - + + Node190 - -NeonBaseWorkload< FillQueue -Descriptor > + +NeonBaseWorkload< FillQueue +Descriptor > Node187->Node190 - - + + Node192 - -RefBaseWorkload< FillQueue -Descriptor > + +RefBaseWorkload< FillQueue +Descriptor > Node187->Node192 - - + + Node189 - -ClFillWorkload + +ClFillWorkload Node188->Node189 - - + + Node191 - -NeonFillWorkload + +NeonFillWorkload Node190->Node191 - - + + Node193 - -RefFillWorkload + +RefFillWorkload Node192->Node193 - - + + Node195 - -RefBaseWorkload< FloorQueue -Descriptor > + +RefBaseWorkload< FloorQueue +Descriptor > Node194->Node195 - - + + Node196 - -RefFloorWorkload + +RefFloorWorkload Node195->Node196 - - + + Node198 - -ClBaseWorkload< FullyConnected -QueueDescriptor > + +ClBaseWorkload< FullyConnected +QueueDescriptor > Node197->Node198 - - + + Node200 - -NeonBaseWorkload< FullyConnected -QueueDescriptor > + +NeonBaseWorkload< FullyConnected +QueueDescriptor > Node197->Node200 - - + + Node202 - -RefBaseWorkload< FullyConnected -QueueDescriptor > + +RefBaseWorkload< FullyConnected +QueueDescriptor > Node197->Node202 - - + + Node199 - -ClFullyConnectedWorkload + +ClFullyConnectedWorkload Node198->Node199 - - + + Node201 - -NeonFullyConnectedWorkload + +NeonFullyConnectedWorkload Node200->Node201 - - + + Node203 - -RefFullyConnectedWorkload + +RefFullyConnectedWorkload Node202->Node203 - - + + Node205 - -NeonBaseWorkload< FusedQueue -Descriptor > + +NeonBaseWorkload< FusedQueue +Descriptor > Node204->Node205 - - + + Node206 - -NeonFusedWorkload + +NeonFusedWorkload Node205->Node206 - - + + Node208 - -ClBaseWorkload< GatherNd -QueueDescriptor > + +ClBaseWorkload< GatherNd +QueueDescriptor > Node207->Node208 - - + + Node210 - -NeonBaseWorkload< Gather -NdQueueDescriptor > + +NeonBaseWorkload< Gather +NdQueueDescriptor > Node207->Node210 - - + + Node212 - -RefBaseWorkload< GatherNd -QueueDescriptor > + +RefBaseWorkload< GatherNd +QueueDescriptor > Node207->Node212 - - + + Node209 - -ClGatherNdWorkload + +ClGatherNdWorkload Node208->Node209 - - + + Node211 - -NeonGatherNdWorkload + +NeonGatherNdWorkload Node210->Node211 - - + + Node213 - -RefGatherNdWorkload + +RefGatherNdWorkload Node212->Node213 - - + + Node215 - -ClBaseWorkload< GatherQueue -Descriptor > + +ClBaseWorkload< GatherQueue +Descriptor > Node214->Node215 - - + + Node217 - -NeonBaseWorkload< Gather -QueueDescriptor > + +NeonBaseWorkload< Gather +QueueDescriptor > Node214->Node217 - - + + Node219 - -RefBaseWorkload< GatherQueue -Descriptor > + +RefBaseWorkload< GatherQueue +Descriptor > Node214->Node219 - - + + Node216 - -ClGatherWorkload + +ClGatherWorkload Node215->Node216 - - + + Node218 - -NeonGatherWorkload + +NeonGatherWorkload Node217->Node218 - - + + Node220 - -RefGatherWorkload + +RefGatherWorkload Node219->Node220 - - + + Node222 - -ClBaseWorkload< Instance -NormalizationQueueDescriptor > + +ClBaseWorkload< Instance +NormalizationQueueDescriptor > Node221->Node222 - - + + Node224 - -NeonBaseWorkload< Instance -NormalizationQueueDescriptor > + +NeonBaseWorkload< Instance +NormalizationQueueDescriptor > Node221->Node224 - - + + Node226 - -RefBaseWorkload< Instance -NormalizationQueueDescriptor > + +RefBaseWorkload< Instance +NormalizationQueueDescriptor > Node221->Node226 - - + + Node223 - -ClInstanceNormalizationWorkload + +ClInstanceNormalizationWorkload Node222->Node223 - - + + Node225 - -NeonInstanceNormalization -Workload + +NeonInstanceNormalization +Workload Node224->Node225 - - + + Node227 - -RefInstanceNormalization -Workload + +RefInstanceNormalization +Workload Node226->Node227 - - + + Node229 - -RefBaseWorkload< L2Normalization -QueueDescriptor > + +RefBaseWorkload< L2Normalization +QueueDescriptor > Node228->Node229 - - + + Node230 - -RefL2NormalizationWorkload + +RefL2NormalizationWorkload Node229->Node230 - - + + Node232 - -ClBaseWorkload< LogicalBinary -QueueDescriptor > + +ClBaseWorkload< LogicalBinary +QueueDescriptor > Node231->Node232 - - + + Node235 - -NeonBaseWorkload< Logical -BinaryQueueDescriptor > + +NeonBaseWorkload< Logical +BinaryQueueDescriptor > Node231->Node235 - - + + Node238 - -RefBaseWorkload< Logical -BinaryQueueDescriptor > + +RefBaseWorkload< Logical +BinaryQueueDescriptor > Node231->Node238 - - + + Node233 - -ClLogicalAndWorkload + +ClLogicalAndWorkload Node232->Node233 - - + + Node234 - -ClLogicalOrWorkload + +ClLogicalOrWorkload Node232->Node234 - - + + Node236 - -NeonLogicalAndWorkload + +NeonLogicalAndWorkload Node235->Node236 - - + + Node237 - -NeonLogicalOrWorkload + +NeonLogicalOrWorkload Node235->Node237 - - + + Node239 - -RefLogicalBinaryWorkload + +RefLogicalBinaryWorkload Node238->Node239 - - + + Node241 - -ClBaseWorkload< LogSoftmax -QueueDescriptor > + +ClBaseWorkload< LogSoftmax +QueueDescriptor > Node240->Node241 - - + + Node243 - -NeonBaseWorkload< LogSoftmax -QueueDescriptor > + +NeonBaseWorkload< LogSoftmax +QueueDescriptor > Node240->Node243 - - + + Node245 - -RefBaseWorkload< LogSoftmax -QueueDescriptor > + +RefBaseWorkload< LogSoftmax +QueueDescriptor > Node240->Node245 - - + + Node242 - -ClLogSoftmaxWorkload + +ClLogSoftmaxWorkload Node241->Node242 - - + + Node244 - -NeonLogSoftmaxWorkload + +NeonLogSoftmaxWorkload Node243->Node244 - - + + Node246 - -RefLogSoftmaxWorkload + +RefLogSoftmaxWorkload Node245->Node246 - - + + Node248 - -RefBaseWorkload< LstmQueue -Descriptor > + +RefBaseWorkload< LstmQueue +Descriptor > Node247->Node248 - - + + Node249 - -RefLstmWorkload + +RefLstmWorkload Node248->Node249 - - + + Node251 - -MapWorkload + +MapWorkload Node250->Node251 - - + + Node253 - -ClBaseWorkload< MaximumQueue -Descriptor > + +ClBaseWorkload< MaximumQueue +Descriptor > Node252->Node253 - - + + Node255 - -NeonBaseWorkload< Maximum -QueueDescriptor > + +NeonBaseWorkload< Maximum +QueueDescriptor > Node252->Node255 - - + + Node254 - -ClMaximumWorkload + +ClMaximumWorkload Node253->Node254 - - + + Node256 - -NeonMaximumWorkload + +NeonMaximumWorkload Node255->Node256 - - + + Node258 - -ClBaseWorkload< MeanQueue -Descriptor > + +ClBaseWorkload< MeanQueue +Descriptor > Node257->Node258 - - + + Node260 - -NeonBaseWorkload< MeanQueue -Descriptor > + +NeonBaseWorkload< MeanQueue +Descriptor > Node257->Node260 - - + + Node262 - -RefBaseWorkload< MeanQueue -Descriptor > + +RefBaseWorkload< MeanQueue +Descriptor > Node257->Node262 - - + + Node259 - -ClMeanWorkload + +ClMeanWorkload Node258->Node259 - - + + Node261 - -NeonMeanWorkload + +NeonMeanWorkload Node260->Node261 - - + + Node263 - -RefMeanWorkload + +RefMeanWorkload Node262->Node263 - - + + Node265 - -CopyMemGenericWorkload + +CopyMemGenericWorkload Node264->Node265 - - + + Node267 - -ImportMemGenericWorkload + +ImportMemGenericWorkload Node266->Node267 - - + + Node269 - -SyncMemGenericWorkload + +SyncMemGenericWorkload Node268->Node269 - - + + Node271 - -ClBaseWorkload< MinimumQueue -Descriptor > + +ClBaseWorkload< MinimumQueue +Descriptor > Node270->Node271 - - + + Node273 - -NeonBaseWorkload< Minimum -QueueDescriptor > + +NeonBaseWorkload< Minimum +QueueDescriptor > Node270->Node273 - - + + Node272 - -ClMinimumWorkload + +ClMinimumWorkload Node271->Node272 - - + + Node274 - -NeonMinimumWorkload + +NeonMinimumWorkload Node273->Node274 - - + + Node276 - -ClBaseWorkload< Multiplication -QueueDescriptor > + +ClBaseWorkload< Multiplication +QueueDescriptor > Node275->Node276 - - + + Node278 - -NeonBaseWorkload< Multiplication -QueueDescriptor > + +NeonBaseWorkload< Multiplication +QueueDescriptor > Node275->Node278 - - + + Node277 - -ClMultiplicationWorkload + +ClMultiplicationWorkload Node276->Node277 - - + + Node279 - -NeonMultiplicationWorkload + +NeonMultiplicationWorkload Node278->Node279 - - + + Node281 - -RefBaseWorkload< Normalization -QueueDescriptor > + +RefBaseWorkload< Normalization +QueueDescriptor > Node280->Node281 - - + + Node282 - -RefNormalizationWorkload + +RefNormalizationWorkload Node281->Node282 - - + + Node284 - -ClBaseWorkload< PadQueue -Descriptor > + +ClBaseWorkload< PadQueue +Descriptor > Node283->Node284 - - + + Node286 - -NeonBaseWorkload< PadQueue -Descriptor > + +NeonBaseWorkload< PadQueue +Descriptor > Node283->Node286 - - + + Node288 - -RefBaseWorkload< PadQueue -Descriptor > + +RefBaseWorkload< PadQueue +Descriptor > Node283->Node288 - - + + Node285 - -ClPadWorkload + +ClPadWorkload Node284->Node285 - - + + Node287 - -NeonPadWorkload + +NeonPadWorkload Node286->Node287 - - + + Node289 - -RefPadWorkload + +RefPadWorkload Node288->Node289 - - + + Node291 - -RefBaseWorkload< ParentDescriptor > + +RefBaseWorkload< ParentDescriptor > Node290->Node291 - - + + Node292 - -RefElementwiseWorkload -< Functor, ParentDescriptor, - DebugString > + +RefElementwiseWorkload +< Functor, ParentDescriptor, + DebugString > Node291->Node292 - - + + Node294 - -ClBaseWorkload< PermuteQueue -Descriptor > + +ClBaseWorkload< PermuteQueue +Descriptor > Node293->Node294 - - + + Node296 - -NeonBaseWorkload< Permute -QueueDescriptor > + +NeonBaseWorkload< Permute +QueueDescriptor > Node293->Node296 - - + + Node298 - -TypedWorkload< PermuteQueue -Descriptor, DataType > + +TypedWorkload< PermuteQueue +Descriptor, DataType > Node293->Node298 - - + + Node295 - -ClPermuteWorkload + +ClPermuteWorkload Node294->Node295 - - + + Node297 - -NeonPermuteWorkload + +NeonPermuteWorkload Node296->Node297 - - + + Node299 - -RefPermuteWorkload -< DataType > + +RefPermuteWorkload +< DataType > Node298->Node299 - - + + Node301 - -ClBaseWorkload< Pooling2d -QueueDescriptor > + +ClBaseWorkload< Pooling2d +QueueDescriptor > Node300->Node301 - - + + Node303 - -NeonBaseWorkload< Pooling2d -QueueDescriptor > + +NeonBaseWorkload< Pooling2d +QueueDescriptor > Node300->Node303 - - + + Node305 - -RefBaseWorkload< Pooling2d -QueueDescriptor > + +RefBaseWorkload< Pooling2d +QueueDescriptor > Node300->Node305 - - + + Node302 - -ClPooling2dWorkload + +ClPooling2dWorkload Node301->Node302 - - + + Node304 - -NeonPooling2dWorkload + +NeonPooling2dWorkload Node303->Node304 - - + + Node306 - -RefPooling2dWorkload + +RefPooling2dWorkload Node305->Node306 - - + + Node308 - -ClBaseWorkload< Pooling3d -QueueDescriptor > + +ClBaseWorkload< Pooling3d +QueueDescriptor > Node307->Node308 - - + + Node310 - -NeonBaseWorkload< Pooling3d -QueueDescriptor > + +NeonBaseWorkload< Pooling3d +QueueDescriptor > Node307->Node310 - - + + Node312 - -RefBaseWorkload< Pooling3d -QueueDescriptor > + +RefBaseWorkload< Pooling3d +QueueDescriptor > Node307->Node312 - - + + Node309 - -ClPooling3dWorkload + +ClPooling3dWorkload Node308->Node309 - - + + Node311 - -NeonPooling3dWorkload + +NeonPooling3dWorkload Node310->Node311 - - + + Node313 - -RefPooling3dWorkload + +RefPooling3dWorkload Node312->Node313 - - + + Node315 - -GpuFsaPreCompiledWorkload + +GpuFsaPreCompiledWorkload Node314->Node315 - - + + Node316 - -TosaRefPreCompiledWorkload + +TosaRefPreCompiledWorkload Node314->Node316 - - + + Node318 - -ClBaseWorkload< PreluQueue -Descriptor > + +ClBaseWorkload< PreluQueue +Descriptor > Node317->Node318 - - + + Node320 - -NeonBaseWorkload< PreluQueue -Descriptor > + +NeonBaseWorkload< PreluQueue +Descriptor > Node317->Node320 - - + + Node322 - -RefBaseWorkload< PreluQueue -Descriptor > + +RefBaseWorkload< PreluQueue +Descriptor > Node317->Node322 - - + + Node319 - -ClPreluWorkload + +ClPreluWorkload Node318->Node319 - - + + Node321 - -NeonPreluWorkload + +NeonPreluWorkload Node320->Node321 - - + + Node323 - -RefPreluWorkload + +RefPreluWorkload Node322->Node323 - - + + Node325 - -ClBaseWorkload< QLstmQueue -Descriptor > + +ClBaseWorkload< QLstmQueue +Descriptor > Node324->Node325 - - + + Node327 - -NeonBaseWorkload< QLstmQueue -Descriptor > + +NeonBaseWorkload< QLstmQueue +Descriptor > Node324->Node327 - - + + Node329 - -RefBaseWorkload< QLstmQueue -Descriptor > + +RefBaseWorkload< QLstmQueue +Descriptor > Node324->Node329 - - + + Node326 - -ClQLstmWorkload + +ClQLstmWorkload Node325->Node326 - - + + Node328 - -NeonQLstmWorkload + +NeonQLstmWorkload Node327->Node328 - - + + Node330 - -RefQLstmWorkload + +RefQLstmWorkload Node329->Node330 - - + + Node332 - -ClBaseWorkload< Quantized -LstmQueueDescriptor > + +ClBaseWorkload< Quantized +LstmQueueDescriptor > Node331->Node332 - - + + Node334 - -NeonBaseWorkload< Quantized -LstmQueueDescriptor > + +NeonBaseWorkload< Quantized +LstmQueueDescriptor > Node331->Node334 - - + + Node333 - -ClQuantizedLstmWorkload + +ClQuantizedLstmWorkload Node332->Node333 - - + + Node335 - -NeonQuantizedLstmWorkload + +NeonQuantizedLstmWorkload Node334->Node335 - - + + Node337 - -ClBaseWorkload< Quantize -QueueDescriptor > + +ClBaseWorkload< Quantize +QueueDescriptor > Node336->Node337 - - + + Node339 - -NeonBaseWorkload< Quantize -QueueDescriptor > + +NeonBaseWorkload< Quantize +QueueDescriptor > Node336->Node339 - - + + Node341 - -RefBaseWorkload< Quantize -QueueDescriptor > + +RefBaseWorkload< Quantize +QueueDescriptor > Node336->Node341 - - + + Node338 - -ClQuantizeWorkload + +ClQuantizeWorkload Node337->Node338 - - + + Node340 - -NeonQuantizeWorkload + +NeonQuantizeWorkload Node339->Node340 - - + + Node342 - -RefQuantizeWorkload + +RefQuantizeWorkload Node341->Node342 - - + + Node344 - -ClBaseWorkload< RankQueue -Descriptor > + +ClBaseWorkload< RankQueue +Descriptor > Node343->Node344 - - + + Node346 - -NeonBaseWorkload< RankQueue -Descriptor > + +NeonBaseWorkload< RankQueue +Descriptor > Node343->Node346 - - + + Node348 - -RefBaseWorkload< RankQueue -Descriptor > + +RefBaseWorkload< RankQueue +Descriptor > Node343->Node348 - - + + Node345 - -ClRankWorkload + +ClRankWorkload Node344->Node345 - - + + Node347 - -NeonRankWorkload + +NeonRankWorkload Node346->Node347 - - + + Node349 - -RefRankWorkload + +RefRankWorkload Node348->Node349 - - + + Node351 - -ClBaseWorkload< ReduceQueue -Descriptor > + +ClBaseWorkload< ReduceQueue +Descriptor > Node350->Node351 - - + + Node353 - -NeonBaseWorkload< Reduce -QueueDescriptor > + +NeonBaseWorkload< Reduce +QueueDescriptor > Node350->Node353 - - + + Node355 - -RefBaseWorkload< ReduceQueue -Descriptor > + +RefBaseWorkload< ReduceQueue +Descriptor > Node350->Node355 - - + + Node352 - -ClReduceWorkload + +ClReduceWorkload Node351->Node352 - - + + Node354 - -NeonReduceWorkload + +NeonReduceWorkload Node353->Node354 - - + + Node356 - -RefReduceWorkload + +RefReduceWorkload Node355->Node356 - - + + Node358 - -ClBaseWorkload< ReshapeQueue -Descriptor > + +ClBaseWorkload< ReshapeQueue +Descriptor > Node357->Node358 - - + + Node360 - -NeonBaseWorkload< Reshape -QueueDescriptor > + +NeonBaseWorkload< Reshape +QueueDescriptor > Node357->Node360 - - + + Node362 - -RefBaseWorkload< Reshape -QueueDescriptor > + +RefBaseWorkload< Reshape +QueueDescriptor > Node357->Node362 - - + + Node359 - -ClReshapeWorkload + +ClReshapeWorkload Node358->Node359 - - + + Node361 - -NeonReshapeWorkload + +NeonReshapeWorkload Node360->Node361 - - + + Node363 - -RefReshapeWorkload + +RefReshapeWorkload Node362->Node363 - - + + Node365 - -ClBaseWorkload< ResizeQueue -Descriptor > + +ClBaseWorkload< ResizeQueue +Descriptor > Node364->Node365 - - + + Node367 - -NeonBaseWorkload< Resize -QueueDescriptor > + +NeonBaseWorkload< Resize +QueueDescriptor > Node364->Node367 - - + + Node369 - -RefBaseWorkload< ResizeQueue -Descriptor > + +RefBaseWorkload< ResizeQueue +Descriptor > Node364->Node369 - - + + Node366 - -ClResizeWorkload + +ClResizeWorkload Node365->Node366 - - + + Node368 - -NeonResizeWorkload + +NeonResizeWorkload Node367->Node368 - - + + Node370 - -RefResizeWorkload + +RefResizeWorkload Node369->Node370 - - + + Node372 - -ClReverseV2Workload + +ClReverseV2Workload Node371->Node372 - - + + Node373 - -NeonReverseV2Workload + +NeonReverseV2Workload Node371->Node373 - - + + Node374 - -RefBaseWorkload< Reverse -V2QueueDescriptor > + +RefBaseWorkload< Reverse +V2QueueDescriptor > Node371->Node374 - - + + Node375 - -RefReverseV2Workload + +RefReverseV2Workload Node374->Node375 - - + + Node377 - -ClBaseWorkload< RsqrtQueue -Descriptor > + +ClBaseWorkload< RsqrtQueue +Descriptor > Node376->Node377 - - + + Node379 - -NeonBaseWorkload< RsqrtQueue -Descriptor > + +NeonBaseWorkload< RsqrtQueue +Descriptor > Node376->Node379 - - + + Node378 - -ClRsqrtWorkload + +ClRsqrtWorkload Node377->Node378 - - + + Node380 - -NeonRsqrtWorkload + +NeonRsqrtWorkload Node379->Node380 - - + + Node382 - - -RefBaseWorkload< ShapeQueue -Descriptor > + + +ClBaseWorkload< ScatterNd +QueueDescriptor > Node381->Node382 - - + + - + + +Node384 + + +RefBaseWorkload< Scatter +NdQueueDescriptor > + + + + + +Node381->Node384 + + + + Node383 - - -RefShapeWorkload + + +ClScatterNdWorkload Node382->Node383 - - + + Node385 - - -ClBaseWorkload< SliceQueue -Descriptor > + + +RefScatterNdWorkload Node384->Node385 - - + + Node387 - - -NeonBaseWorkload< SliceQueue -Descriptor > + + +RefBaseWorkload< ShapeQueue +Descriptor > - + -Node384->Node387 - - - - - -Node389 - - -RefBaseWorkload< SliceQueue -Descriptor > - - - - - -Node384->Node389 - - - - - -Node386 - - -ClSliceWorkload - - - - - -Node385->Node386 - - +Node386->Node387 + + Node388 - - -NeonSliceWorkload + + +RefShapeWorkload Node387->Node388 - - + + Node390 - - -RefSliceWorkload + + +ClBaseWorkload< SliceQueue +Descriptor > Node389->Node390 - - + + Node392 - - -ClBaseWorkload< SoftmaxQueue -Descriptor > + + +NeonBaseWorkload< SliceQueue +Descriptor > - + -Node391->Node392 - - +Node389->Node392 + + Node394 - - -NeonBaseWorkload< Softmax -QueueDescriptor > + + +RefBaseWorkload< SliceQueue +Descriptor > - + -Node391->Node394 - - +Node389->Node394 + + - - -Node396 - - -RefBaseWorkload< Softmax -QueueDescriptor > + + +Node391 + + +ClSliceWorkload - - -Node391->Node396 - - + + +Node390->Node391 + + Node393 - - -ClSoftmaxWorkload + + +NeonSliceWorkload Node392->Node393 - - + + Node395 - - -NeonSoftmaxWorkload + + +RefSliceWorkload Node394->Node395 - - + + Node397 - - -RefSoftmaxWorkload + + +ClBaseWorkload< SoftmaxQueue +Descriptor > Node396->Node397 - - + + Node399 - - -ClBaseWorkload< SpaceToBatch -NdQueueDescriptor > + + +NeonBaseWorkload< Softmax +QueueDescriptor > - + -Node398->Node399 - - +Node396->Node399 + + Node401 - - -NeonBaseWorkload< SpaceTo -BatchNdQueueDescriptor > + + +RefBaseWorkload< Softmax +QueueDescriptor > - + -Node398->Node401 - - +Node396->Node401 + + - - -Node403 - - -RefBaseWorkload< SpaceTo -BatchNdQueueDescriptor > + + +Node398 + + +ClSoftmaxWorkload - - -Node398->Node403 - - + + +Node397->Node398 + + Node400 - - -ClSpaceToBatchNdWorkload + + +NeonSoftmaxWorkload Node399->Node400 - - + + Node402 - - -NeonSpaceToBatchNdWorkload + + +RefSoftmaxWorkload Node401->Node402 - - + + Node404 - - -RefSpaceToBatchNdWorkload + + +ClBaseWorkload< SpaceToBatch +NdQueueDescriptor > Node403->Node404 - - + + Node406 - - -ClBaseWorkload< SpaceToDepth -QueueDescriptor > + + +NeonBaseWorkload< SpaceTo +BatchNdQueueDescriptor > - + -Node405->Node406 - - +Node403->Node406 + + Node408 - - -NeonBaseWorkload< SpaceTo -DepthQueueDescriptor > + + +RefBaseWorkload< SpaceTo +BatchNdQueueDescriptor > - + -Node405->Node408 - - +Node403->Node408 + + - - -Node410 - - -RefBaseWorkload< SpaceTo -DepthQueueDescriptor > + + +Node405 + + +ClSpaceToBatchNdWorkload - - -Node405->Node410 - - + + +Node404->Node405 + + Node407 - - -ClSpaceToDepthWorkload + + +NeonSpaceToBatchNdWorkload Node406->Node407 - - + + Node409 - - -NeonSpaceToDepthWorkload + + +RefSpaceToBatchNdWorkload Node408->Node409 - - + + Node411 - - -RefSpaceToDepthWorkload + + +ClBaseWorkload< SpaceToDepth +QueueDescriptor > Node410->Node411 - - + + Node413 - - -ClBaseWorkload< Splitter -QueueDescriptor > + + +NeonBaseWorkload< SpaceTo +DepthQueueDescriptor > - + -Node412->Node413 - - +Node410->Node413 + + Node415 - - -NeonBaseWorkload< Splitter -QueueDescriptor > + + +RefBaseWorkload< SpaceTo +DepthQueueDescriptor > - + -Node412->Node415 - - +Node410->Node415 + + - - -Node417 - - -RefBaseWorkload< Splitter -QueueDescriptor > + + +Node412 + + +ClSpaceToDepthWorkload - - -Node412->Node417 - - + + +Node411->Node412 + + Node414 - - -ClSplitterWorkload + + +NeonSpaceToDepthWorkload Node413->Node414 - - + + Node416 - - -NeonSplitterWorkload + + +RefSpaceToDepthWorkload Node415->Node416 - - + + Node418 - - -RefSplitterWorkload + + +ClBaseWorkload< Splitter +QueueDescriptor > Node417->Node418 - - + + Node420 - + + +NeonBaseWorkload< Splitter +QueueDescriptor > + + + + + +Node417->Node420 + + + + + +Node422 + + +RefBaseWorkload< Splitter +QueueDescriptor > + + + + + +Node417->Node422 + + + + + +Node419 + + +ClSplitterWorkload + + + + + +Node418->Node419 + + + + + +Node421 + + +NeonSplitterWorkload + + + + + +Node420->Node421 + + + + + +Node423 + + +RefSplitterWorkload + + + + + +Node422->Node423 + + + + + +Node425 + ClBaseWorkload< StackQueue Descriptor > - - -Node419->Node420 + + +Node424->Node425 - - -Node422 - + + +Node427 + NeonBaseWorkload< StackQueue Descriptor > - - -Node419->Node422 + + +Node424->Node427 - - -Node424 - + + +Node429 + RefBaseWorkload< StackQueue Descriptor > - - -Node419->Node424 + + +Node424->Node429 - - -Node421 - + + +Node426 + ClStackWorkload - - -Node420->Node421 + + +Node425->Node426 - - -Node423 - + + +Node428 + NeonStackWorkload - - -Node422->Node423 + + +Node427->Node428 - - -Node425 - + + +Node430 + RefStackWorkload - - -Node424->Node425 + + +Node429->Node430 - - -Node427 - + + +Node432 + ClBaseWorkload< StridedSlice QueueDescriptor > - - -Node426->Node427 + + +Node431->Node432 - - -Node429 - + + +Node434 + NeonBaseWorkload< Strided SliceQueueDescriptor > - - -Node426->Node429 + + +Node431->Node434 - - -Node431 - + + +Node436 + RefBaseWorkload< Strided SliceQueueDescriptor > - - -Node426->Node431 + + +Node431->Node436 - - -Node428 - + + +Node433 + ClStridedSliceWorkload - - -Node427->Node428 + + +Node432->Node433 - - -Node430 - + + +Node435 + NeonStridedSliceWorkload - - -Node429->Node430 + + +Node434->Node435 - - -Node432 - + + +Node437 + RefStridedSliceWorkload - - -Node431->Node432 + + +Node436->Node437 - - -Node434 - + + +Node439 + ClBaseWorkload< Subtraction QueueDescriptor > - - -Node433->Node434 + + +Node438->Node439 - - -Node436 - + + +Node441 + NeonBaseWorkload< Subtraction QueueDescriptor > - - -Node433->Node436 + + +Node438->Node441 - - -Node435 - + + +Node440 + ClSubtractionWorkload - - -Node434->Node435 + + +Node439->Node440 - - -Node437 - + + +Node442 + NeonSubtractionWorkload - - -Node436->Node437 + + +Node441->Node442 - - -Node439 - + + +Node444 + ClTileWorkload - - -Node438->Node439 + + +Node443->Node444 - - -Node440 - + + +Node445 + NeonTileWorkload - - -Node438->Node440 + + +Node443->Node445 - - -Node441 - + + +Node446 + RefBaseWorkload< TileQueue Descriptor > - - -Node438->Node441 + + +Node443->Node446 - - -Node442 - + + +Node447 + RefTileWorkload - - -Node441->Node442 + + +Node446->Node447 - - -Node444 - + + +Node449 + ClBaseWorkload< Transpose Convolution2dQueueDescriptor > - - -Node443->Node444 - - + + +Node448->Node449 + + - - -Node446 - + + +Node451 + NeonBaseWorkload< Transpose Convolution2dQueueDescriptor > - - -Node443->Node446 - - + + +Node448->Node451 + + - - -Node448 - + + +Node453 + RefBaseWorkload< Transpose Convolution2dQueueDescriptor > - - -Node443->Node448 - - + + +Node448->Node453 + + - - -Node445 - + + +Node450 + ClTransposeConvolution2d Workload - - -Node444->Node445 + + +Node449->Node450 - - -Node447 - + + +Node452 + NeonTransposeConvolution2d Workload - - -Node446->Node447 + + +Node451->Node452 - - -Node449 - + + +Node454 + RefTransposeConvolution2d Workload - - -Node448->Node449 + + +Node453->Node454 - - -Node451 - + + +Node456 + ClBaseWorkload< Transpose QueueDescriptor > - - -Node450->Node451 + + +Node455->Node456 - - -Node453 - + + +Node458 + NeonBaseWorkload< Transpose QueueDescriptor > - - -Node450->Node453 + + +Node455->Node458 - - -Node455 - + + +Node460 + TypedWorkload< Transpose QueueDescriptor, DataType > - - -Node450->Node455 + + +Node455->Node460 - - -Node452 - + + +Node457 + ClTransposeWorkload - - -Node451->Node452 + + +Node456->Node457 - - -Node454 - + + +Node459 + NeonTransposeWorkload - - -Node453->Node454 + + +Node458->Node459 - - -Node456 - + + +Node461 + RefTransposeWorkload < DataType > - - -Node455->Node456 + + +Node460->Node461 - - -Node458 - + + +Node463 + NeonBaseWorkload< Unidirectional SequenceLstmQueueDescriptor > - - -Node457->Node458 + + +Node462->Node463 - - -Node460 - + + +Node465 + RefBaseWorkload< Unidirectional SequenceLstmQueueDescriptor > - - -Node457->Node460 + + +Node462->Node465 - - -Node459 - + + +Node464 + NeonUnidirectionalSequence LstmWorkload - - -Node458->Node459 + + +Node463->Node464 - - -Node461 - + + +Node466 + RefUnidirectionalSequence LstmWorkload - - -Node460->Node461 + + +Node465->Node466 - - -Node463 - + + +Node468 + UnmapWorkload - - -Node462->Node463 + + +Node467->Node468 -- cgit v1.2.1