| ►Nat | Flush-To-Zero and Denormals-Are-Zero mode |
| ►Ncuda | |
| ►Ndetail | |
| CCUDAHooks | |
| CArray | |
| CCUDAEvent | |
| CCUDAMultiStreamGuard | |
| ►Ndetail | |
| CCPUGuardImpl | |
| ►Nnative | |
| ►Ndetail | |
| CCuFFTConfig | |
| CCuFFTHandleDeleter | |
| CCuFFTParams | |
| CCuFFTParamsLRUCache | |
| CAbsMaxOps | |
| CAbsMinOps | |
| CAdvancedIndex | |
| CConstant | |
| CConvolutionDescriptor | |
| CConvParams | |
| CCpuEngine | |
| CCTCLossDescriptor | |
| CDescriptor | |
| CDescriptorDeleter | |
| CDftiDescriptor | |
| CDftiDescriptorDeleter | |
| CDispatchStub< rT(*)(Args...), T > | |
| CDropoutDescriptor | |
| CFilterDescriptor | |
| Cinter_copy_type | |
| Cinter_copy_type< uint8_t > | |
| CInvStd | |
| CMeanOps | |
| Cmiopen_exception | |
| CNormOneOps | |
| CNormOps | |
| CNormZeroOps | |
| CParamsEqual | |
| CParamsHash | |
| CRNNDescriptor | |
| CSpatialTransformerDescriptor | |
| CStream | |
| CTensorDescriptor | |
| CVar | |
| CWelfordData | |
| CWelfordOps | |
| CAccumulateType | |
| CAccumulateType< char, false > | |
| CAccumulateType< char, true > | |
| CAccumulateType< double, false > | |
| CAccumulateType< double, true > | |
| CAccumulateType< float, false > | |
| CAccumulateType< float, true > | |
| CAccumulateType< Half, true > | |
| CAccumulateType< int16_t, false > | |
| CAccumulateType< int16_t, true > | |
| CAccumulateType< int32_t, false > | |
| CAccumulateType< int32_t, true > | |
| CAccumulateType< int64_t, false > | |
| CAccumulateType< int64_t, true > | |
| CAccumulateType< int8_t, false > | |
| CAccumulateType< int8_t, true > | |
| CAccumulateType< uint8_t, false > | |
| CAccumulateType< uint8_t, true > | |
| CATenDLMTensor | |
| CAutoNonVariableTypeMode | |
| CBaseContext | Virtual interface for the Context class in Caffe2 |
| CCAFFE2_API | |
| CComplexHooks | |
| CComplexHooksArgs | |
| CComplexHooksInterface | |
| CContext | |
| CCPUComplexFloatType | |
| CCPUTypeDefault | |
| CCUDAHooksArgs | |
| CCUDAHooksInterface | |
| CCUDATypeDefault | |
| CDefaultPtrTraits | |
| CDimCounter | |
| CFormatGuard | |
| CGenerator | |
| CHIPHooksArgs | |
| CHIPHooksInterface | |
| CLegacyDeviceTypeInit | |
| CLegacyDeviceTypeInitArgs | |
| CLegacyDeviceTypeInitInterface | |
| CLegacyTHDispatch | |
| CLegacyTHDispatcher | |
| CLegacyTHDispatcherDeleter | |
| CLegacyTypeDeleter | |
| CLegacyTypeDispatch | |
| CMatrixRef | MatrixRef - Like an ArrayRef, but with an extra recorded strides so that we can easily view it as a multidimensional array |
| CNonVariableTypeMode | |
| COperandInfo | |
| CPackedTensorAccessor | |
| CPackedTensorAccessor< T, 1, PtrTraits, index_t > | |
| CPackedTensorAccessorBase | |
| CRange | |
| CSparseTensorImpl | |
| CSparseTensorRef | |
| ►CSplitUntil32Bit | A container-like struct that acts as if it contains splits of a TensorIterator that can use 32-bit indexing |
| Citerator | |
| Cstrided_tensor_iter | |
| Cstrided_tensor_iter_fixed | |
| CTensor | |
| CTensorAccessor | |
| CTensorAccessor< T, 1, PtrTraits, index_t > | |
| CTensorAccessorBase | |
| CTensorArg | |
| CTensorGeometry | |
| CTensorGeometryArg | |
| ►CTensorIterator | |
| CBuilder | |
| CType | |
| CTypeDefault | |
| CTypeExtendedInterface | |
| CUndefinedType | |
| CVariableHooksArgs | |
| CVariableHooksInterface | |
| CWeakTensor | |
| ►Nc10 | To register your own kernel for an operator, do in one (!) cpp file: C10_REGISTER_KERNEL(OperatorHandle) .kernel<decltype(&kernel_func), &kernel_func>() .dispatchKey(dispatch_key); |
| ►Ncuda | |
| ►NCUDACachingAllocator | |
| CCudaCachingAllocator | |
| CTHCCachingAllocator | |
| ►Nimpl | |
| CCUDAGuardImpl | |
| CCUDAGuard | A variant of DeviceGuard that is specialized for CUDA |
| CCUDAStream | |
| CCUDAStreamGuard | A variant of StreamGuard that is specialized for CUDA |
| COptionalCUDAGuard | A variant of OptionalDeviceGuard that is specialized for CUDA |
| COptionalCUDAStreamGuard | A variant of OptionalStreamGuard that is specialized for CUDA |
| ►Ndetail | |
| C_guarded_unsigned_long_unique_dummy | |
| CAlignerImpl | |
| CgetTypePtr_ | |
| CgetTypePtr_< ArrayRef< T > > | |
| CgetTypePtr_< at::optional< T > > | |
| CgetTypePtr_< at::Scalar > | |
| CgetTypePtr_< at::Tensor > | |
| CgetTypePtr_< bool > | |
| CgetTypePtr_< double > | |
| CgetTypePtr_< int64_t > | |
| CgetTypePtr_< std::string > | |
| CgetTypePtr_< std::unordered_map< K, V > > | |
| CgetTypePtr_< std::vector< T > > | |
| CIncrementRAII | |
| Cintrusive_target_default_null_type | |
| Civalue_to_arg_type | |
| Civalue_to_arg_type< ArrayRef< T > > | |
| COpSchemaRegistrar | |
| Cpush_outputs | |
| Cpush_outputs< std::tuple< OutputTypes... > > | |
| CRegistrationListenerList | |
| CSizerImpl | |
| CThreadsafeOperatorTable_ | Kernel implementations in a thread-safe hash table |
| CUniqueVoidPtr | |
| Cwrap_kernel | |
| Cwrap_kernel< CacheTypeOrVoid, FuncType, kernel, guts::enable_if_t< std::is_same< void, CacheTypeOrVoid >::value &&!std::is_same< void, typename guts::function_traits< FuncType >::return_type >::value > > | |
| Cwrap_kernel< CacheTypeOrVoid, FuncType, kernel, guts::enable_if_t< std::is_same< void, CacheTypeOrVoid >::value &&std::is_same< void, typename guts::function_traits< FuncType >::return_type >::value > > | |
| Cwrap_kernel< CacheTypeOrVoid, FuncType, kernel, guts::enable_if_t<!std::is_same< void, CacheTypeOrVoid >::value &&!std::is_same< void, typename guts::function_traits< FuncType >::return_type >::value > > | |
| Cwrap_kernel< CacheTypeOrVoid, FuncType, kernel, guts::enable_if_t<!std::is_same< void, CacheTypeOrVoid >::value &&std::is_same< void, typename guts::function_traits< FuncType >::return_type >::value > > | |
| ►Ndetail_ | |
| Chas_overloaded_addressof | |
| ►Nenforce_detail | Rich logging messages |
| CEnforceFailMessage | |
| CEnforceOK | |
| ►Nguts | |
| ►Ndetail | Some added features not available in std::array |
| C__array_traits | |
| ►C__array_traits< _Tp, 0 > | |
| C_Type | |
| CDummyClassForToString | |
| Cextract_arg_by_filtered_index_ | |
| Cextract_arg_by_filtered_index_< Condition, index, guts::enable_if_t< Condition< Head >::value &&index!=0 >, Head, Tail... > | |
| Cextract_arg_by_filtered_index_< Condition, index, guts::enable_if_t< Condition< Head >::value &&index==0 >, Head, Tail... > | |
| Cextract_arg_by_filtered_index_< Condition, index, guts::enable_if_t<!Condition< Head >::value >, Head, Tail... > | |
| Cextract_arg_by_filtered_index_< Condition, index, void > | |
| Cfilter_map_ | |
| Cfilter_map_< ResultType, 0 > | |
| Cmake_integer_sequence_ | |
| Cmake_integer_sequence_< T, N, N, Ints... > | |
| Cstrip_class | Strip_class: helper to remove the class type from pointers to operator() |
| Cstrip_class< Result(Class::*)(Args...) const > | |
| Cstrip_class< Result(Class::*)(Args...)> | |
| Cto_string_ | |
| Cto_string_< T, void_t< decltype(std::to_string(std::declval< T >()))> | |
| ►Ntypelist | |
| ►Ndetail | Maps a list of types into a list of values |
| Cmap_types_to_values | |
| Cmap_types_to_values< typelist< Types... > > | |
| Ctype_ | |
| Cconcat | Concatenates multiple type lists |
| Cconcat< typelist< Head1Types... >, typelist< Head2Types... >, TailLists... > | |
| Cconcat< typelist< HeadTypes... > > | |
| Cconcat<> | |
| Ccount_if | Counts how many types in the list fulfill a type trait Examples: 2 == count_if<std::is_reference, typelist<void, string, int&, bool, const string&&, int>> |
| Celement | Returns the N-th element of a type list |
| Celement< 0, typelist< Head, Tail... > > | Successful case, we have reached the zero index and can "return" the head type |
| Celement< Index, typelist< Head, Tail... > > | Shave off types until we hit the <0, Head, Tail...> or <Index> case |
| Celement< Index, typelist< Ts... > > | Error case, we have an index but ran out of types! It will only be selected if Ts... is actually empty! |
| Cfilter | Filters the types in a type list by a type trait |
| Cfilter< Condition, typelist< Head, Tail... > > | |
| Cfilter< Condition, typelist<> > | |
| Cfind_if | Find the index of the first type in a typelist fulfilling a type trait condition |
| Cfind_if< typelist< Head, Tail... >, Condition, enable_if_t< Condition< Head >::value > > | |
| Cfind_if< typelist< Head, Tail... >, Condition, enable_if_t<!Condition< Head >::value > > | |
| Cfind_if< typelist<>, Condition, void > | |
| Cfrom_tuple | Creates a typelist containing the types of a given tuple |
| Cfrom_tuple< std::tuple< Types... > > | |
| Chead | Returns the first element of a type list |
| Chead< typelist< Head, Tail... > > | |
| Clast | Returns the last element of a type list |
| Clast< typelist< Head > > | |
| Clast< typelist< Head, Tail... > > | |
| Cmap | Maps types of a type list using a type trait Example: typelist<int&, double&, string&> == map_t<std::add_lvalue_reference_t, typelist<int, double, string>> |
| Cmap< Mapper, typelist< Types... > > | |
| Creverse | Reverses a typelist |
| Creverse< typelist< Head, Tail... > > | |
| Creverse< typelist<> > | |
| Csize | Returns the number of types in a typelist Example: 3 == size<typelist<int, int, double>>::value |
| Csize< typelist< Types... > > | |
| Cto_tuple | Transforms a list of types into a tuple holding these types |
| Cto_tuple< typelist< Types... > > | |
| Ctrue_for_each_type | Returns true iff the type trait is true for all types in the type list Examples: true == true_for_each_type<std::is_reference, typelist<int&, const float&&, const MyClass&>>::value false == true_for_each_type<std::is_reference, typelist<int&, const float&&, MyClass>>::value |
| Ctrue_for_each_type< Condition, typelist< Types... > > | |
| Ctypelist | Type holding a list of types for compile time type computations |
| Carray | |
| Cconjunction | |
| Cconjunction< B1 > | |
| Cconjunction< B1, Bn... > | |
| Cdisjunction | |
| Cdisjunction< B1 > | |
| Cdisjunction< B1, Bn... > | |
| Cenable_if_t< std::is_same< bool, guts::remove_cv_t< decltype(C< int >::value)> >::value > | |
| Cfalse_higher_t | |
| Cfalse_t | |
| Cfunction_traits | Access information about result type or arguments from a function type |
| Cfunction_traits< Result(Args...)> | |
| Cinfer_function_traits | Infer_function_traits: creates a function_traits type for a simple function (pointer) or functor (lambda/struct) |
| Cinfer_function_traits< Result(*)(Args...)> | |
| Cinteger_sequence | |
| Cis_equality_comparable | Is_equality_comparable<T> is true_type iff the equality operator is defined for T |
| Cis_function_type | Is_function_type<T> is true_type iff T is a plain function type (i.e |
| Cis_function_type< Result(Args...)> | |
| Cis_hashable | Is_hashable<T> is true_type iff std::hash is defined for T |
| Cis_instantiation_of | Is_instantiation_of<T, I> is true_type iff I is a template instantiation of T (e.g |
| Cis_instantiation_of< Template, Template< Args... > > | |
| Cis_type_condition | Is_type_condition<C> is true_type iff C<...> is a type trait representing a condition (i.e |
| Cmake_void | |
| Cnegation | |
| ►Nhip | |
| CHIPAllocatorMasqueradingAsCUDA | |
| CHIPGuardImplMasqueradingAsCUDA | |
| CHIPGuardMasqueradingAsCUDA | This code is all a direct copy from c10/cuda/HIPGuardMasqueradingAsCUDA.h, but with the correct InlineDeviceGuard burned in |
| CHIPStreamGuardMasqueradingAsCUDA | |
| CHIPStreamMasqueradingAsCUDA | |
| COptionalHIPGuardMasqueradingAsCUDA | |
| COptionalHIPStreamGuardMasqueradingAsCUDA | |
| ►Nimpl | |
| CDeviceGuardImplInterface | DeviceGuardImplInterface represents the virtual interface which provides functionality to provide an RAII class for device and stream switching, via DeviceGuard |
| CDeviceGuardImplRegistrar | |
| CFakeGuardImpl | A fake implementation of DeviceGuardImplInterface suitable for testing |
| CInlineDeviceGuard | A DeviceGuard is an RAII class that sets a device to some value on construction, and resets the device to its original value on destruction |
| CInlineOptionalDeviceGuard | A OptionalDeviceGuard is an RAII class that sets a device to some value on initialization, and resets the device to its original value on destruction |
| CInlineOptionalStreamGuard | An OptionalStreamGuard is an RAII class that sets a device to some value on initialization, and resets the device to its original value on destruction |
| CInlineStreamGuard | A StreamGuard is an RAII class that changes the current device to the device corresponding to some stream, and changes the default stream on that device to be this stream |
| CVirtualGuardImpl | An implementation of DeviceGuardImplInterface which delegates to virtual dispatch on the DeviceGuardImpl registry |
| ►Nivalue | |
| CConstantString | |
| CDictEqualTo | |
| CDictHash | |
| CList | |
| CTuple | |
| C_CopyBytesFunctionRegisterer | |
| C_fake_type | |
| CAliasInfo | Class AliasInfo |
| CAlignedCharArray | Helper for building an aligned character array type |
| CAlignedCharArrayUnion | This union template exposes a suitably aligned and sized character array member which can hold elements of any of up to ten types |
| CAllocator | |
| CAllocatorRegisterer | |
| CArgument | |
| CArrayRef | ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory), i.e |
| CAutogradMetaInterface | |
| CAutogradZeroTensorType | |
| Cbad_optional_access | |
| CBoolType | |
| CC10FlagParser | |
| CC10Tensor | This is a minimal Tensor class for use in c10 code |
| CClassType | |
| CCompleteTensorType | |
| CComplexHalf | |
| Cconstexpr_optional_base | |
| Cconstexpr_storage_t | |
| CConverter | |
| CConverter< To, std::complex< FromV >, typename std::enable_if< c10::guts::negation< is_complex_t< To > >::value >::type > | |
| CDataPtr | |
| CDefaultCPUAllocator | |
| CDefaultTensorOptions | Like TensorOptions, but all fields are guaranteed to be filled |
| CDevice | Represents a a compute device on which a tensor is located |
| CDeviceGuard | RAII guard that sets a certain default device in its constructor, and changes it back to the device that was originally active upon destruction |
| CDeviceObjType | |
| CDictType | |
| CDimensionedTensorType | |
| CDispatcher | Top-level dispatch interface for dispatching via the dynamic dispatcher |
| CDispatchTable | Per-operator dispatch table |
| CDispatchTableEntry | The dispatch table stores a pointer to a kernel function and a pointer to a function initializing a cache for the kernel |
| CError | The primary ATen error class |
| CFloatType | |
| CFunctionSchema | |
| CFutureType | |
| CGeneratorType | |
| ►CHalf | |
| Cfrom_bits_t | |
| CIdWrapper | This template simplifies generation of simple classes that wrap an id in a typesafe way |
| Cin_place_t | |
| CIndexError | |
| CInefficientStdFunctionContext | |
| CInternedStrings | |
| Cintrusive_ptr | |
| Cintrusive_ptr_target | Intrusive_ptr<T> is an alternative to shared_ptr<T> that has better performance because it does the refcounting intrusively (i.e |
| CIntType | |
| Cis_complex_t | |
| Cis_complex_t< ComplexHalf > | |
| Cis_complex_t< std::complex< T > > | |
| ►Civalue | |
| CFutureError | |
| CIValue | |
| CKernelCache | A kernel can keep around a cache to have better performance when it's called multiple times |
| CKernelRegistrar | Class which, on construction, registers an operator in the dispatch table |
| CKernelRegistrationBuilder | Helper class for building a KernelRegistrar |
| CLeftRight | |
| CListType | |
| CLoggerVoidify | |
| CMatchTypeReturn | |
| CMemoryAllocationReporter | |
| CMessageLogger | |
| CNoneType | |
| ►Cnullopt_t | |
| Cinit | |
| CNumberType | |
| COperatorHandle | This is a handle to an operator schema registered with the dispatcher |
| COpKernel | This class represents an operator kernel, i.e |
| COpRegistrationListener | Implement this interface and register your instance with the dispatcher to get notified when operators are registered or deregistered with the dispatcher |
| Coptional | |
| Coptional< T & > | |
| Coptional< T && > | |
| Coptional_base | |
| COptionalDeviceGuard | A OptionalDeviceGuard is an RAII class that sets a device to some value on initialization, and resets the device to its original value on destruction |
| COptionalStreamGuard | An OptionalStreamGuard is an RAII class that sets a device to some value on initialization, and resets the device to its original value on destruction |
| COptionalType | |
| CPlacementDeleteContext | |
| CRegisterer | |
| CRegistry | A template class that allows one to register classes by keys |
| CScalar | Scalar represents a 0-dimensional tensor which contains a single element |
| Cscalar_value_type | |
| Cscalar_value_type< ComplexHalf > | |
| Cscalar_value_type< std::complex< T > > | |
| CSingleElementType | |
| CSmallVector | This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small |
| CSmallVectorBase | This is all the non-templated stuff common to all SmallVectors |
| CSmallVectorImpl | This class consists of common code factored out of the SmallVector class to reduce code duplication based on the SmallVector 'N' template parameter |
| CSmallVectorStorage | Storage for the SmallVector elements which aren't contained in SmallVectorTemplateCommon |
| CSmallVectorStorage< T, 0 > | |
| CSmallVectorStorage< T, 1 > | |
| CSmallVectorTemplateBase | SmallVectorTemplateBase<isPodLike = false> - This is where we put method implementations that are designed to work with non-POD-like T's |
| CSmallVectorTemplateBase< T, true > | SmallVectorTemplateBase<isPodLike = true> - This is where we put method implementations that are designed to work with POD-like T's |
| CSmallVectorTemplateCommon | This is the part of SmallVectorTemplateBase which does not depend on whether the type T is a POD |
| CSourceLocation | Represents a location in source code (for debugging) |
| CStorage | |
| Cstorage_t | |
| CStorageImpl | |
| CStream | A stream is a software mechanism used to synchronize launched kernels without requiring explicit synchronizations between kernels |
| CStreamGuard | A StreamGuard is an RAII class that changes the current device to the device corresponding to some stream, and changes the default stream on that device to be this stream |
| CStringType | |
| CSymbol | |
| CTaskThreadPool | |
| CTaskThreadPoolBase | |
| CTempFile | |
| CTensorImpl | The low-level representation of a tensor, which contains a pointer to a storage (which contains the actual data) and metadata (e.g., sizes and strides) describing this particular view of the data as a tensor |
| CTensorOptions | |
| CTensorType | |
| CTensorTypeId | Dynamic type ID of a Tensor argument |
| CTensorTypeIdCreator | |
| CTensorTypeIdRegistrar | |
| CTensorTypeIdRegistry | |
| CTensorTypeIds | |
| ►CThreadPool | |
| Ctask_element_t | |
| Ctrivial_init_t | |
| CTupleType | |
| CType | |
| CUndefinedTensorImpl | |
| CVarType | |
| CWarning | |
| Cweak_intrusive_ptr | |
| ►Nc10_test | |
| CAnotherBar | |
| CBar | |
| CFoo | |
| ►Ncaffe2 | A global dictionary that holds information about what Caffe2 modules have been loaded in the current runtime, and also utility functions to load modules |
| ►Ndag_utils | |
| COperatorNode | |
| COpGraphNode | |
| ►Ndataset_ops | |
| CSharedTensorVectorPtrDeserializer | |
| CSharedTensorVectorPtrSerializer | |
| CTreeCursor | |
| ►CTreeIterator | Provides functionality to iterate across a list of tensors where some of those tensors represent lengths in a hierarchical structure |
| CFieldDesc | |
| ►CTreeWalker | Simple wrapper class allowing an easy traversal of the tensors representing the hirerarchical structure |
| CField | |
| ►Ndb | |
| CBlobsQueueDB | |
| CBlobsQueueDBCursor | |
| CCreateBlobsQueueDBOp | |
| CCursor | An abstract class for the cursor of the database while reading |
| CDB | An abstract class for accessing a database of key-value pairs |
| CDBReader | A reader wrapper for DB that also allows us to serialize it |
| CDBReaderDeserializer | |
| CDBReaderSerializer | |
| CLevelDB | |
| CLevelDBCursor | |
| CLevelDBTransaction | |
| CLMDB | |
| CLMDBCursor | |
| CLMDBTransaction | |
| CMiniDB | |
| CMiniDBCursor | |
| CMiniDBTransaction | |
| CProtoDB | |
| CProtoDBCursor | |
| CProtoDBTransaction | |
| CRocksDB | |
| CRocksDBCursor | |
| CRocksDBTransaction | |
| CTransaction | An abstract class for the current database transaction while writing |
| CZmqDB | |
| CZmqDBCursor | |
| ►Ndetail | To make a c10 operator "C10Add" callable from caffe2 as "C2MyAddOpName", just write |
| C_guard_long_unique_dummy | |
| C_ScopeGuard | |
| C_Uninitialized | |
| CC10OperatorWrapper | |
| CLink | |
| COffsetAlias | |
| CParam | |
| CRecurrentGradient | |
| CRecurrentInput | |
| CScopeGuardImpl | |
| CScopeGuardImplBase | |
| CScratchWorkspaces | |
| CTensorDescriptors | |
| CTypeMetaData | |
| CWorkspaceStack | |
| ►Nemulator | |
| CBenchmarkParam | |
| CBenchmarkRunner | |
| CDataNetFiller | |
| CDataRandomFiller | |
| CEmulator | |
| CFiller | |
| CMutatingNetSupplier | |
| CNetSupplier | |
| COutputFormatter | |
| CProfiler | |
| CRunnableNet | |
| CSingleLoadedNetSupplier | |
| CSingleNetSupplier | |
| CStdOutputFormatter | |
| CTestDataRandomFiller | |
| CTimeProfiler | |
| ►NFeedBlob | |
| CGetExpGradient | |
| CGetLogGradient | |
| CGetSqrtGradient | |
| ►Nint8 | |
| CInt8AddOp | |
| CInt8AveragePoolOp | |
| CInt8ChannelShuffleOp | |
| CInt8ConcatOp | |
| CInt8ConvOp | |
| CInt8ConvTransposeOp | |
| CInt8DequantizeOp | |
| CInt8FCOp | |
| CInt8FlattenOp | |
| CInt8GivenIntTensorFillOp | |
| CInt8GivenTensorFillOp | |
| CInt8LeakyReluOp | |
| CInt8MaxPoolOp | |
| CInt8QuantizeOp | |
| CInt8ReluOp | |
| CInt8ReshapeOp | |
| CInt8ResizeNearestOp | |
| CInt8RoIAlignOp | |
| CInt8SigmoidOp | |
| CInt8SliceOp | |
| CInt8SoftmaxOp | |
| CInt8TensorCPU | |
| CInt8TensorCPUDeserializer | |
| CInt8TensorCPUSerializer | |
| ►Ninternal | |
| CCaffe2InitializeRegistry | |
| ►Nlc_op_util | |
| CCUDAConvNetShapeParams | |
| CShapeParams | |
| ►Nmath | |
| ►Ndetail | |
| CAxpyImpl | |
| CAxpyImpl< T, CPUContext, 1 > | |
| CScaleImpl | |
| CScaleImpl< T, CPUContext, 1 > | |
| ►Nutils | |
| CHalfAddFunctor | |
| CHalfDivFunctor | |
| CHalfMulFunctor | |
| CHalfSubFunctor | |
| ►Nmemonger | |
| CComputeBlobRecyclingForDag | |
| ►Nonnx | |
| CBackendGraphInfo | |
| CCaffe2Backend | |
| CCaffe2BackendRep | |
| CCaffe2Ops | |
| CConversionContext | |
| CDevice | |
| CDummyName | |
| COnnxAttributes | |
| COnnxBackendGraphMap | |
| COnnxExporter | |
| COnnxNode | |
| ►Nserialize | |
| CFileAdapter | |
| CIStreamAdapter | |
| CPyTorchStreamReader | |
| CPyTorchStreamWriter | |
| CReadAdapterInterface | |
| ►NTensorInferenceFunction | |
| CGetFCGradient | |
| ►Ntesting | |
| CNetMutator | |
| CWorkspaceMutator | |
| ►Ntracing | |
| CTracer | |
| CTracerEvent | |
| CTracerGuard | |
| CTracingConfig | |
| ►Ntransform | |
| CGraph | Graph representation of a Netdef |
| CNode | Graph representation of an operator |
| ►Nutils | |
| CConstTensorView | |
| CRotatedBox | |
| C_CaffeHighestPreallocatedTypeId | |
| CAbsFunctor | |
| CAbsGradientFunctor | |
| CAbstractLengthsDef | |
| CAbstractLengthsGradientOp | |
| CAbstractLengthsOp | Segment reduction op with optional fused embedding lookup |
| CAbstractLengthsWithMainInputAndForwardOutputGradientOp | |
| CAbstractLengthsWithMainInputGradientOp | |
| ►CAbstractReduceBackDef | |
| CGetGradient | |
| ►CAbstractReduceFrontDef | |
| CGetGradient | |
| CAbstractReduceFrontOrBackGradientOp | |
| CAbstractReduceFrontOrBackOp | Simple non-segmented reduction over the first few dimensions of the tensor |
| CAbstractSortedSegmentDef | |
| CAbstractSortedSegmentGradientOp | |
| CAbstractSortedSegmentOp | Segment reduction op with optional fused embedding lookup |
| ►CAbstractSortedSegmentRangeDef | |
| CGetGradient | |
| CAbstractSortedSegmentRangeGradientOp | |
| CAbstractSortedSegmentRangeOp | Base implementation for segment reduction op that leverages continuity of the data |
| CAbstractSparseLengthsDef | |
| CAbstractSparseSortedSegmentDef | |
| CAbstractSparseUnsortedSegmentDef | |
| CAbstractUnsortedSegmentDef | |
| CAbstractUnsortedSegmentGradientOp | |
| CAbstractUnsortedSegmentOp | Unsorted segment reduction op with optional fused embedding lookup |
| CAccumulateHistogramOp | |
| CAccumulateInputGradientOp | |
| CAccumulateOp | |
| CAccuracyOp | |
| CAcosFunctor | |
| CAcosGradientFunctor | |
| CAdadeltaOp | |
| CAdagradOp | |
| CAdamOp | |
| CAddDNNLowPOp | |
| CAddFunctor | |
| CAddPaddingOp | |
| CAdjustBatchOp | |
| CAffineChannelGradientOp | |
| CAffineChannelOp | |
| CAlgorithmsCache | |
| CAliasOp | Alias op makes the output and the input share the same underlying storage |
| CAlignedDeleter | |
| CAllocAligned | |
| CAlternateLearningRate | |
| CAPMeterOp | |
| CArgMaxReducer | |
| CArgMinReducer | |
| CArgOp | |
| CArgumentHelper | A helper class to index into arguments |
| CAsinFunctor | |
| CAsinGradientFunctor | |
| CAssertOp | |
| CAsyncNetBase | |
| CAsyncNetExecutorHelper | |
| CAsyncSchedulingNet | |
| CAsyncTask | |
| CAsyncTaskFuture | |
| CAsyncTaskGraph | |
| CAsyncTaskGraphBase | |
| CAtanFunctor | |
| CAtanGradientFunctor | |
| CAtomicIterOp | |
| CAveragedLoss | |
| CAveragedLossGradient | |
| CAveragePoolFunctor | |
| CAvgExportedStat | |
| CBackendTransformerBase | |
| CBaseInputAccessor | |
| ►CBaseReducer | |
| CMeta | |
| ►CBaseReducerGradient | |
| CMeta | |
| CBatchBoxCoxOp | |
| CBatchBucketizeOp | |
| CBatchBucketOneHotOp | |
| CBatchDenseToSparseOp | |
| CBatchGatherGradientOp | |
| CBatchGatherOp | |
| CBatchMatMulDNNLowPOp | |
| CBatchMatMulOp | |
| CBatchMomentsGradientOp | |
| CBatchMomentsOp | |
| CBatchOneHotOp | |
| CBatchPermutationDNNLowPOp | |
| CBatchPermutationGradientOp | |
| CBatchPermutationOp | |
| CBatchSparseToDenseOp | |
| CBatchToSpaceOp | |
| CBBoxTransformOp | |
| CBernoulliJSDGradientOp | |
| CBernoulliJSDOp | |
| CBinaryElementwiseDNNLowPOp | |
| CBinaryElementwiseWithArgsGradientOp | |
| CBinaryElementwiseWithArgsGradientOp< NumericTypes, CPUContext, BinaryFunctorWithDefaultCtor< DivFunctor< CPUContext > >, SameTypeAsInput, SameTypeAsInput > | |
| CBinaryElementwiseWithArgsOp | |
| CBinaryFunctorWithDefaultCtor | |
| CBisectPercentileOp | |
| CBlob | Blob is a general container that hosts a typed pointer |
| CBlobDeserializerBase | BlobDeserializerBase is an abstract class that deserializes a blob from a BlobProto or a TensorProto |
| CBlobSerializerBase | BlobSerializerBase is an abstract class that serializes a blob to a string |
| CBlobsQueue | |
| CBlobStatGetter | |
| ►CBlobStatRegistry | |
| CRegistrar | |
| CBlockingCounter | |
| CBooleanMaskOp | |
| CBooleanUnmaskOp | |
| CBoundShapeInferencer | |
| CBoundShapeSpec | |
| CBoxWithNMSLimitOp | |
| CBRGNCHWCToPackedInt8BGRAStylizerDeprocessOp | |
| CBufferedTokenizer | |
| CByteWeightDequantOp | |
| CCaffe2Annotation | |
| CCaffe2ModuleTestDynamicDummyOp | |
| CCastHelper | |
| CCastHelper< std::string, SrcType > | |
| CCastOp | |
| CCbrtFunctor | |
| CCbrtGradientFunctor | |
| CCeilOp | |
| CChannelBackpropStatsOp | |
| CChannelShuffleDNNLowPOp | |
| CChannelShuffleGradientOp | |
| CChannelShuffleOp | |
| CChannelStatsOp | |
| CCharRange | |
| CCheckCounterDoneOp | |
| CCheckpointOp | |
| CClipGradientOp | |
| CClipOp | |
| CClipTensorByScalingOp | |
| CCloseBlobsQueueOp | |
| CCloseRebatchingQueueOp | |
| CCol2ImOp | |
| CCollectAndDistributeFpnRpnProposalsOp | |
| CCommonSubexpressionEliminationTransform | Common Subexpression Elimination |
| CCompositeLearningRate | |
| CCompositeLearningRateItem | |
| CConcatDNNLowPOp | |
| CConcatOp | |
| CConditionalOp | |
| CConstantFillOp | |
| CConstantWarmupLearningRate | |
| CConvArgs | |
| CConvDNNLowPAcc16Op | Quantized Conv operator with 16-bit accumulation |
| CConvDNNLowPOp | |
| CConvDNNLowPPackWeightOp | Pack a weight matrix that can be used by DNNLOWP Int8Conv operators |
| CConverter | |
| CConvGradientOp | |
| CConvOp | |
| CConvPoolDNNLowPOpBase | |
| CConvPoolOpBase | |
| CConvReluOp | |
| CConvToNNPackTransform | |
| CConvTransposeGradientOp | |
| CConvTransposeOp | |
| CConvTransposeUnpoolBase | |
| CCopyCPUToIDEEPOp | |
| CCopyIDEEPToCPUOp | |
| CCopyOnDeviceLikeOp | |
| CCopyOp | |
| CCosFunctor | |
| CCosGradientFunctor | |
| CCoshFunctor | |
| CCoshGradientFunctor | |
| CCosineEmbeddingCriterionGradientOp | |
| CCosineEmbeddingCriterionOp | |
| CCosineSimilarityGradientOp | |
| CCosineSimilarityOp | |
| CCountDownOp | |
| CCounter | |
| CCountUpOp | |
| CCPUContext | The CPU Context, representing the bare minimum of what a Context class in Caffe2 should implement |
| CCPUEventWrapper | |
| CCpuId | Identification of an Intel CPU |
| CCPUSparseLengthsReductionOp | |
| CCreateBlobsQueueOp | |
| CCreateCounterOp | |
| CCreateDBOp | |
| CCreateMapOp | |
| CCreateRebatchingQueueOp | |
| CCreateScopeOp | |
| CCreateTextFileReaderOp | |
| CCrossEntropyGradientOp | |
| CCrossEntropyOp | |
| CCTCBeamSearchDecoderOp | |
| CCTCGreedyDecoderOp | |
| CCubeFunctor | |
| CCubeGradientFunctor | |
| CCUDAContext | |
| CCudaDevicePropWrapper | |
| CCudaEventWrapper | |
| CCUDARecurrentNetworkExecutor | |
| CCudaRTCFunction | |
| CCuDNNActivationGradientOp | |
| CCuDNNActivationGradientOp< CUDNN_ACTIVATION_ELU > | |
| CCuDNNActivationOp | |
| CCuDNNActivationOp< CUDNN_ACTIVATION_ELU > | |
| CCuDNNActivationOpBase | |
| CCudnnConvGradientOp | |
| CCudnnConvOp | |
| CCudnnConvOpBase | |
| CCudnnConvTransposeGradientOp | |
| CCudnnConvTransposeOp | |
| CCudnnConvTransposeOpBase | |
| CcudnnFilterDescWrapper | |
| CCuDNNLRNGradientOp | |
| CCuDNNLRNOp | |
| CCuDNNSoftmaxGradientOp | |
| CCuDNNSoftmaxOp | |
| CCuDNNState | |
| CcudnnTensorDescWrapper | CudnnTensorDescWrapper is the placeholder that wraps around a cudnnTensorDescriptor_t, allowing us to do descriptor change as-needed during runtime |
| CcudnnTypeWrapper | CudnnTypeWrapper is a wrapper class that allows us to refer to the cudnn type in a template function |
| CcudnnTypeWrapper< at::Half > | |
| CcudnnTypeWrapper< double > | |
| CcudnnTypeWrapper< float > | |
| CCuDNNWeightedSumOp | |
| CCuDNNWorkspace | CuDNNWorkspace is a wrapper around a raw cuda pointer that holds the cudnn scratch space |
| ►CCuDNNWrapper | CuDNNWrapper is a class that wraps the cudnn handles and cudnn workspaces |
| CSyncedCuDNNState | |
| CDataCoupleOp | |
| CDBExistsOp | |
| ►CDecodedFrame | |
| CavDeleter | |
| CDefaultEngine | |
| CDeformConvGradientOp | |
| CDeformConvOp | |
| CDeformConvOpBase | |
| CDenseVectorToIdListOp | |
| CDequantizeDNNLowPOp | |
| CDequeueBlobsOp | |
| CDequeueRebatchingQueueOp | |
| CDetailedExportedStat | |
| CDeviceTypeRegisterer | |
| CDiagonalFillOp | |
| CDispatchHelper | |
| CDispatchHelper< FixedValues< FirstVal, Values... >, ExtraArgs... > | |
| CDispatchHelper< FixedValues<>, ExtraArgs... > | |
| CDivFunctor | |
| CDNNLowPOp | A convenient base class for C2 operators with DNNLOWP engine |
| CDoOp | |
| CDotProductGradientOp | |
| CDotProductOp | |
| CDotProductWithPaddingGradientOp | |
| CDotProductWithPaddingOp | |
| CDropoutGradientOp | |
| CDropoutOp | |
| CEigenPowFunctor | |
| CElementwiseLinearDNNLowPOp | |
| CElementwiseLinearGradientOp | |
| CElementwiseLinearOp | |
| CElementwiseRTCOp | A GPU operator that can generate limited elementwise operations |
| CEluFunctor | |
| CEluGradientFunctor | |
| CEnforceFiniteOp | |
| CEnqueueBlobsOp | |
| CEnqueueRebatchingQueueOp | |
| CEnsureClippedOp | |
| CEnsureCPUOutputOp | |
| CEnsureDenseOp | Pass inputs to outputs |
| CErfFunctor | |
| CErfGradientFunctor | |
| CEvent | |
| CEventCreateFunctionRegisterer | |
| CEventErrorMessageFunctionRegisterer | |
| CEventFinishFunctionRegisterer | |
| CEventQueryFunctionRegisterer | |
| CEventRecordFunctionRegisterer | |
| CEventResetFunctionRegisterer | |
| CEventSetCallbackFunctionRegisterer | |
| CEventSetFinishedFunctionRegisterer | |
| CEventWaitFunctionRegisterer | |
| CExecutionOptions | |
| CExecutorHelper | |
| CExpandDimsOp | |
| CExpandGradientOp | |
| CExpandOp | |
| CExpFunctor | |
| CExpLearningRate | |
| CExportedStat | |
| CExportedStatValue | |
| CFailOp | |
| CFeedBlobOp | |
| CFileReader | |
| CFileStoreHandler | |
| CFileStoreHandlerCreateOp | |
| CFillerOp | |
| CFindDuplicateElementsOp | |
| CFindOp | |
| CFixedDivisor | |
| CFixedDivisor< std::int32_t > | |
| CFixedLearningRate | |
| CFixedType | |
| CFixedValues | |
| CFlattenOp | |
| CFlattenToVecOp | |
| CFlexibleTopKGradientOp | |
| CFlexibleTopKOp | |
| CFloat16ConstantFillOp | |
| CFloat16UniformFillOp | |
| CFloatToFused8BitRowwiseQuantizedOp | |
| CFloatToFusedRandRowwiseQuantizedOp | |
| CFloatToHalfOp | |
| CFloatToRowwiseQuantized8BitsOp | |
| CFloorOp | |
| CForEach | ForEach is a unary functor that forwards each element of the input array into the elementwise Functor provided, and gathers the results of each call into the resulting array |
| CFP16MomentumSGDUpdateOp | |
| CFP32MomentumSGDUpdateOp | |
| CFreeOp | |
| CFtrlOp | |
| CFtrlParams | |
| CFullyConnectedDecompGradientOp | |
| CFullyConnectedDNNLowPAcc16Op | Quantized FC operator with 16-bit accumulation |
| CFullyConnectedDNNLowPOp | |
| CFullyConnectedDNNLowPPackWeightOp | |
| CFullyConnectedFakeLowpFPOp | |
| CFullyConnectedGradientFakeLowpFPOp | |
| CFullyConnectedGradientOp | |
| CFullyConnectedOp | |
| CFullyConnectedOp_SPARSE | |
| CFullyConnectedOpDecomp | |
| CFullyConnectedOpPrune | |
| CFullyConnectedPruneGradientOp | |
| CFunHashGradientOp | |
| CFunHashOp | |
| CFused8BitRowwiseQuantizedToFloatOp | |
| CFusedRandRowwiseQuantizedToFloatOp | |
| CGatherByKeyOp | |
| CGatherDNNLowPOp | |
| CGatherFused8BitRowwiseOp | |
| CGatherOp | |
| CGatherPaddingOp | |
| CGatherRangesOp | |
| CGatherRangesToDenseOp | |
| CGaussianFillOp | |
| CGenerateProposalsOp | |
| CGenericTensorImplementation | |
| CGetAddPaddingGradient | |
| CGetAveragedLossGradient | |
| CGetBatchGatherGradient | |
| CGetBatchPermutationGradient | |
| CGetBatchToSpaceGradient | |
| CGetBernoulliJSDGradient | |
| CGetCastGradient | |
| CGetCol2ImGradient | |
| CGetConvGradient | |
| CGetConvTransposeGradient | |
| CGetCopyGradient | |
| CGetCosineSimilarityGradient | |
| CGetCPUToGPUGradient | |
| CGetCrossEntropyGradient | |
| CGetDotProductGradient | |
| CGetDotProductWithPaddingGradient | |
| CGetDropoutGradient | |
| CGetElementwiseLinearGradient | |
| CGetExpandDimsGradient | |
| CGetFCDecompGradient | |
| CGetFloatToHalfGradient | |
| CGetGPUToCPUGradient | |
| CGetGroupSpatialSoftmaxGradient | |
| CGetGRUUnitGradient | |
| CGetHalfToFloatGradient | |
| CGetIm2ColGradient | |
| CGetInstanceNormGradient | |
| CGetIntegralImageGradient | |
| CGetL1DistanceGradient | |
| CGetLabelCrossEntropyGradient | |
| CGetLeakyReluGradient | |
| CGetLRNGradient | |
| CGetLSTMUnitGradient | |
| CGetMakeTwoClassGradient | |
| CGetMatMulGradient | |
| CGetMeanGradient | |
| CGetNanCheckGradient | |
| CGetNegateGradientGradient | |
| CGetNormalizeGradient | |
| CGetPackSegmentsGradient | |
| CGetPadImageGradient | |
| CGetPoolGradient | |
| CGetPrependDimGradient | |
| CGetRecurrentGradient | |
| CGetRecurrentNetworkGradient | |
| CGetReduceBackMaxGradient | |
| CGetReduceBackSumGradient | |
| CGetReduceFrontMaxGradient | |
| CGetReduceFrontMeanGradient | |
| CGetReduceFrontSumGradient | |
| CGetRemovePaddingGradient | |
| CGetResizeNearestGradient | |
| CGetReversePackedSegsGradient | |
| CGetRoIPoolGradient | |
| CGetSampleAsGradient | |
| CGetScaleGradient | |
| CGetSelectSmoothL1LossGradient | |
| CGetSeluGradient | |
| CGetSigmoidCrossEntropyLossGradient | |
| CGetSigmoidCrossEntropyWithLogitsGradient | |
| CGetSigmoidFocalLossGradient | |
| CGetSmoothL1LossGradient | |
| CGetSoftmaxFocalLossGradient | |
| CGetSoftplusGradient | |
| CGetSpaceToBatchGradient | |
| CGetSquaredL2DistanceGradient | |
| CGetSquareRootDivideGradient | |
| CGetSqueezeGradient | |
| CGetSumElementsGradient | |
| CGetTopKGradient | |
| CGetTransposeGradient | |
| CGetUnpackSegmentsGradient | |
| CGetUpsampleBilinearGradient | |
| CGetUpsampleNearestGradient | |
| CGetWeightedSigmoidCrossEntropyWithLogitsGradient | |
| CGetZeroGradientOpGradient | |
| CGFtrlOp | |
| CGFtrlParams | |
| CGivenTensorByteStringToUInt8FillOp | |
| CGivenTensorFillOp | |
| CGlobalInitIsCalledGuard | |
| CGluOp | |
| CGPUFallbackOpEx | A templated class to allow one to wrap a CPU operator as a CUDA operator |
| CGradientMakerBase | |
| CGradientNotImplementedYet | A helper class to indicate that the gradient mechanism is not ready |
| CGradientOpsMeta | A struct that holds the gradient operators and related gradient maps |
| CGradientWrapper | |
| CGroupNormDNNLowPOp | |
| CGroupNormGradientOp | |
| CGroupNormOp | |
| CGroupSpatialSoftmaxGradientOp | |
| CGroupSpatialSoftmaxOp | |
| CGRUUnitGradientOp | |
| CGRUUnitOp | |
| CHalfToFloatOp | |
| CHardSigmoidFunctor | |
| CHardSigmoidGradientFunctor | |
| CHasElementsOp | |
| CHasScopeOp | |
| CHeatmapMaxKeypointOp | |
| CHillLearningRate | |
| CHistogramNetObserver | |
| ►CHistogramObserver | Given min/max, collect histogram |
| CInfo | |
| CHSoftmaxGradientOp | |
| CHSoftmaxOp | |
| CHSoftmaxOpBase | |
| CHSoftmaxSearchOp | |
| CHuffmanTreeHierarchyOp | |
| CIDEEPAdamOp | |
| CIDEEPConcatOp | |
| CIDEEPContext | |
| CIDEEPConvFusionOp | |
| CIDEEPConvGradientOp | |
| CIDEEPConvOp | |
| CIDEEPConvPoolOpBase | |
| CIDEEPConvTransposeGradientOp | |
| CIDEEPConvTransposeOp | |
| CIDEEPConvTransposeUnpoolBase | |
| CIDEEPCopyOp | |
| CIDEEPCreateBlobsQueueOp | |
| CIDEEPDropoutGradientOp | |
| CIDEEPDropoutOp | |
| CIDEEPExpandDimsOp | |
| CIDEEPFallbackOp | A templated class to allow one to wrap a CPU operator as an IDEEP operator |
| CIDEEPFullyConnectedGradientOp | |
| CIDEEPFullyConnectedOp | |
| CIDEEPLRNGradientOp | |
| CIDEEPLRNOp | |
| CIDEEPMomentumSGDOp | |
| CIDEEPMomentumSGDUpdateOp | |
| CIDEEPOperator | |
| CIDEEPPoolGradientOp | |
| CIDEEPPoolOp | |
| CIDEEPReluGradientOp | |
| CIDEEPReluOp | |
| CIDEEPReshapeOp | |
| CIDEEPSafeEnqueueBlobsOp | |
| CIDEEPShapeOp | |
| CIDEEPSigmoidGradientOp | |
| CIDEEPSigmoidOp | |
| CIDEEPSpatialBNGradientOp | |
| CIDEEPSpatialBNOp | |
| CIDEEPSplitOp | |
| CIDEEPSqueezeOp | |
| CIDEEPSumOp | |
| CIDEEPWeightedSumOp | |
| CIfOp | |
| CIm2ColOp | |
| CImageInputOp | |
| CIndex | |
| CIndexBase | |
| CIndexCreateOp | |
| CIndexDeserializer | |
| CIndexFreezeOp | |
| CIndexGetOp | |
| CIndexHashOp | |
| CIndexLoadOp | |
| CIndexSerializer | |
| CIndexSizeOp | |
| CIndexStoreOp | |
| CInitRegisterer | |
| CInstanceNormGradientOp | |
| CInstanceNormOp | |
| CInt8ConvDNNLowPPackedWeightBlob | Packed weight matrix for DNNLOWP Int8Conv operator |
| CInt8FCDNNLowPPackedWeightBlob | Packed weight matrix for DNNLOWP Int8FC operator |
| CIntegralImageGradientOp | |
| CIntegralImageOp | |
| CInvLearningRate | |
| CIsEmptyOp | |
| CIsMemberOfOp | |
| CIsMemberOfValueHolder | |
| CIsNanOp | |
| CIterOp | |
| CKeySplitOp | |
| CKeyValueToMapOp | |
| CL1DistanceGradientOp | |
| CL1DistanceOp | |
| CL1Reducer | |
| CL2Reducer | |
| CLabelCrossEntropyGradientOp | |
| CLabelCrossEntropyOp | |
| CLambdaRankNdcgGradientOp | |
| CLambdaRankNdcgOp | |
| CLarsOp | |
| CLayerNormGradientOp | |
| CLayerNormOp | |
| CLeakyReluGradientOp | |
| CLeakyReluOp | |
| CLearningRateAdaptionOp | |
| CLearningRateFunctor | |
| CLearningRateOp | |
| CLengthsGatherOp | |
| CLengthsOpGetGradient | |
| CLengthsPadOp | |
| CLengthsPartitionOp | |
| CLengthsRangeFillOp | |
| CLengthsSplitOp | |
| CLengthsTileOp | |
| CLengthsTopKGradientOp | |
| CLengthsTopKOp | |
| CLengthsToRangesOp | |
| CLengthsToSegmentIdsOp | |
| CLengthsToShapeOp | |
| CLengthsToWeightsOp | |
| CLinearWarmupLearningRate | |
| CLoadOp | |
| CLocallyConnectedGradientOp | |
| CLocallyConnectedOp | |
| CLogFatalOp | |
| CLogFunctor | |
| CLogitFunctor | |
| CLogitGradientOp | |
| CLogMeanExpRangeReducer | |
| CLogMeanExpRangeReducer< T, CPUContext > | |
| CLogMeanExpRangeReducerDef | |
| CLogMeanExpRangeReducerGradient | |
| CLogSumExpRangeReducer | |
| CLogSumExpRangeReducer< T, CPUContext > | |
| CLogSumExpRangeReducerDef | |
| CLogSumExpRangeReducerGradient | |
| CLpNormGradientOp | |
| CLpNormOp | |
| CLpPoolFunctor | |
| CLRNGradientOp | |
| CLRNOp | |
| CLRNOpBase | |
| CLSTMUnitDNNLowPOp | |
| CLSTMUnitGradientOp | |
| CLSTMUnitOp | |
| CMakeAligned | |
| CMakeTwoClassGradientOp | |
| CMakeTwoClassOp | |
| CMapDeserializer | |
| CMapSerializer | |
| CMapToKeyValueOp | |
| CMapTypeTraits | |
| CMarginRankingCriterionGradientOp | |
| CMarginRankingCriterionOp | |
| CMatMulOp | |
| CMaxGradientOp | |
| CMaxOp | |
| CMaxPoolFunctor | |
| CMaxPoolGradientRTCOp | |
| CMaxPoolRTCOp | |
| CMaxPoolWithIndexGradientOp | |
| CMaxPoolWithIndexOp | |
| CMaxRangeReducer | |
| CMaxRangeReducer< T, CPUContext > | |
| CMaxRangeReducerDef | |
| CMaxRangeReducerGradient | |
| CMaxReduceDimsGradientOp | |
| CMaxReduceDimsOp | |
| CMaxReducer | |
| CMaxReducer< T, CPUContext > | |
| CMaxReducerDef | |
| CMaxReducerGradient | |
| CMaxReductionGradientOp | |
| CMaxReductionOp | |
| CMeanGradientOp | |
| CMeanOp | |
| CMeanRangeReducer | |
| CMeanRangeReducer< T, CPUContext > | |
| CMeanRangeReducerDef | |
| CMeanRangeReducerGradient | |
| CMeanReducer | |
| CMeanReducer< T, CPUContext > | |
| CMeanReducerDef | |
| CMeanReducerGradient | |
| CMergeDimOp | |
| CMergeIdListsOp | |
| CMergeMultiListFeatureTensorsOp | |
| CMergeMultiListOrMapFeatureTensorsGradientOp | |
| CMergeMultiMapFeatureTensorsOp | |
| CMergeMultiScalarFeatureTensorsGradientOp | |
| CMergeMultiScalarFeatureTensorsOp | |
| CMergeSingleListFeatureTensorsOp | |
| CMergeSingleListOrMapFeatureTensorsGradientOp | |
| CMergeSingleMapFeatureTensorsOp | |
| CMergeSingleScalarFeatureTensorsGradientOp | |
| CMergeSingleScalarFeatureTensorsOp | |
| CMinGradientOp | |
| CMinOp | |
| CMinReducer | |
| CMIOPENActivationGradientOp | |
| CMIOPENActivationOp | |
| CMIOPENActivationOpBase | |
| CMIOPENState | |
| CmiopenTensorDescWrapper | MiopenTensorDescWrapper is the placeholder that wraps around a miopenTensorDescriptor_t, allowing us to do descriptor change as-needed during runtime |
| CmiopenTypeWrapper | MiopenTypeWrapper is a wrapper class that allows us to refer to the miopen type in a template function |
| CmiopenTypeWrapper< at::Half > | |
| CmiopenTypeWrapper< float > | |
| CMIOPENWorkspace | MIOPENWorkspace is a wrapper around a raw cuda pointer that holds the miopen scratch space |
| ►CMIOPENWrapper | MIOPENWrapper is a class that wraps the miopen handles and miopen workspaces |
| CSyncedMIOPENState | |
| CModOp | |
| CModuleSchema | A module schema that can be used to store specific information about different modules |
| CMomentsGradientOp | |
| CMomentsOp | |
| CMomentumSGDOp | |
| CMomentumSGDUpdateOp | |
| CMPICommonWorldWrapper | A simple wrapper over an MPI common world |
| CMPIDataTypeWrapper | |
| CMPSCNNContext | |
| CMSRAFillOp | |
| CMulDNNLowPOp | |
| CMulFunctor | |
| CMultiClassAccuracyOp | |
| CMutexDeserializer | |
| CMutexSerializer | |
| CNanCheckOp | |
| CNCHW2NHWCOp | |
| CNegateGradientOp | |
| CNegativeFunctor | |
| CNetBase | |
| CNetObserverReporter | |
| CNetObserverReporterPrint | |
| CNGramFromCategoricalOp | |
| CNHWC2NCHWOp | |
| CNNApi | |
| CNNPACKConvOp | |
| CNoDefaultEngineOp | A helper class to denote that an op does not have a default engine |
| CNoGradient | A helper class to indicate that the operator does not need gradient computation |
| CNormalizeGradientOp | |
| CNormalizeL1Op | |
| CNormalizeOp | |
| CNotFunctor | |
| CNumpyTileOp | |
| CObservable | Inherit to make your class observable |
| CObserverBase | Use this to implement a Observer using the Observer Pattern template |
| CObserverConfig | |
| COneHotOp | |
| COnnxifiOp | |
| COnnxifiTransformer | |
| COnnxifiTransformerOptions | |
| CONNXWhileOp | |
| COperator | |
| COperatorAttachingNetObserver | |
| COperatorBase | |
| ►COpSchema | A class to record the schema of an op |
| CArgument | |
| CCost | |
| COpSchemaRegistry | A registry to hold all the operator schemas |
| COpTask | Data structure for a scheduled task in the task queue |
| COptimizationPass | |
| COpWrapper | Wrap a floating-point operator with quantized inputs with type T |
| COutputMinMaxNetObserver | |
| ►COutputMinMaxObserver | |
| COperatorInfo | |
| CTensorInfo | |
| CPackedInt8BGRANHWCToNCHWCStylizerPreprocessOp | |
| CPackRNNSequenceOpBase | |
| CPackSegmentsOp | |
| CPadEmptySamplesOp | |
| CPadImageGradientOp | |
| CPadImageOp | |
| CPairWiseLossGradientOp | |
| CPairWiseLossOp | |
| CParallelNet | |
| CParallelNetExecutorHelper | |
| CParams | |
| CPartitionOp | |
| CPartitionOpBase | |
| CPatternNetTransform | PatternNetTransform allows you to create transforms using a simple interface |
| CPercentileOp | |
| CPerfNetObserver | |
| CPerfOperatorObserver | |
| CPerformanceInformation | |
| CPerplexityOp | |
| CPiecewiseLinearTransformOp | |
| CPolyLearningRate | |
| CPoolGradientOp | |
| CPoolOp | |
| CPowOp | |
| CPredictor | |
| CPredictorConfig | Stores parameters nessasary for creating a PredictorInterface object |
| CPrefetchOperator | |
| CPReluGradientOp | |
| CPReluOp | |
| CPrependDimOp | |
| CPrintOp | |
| CProfDAGCounters | A simple wrapper around prof_dag's counters |
| CProfDAGReport | |
| CProfDAGStats | |
| CProfileCounter | |
| CProfileObserver | |
| CProfileOperatorObserver | |
| CPSRoIPoolGradientOp | |
| CPSRoIPoolOp | |
| CQConvOp | |
| CQConvState | |
| CQTensor | |
| CQTensorDeserializer | |
| CQTensorSerializer | |
| CQuantDecodeGradientOp | |
| CQuantDecodeOp | |
| CQuantDecompZstdOp | |
| CQuantizeDNNLowPOp | |
| CRangeFillOp | |
| CRangeOp | |
| CRebatchingQueue | |
| CReciprocalFunctor | |
| CReciprocalGradientFunctor | |
| CRecurrentBaseOp | |
| CRecurrentGradientOp | |
| CRecurrentNetworkBlobFetcherOp | |
| CRecurrentNetworkExecutorBase | RecurrentNetworkExecutor is a specialized runtime for recurrent neural networks (RNNs) |
| CRecurrentNetworkGradientOp | |
| CRecurrentNetworkOp | |
| CRecurrentOp | |
| CRecurrentParamAccessOp | |
| CRedisStoreHandler | |
| CRedisStoreHandlerCreateOp | |
| CReduceGradientOp | |
| CReduceOp | |
| CReduceTailSumOp | |
| CRegisterQuantizationParamsNetObserver | Set quantization parameters of operators based on min/max collected from OutputMinMaxObserver |
| CRegisterQuantizationParamsWithHistogramNetObserver | Set quantization parameters of operators based on min/max collected from OutputMinMaxObserver |
| CReluDNNLowPOp | |
| CReluFunctor | |
| CReluGradientFunctor | |
| CReluNFunctor | |
| CReluNGradientFunctor | |
| CRemoveDataBlocksOp | |
| CRemovePaddingOp | |
| CReplaceNaNOp | |
| CResetCounterOp | |
| CReshapeOp | |
| CResizeLikeOp | |
| CResizeNearestDNNLowPOp | |
| CResizeNearestGradientOp | |
| CResizeNearestOp | |
| CRetrieveCountOp | |
| CReversePackedSegsOp | |
| CRMACRegionsOp | |
| CRmsPropOp | |
| CRNNApplyLinkOp | |
| CRNNNetOperator | Struct for operator in a timestep and its dependenceis |
| CRoIAlignGradientOp | |
| CRoIAlignOp | |
| CRoIAlignRotatedGradientOp | |
| CRoIAlignRotatedOp | |
| CRoIPoolFGradientOp | |
| CRoIPoolFOp | |
| CRoIPoolGradientOp | |
| CRoIPoolOp | |
| CRowMulOp | |
| CRowwise8BitQuantizedToFloatOp | |
| CRowWiseSparseAdagradOp | |
| CRowWiseSparseAdamOp | |
| CRsqrtFunctor | |
| CRsqrtGradientFunctor | |
| CRunCountNetObserver | |
| CRunCountOperatorObserver | |
| CSafeDequeueBlobsOp | |
| CSafeEnqueueBlobsOp | |
| CSameTypeAsInput | |
| CSampleAsGradientOp | |
| CSampleAsOp | |
| CSampleInterval | |
| CSaveOp | |
| CScaleOp | |
| CScatterAssignOp | Update slices of the tensor in-place by overriding |
| CScatterWeightedSumOp | Update slices of the tensor in-place with weighted sum |
| CSegmentIdsToLengthsOp | |
| CSegmentIdsToRangesOp | |
| CSegmentOneHotOp | |
| CSegmentOpGetGradient | |
| CSelectGradientOpBase | |
| CSelectSmoothL1LossGradientOp | |
| CSelectSmoothL1LossOp | |
| CSeluGradientOp | |
| CSeluOp | |
| CSequenceMaskOp | |
| CShapeInfo | |
| CShapeOp | |
| CSigmoidCrossEntropyLossGradientOp | |
| CSigmoidCrossEntropyLossOp | |
| CSigmoidCrossEntropyWithLogitsGradientOp | |
| CSigmoidCrossEntropyWithLogitsOp | |
| CSigmoidFocalLossGradientOp | |
| CSigmoidFocalLossOp | |
| CSigmoidFunctor | |
| CSigmoidGradientFunctor | |
| CSignalHandler | |
| CSignFunctor | |
| CSimpleArray | |
| CSimpleNet | |
| CSimpleQueue | |
| CSimpleRefCountNet | |
| CSinFunctor | |
| CSingleOpTransform | Single Op Transform Base class |
| CSinGradientFunctor | |
| CSinhFunctor | |
| CSinhGradientFunctor | |
| CSinusoidPositionEncodingOp | |
| CSizeOp | |
| CSkipIndices | |
| CSkipIndices<> | |
| CSliceGradientOp | |
| CSliceOp | |
| CSmartTensorPrinter | |
| CSmoothL1LossGradientOp | |
| CSmoothL1LossOp | |
| CSNPEOp | |
| CSoftmaxFocalLossGradientOp | |
| CSoftmaxFocalLossOp | |
| CSoftmaxGradientOp | |
| CSoftmaxOp | |
| CSoftmaxWithLossGradientOp | |
| CSoftmaxWithLossOp | |
| CSoftplusGradientOp | |
| CSoftplusOp | |
| CSoftsignFunctor | |
| CSoftsignGradientFunctor | |
| CSpaceBatchOpBase | |
| CSpaceToBatchOp | |
| CSparseAdadeltaOp | |
| CSparseAdagradOp | |
| CSparseAdamOp | |
| CSparseFtrlOp | |
| CSparseFunHashGradientOp | |
| CSparseFunHashOp | |
| CSparseLengths8BitsRowwiseOp | |
| CSparseLengthsFused8BitRowwiseOp | |
| CSparseMatrixReshapeOp | |
| CSparseMomentumSGDUpdateOp | |
| CSparseNormalizeOp | |
| CSparseToDenseMaskBase | |
| CSparseToDenseMaskGradientOp | |
| CSparseToDenseMaskOp | |
| CSparseToDenseOp | |
| CSparseWngradOp | |
| CSpatialBNDNNLowPOp | Note this implementation assumes SCALE, BIAS, EST_MEAN, and EST_VAR inputs are still in fp32, so is epsilon argument |
| CSpatialBNGradientOp | |
| CSpatialBNOp | |
| CSpatialNarrowAsGradient | |
| CSpatialNarrowAsGradientOp | |
| CSpatialNarrowAsOp | |
| CSpatialSoftmaxWithLossGradientOp | |
| CSpatialSoftmaxWithLossOp | |
| CSplitByLengthsOp | |
| CSplitOp | |
| CSqrFunctor | |
| CSqrtFunctor | |
| CSquaredL2DistanceGradientOp | |
| CSquaredL2DistanceOp | |
| CSquareRootDivideOp | |
| CSqueezeOp | |
| CStat | |
| CStaticLinkingProtector | |
| CStaticStat | |
| CStatRegistry | Holds a map of atomic counters keyed by name |
| CStatRegistryCreateOp | |
| CStatRegistryExportOp | |
| CStatRegistryUpdateOp | |
| CStatValue | |
| CStdDevExportedStat | |
| CStepLearningRate | |
| CStopGradientOp | |
| CStopOnSignal | |
| CStoreAddOp | |
| CStoreGetOp | |
| CStoreHandler | |
| CStoreHandlerNotAvailableException | |
| CStoreHandlerTimeoutException | |
| CStoreSetOp | |
| CStoreWaitOp | |
| CStringDeserializer | StringDeserializer is the deserializer for Strings |
| CStringJoinOp | |
| CStringProvider | |
| CStringSerializer | StringSerializer is the serializer for String |
| CStumpFuncIndexOp | |
| CStumpFuncOp | |
| CSubFunctor | |
| CSumDNNLowPOp | |
| CSumElementsGradientOp | |
| CSumElementsIntOp | |
| CSumElementsOp | |
| CSummarizeOp | |
| CSumOp | |
| CSumRangeReducer | |
| CSumRangeReducer< T, CPUContext > | |
| CSumRangeReducerDef | |
| CSumRangeReducerGradient | |
| CSumReduceDimsGradientOp | |
| CSumReduceDimsOp | |
| CSumReduceLikeOp | |
| CSumReducer | |
| CSumReducer< T, CPUContext > | |
| CSumReducerDef | |
| CSumReducerGradient | |
| CSumReluOp | |
| CSumSqrElementsOp | |
| CSwishFunctor | |
| CSwishGradientOp | |
| CTanFunctor | |
| CTanGradientFunctor | |
| CTanhFunctor | |
| CTanhGradientFunctor | |
| CTask | |
| CTemplatePutOp | |
| CTensor | Tensor class holds a shared pointer to the implementation TensorImpl, redirects API calls to TensorImpl; Copying of Tensor results in sharing the same underlying implementation object |
| CTensorDeserializer | TensorDeserializer is the deserializer for Tensors |
| CTensorFiller | |
| CTensorPrinter | |
| CTensorProtosDBInput | |
| CTensorSerializer | TensorSerializer is the serializer for Tensors |
| CTensorTypes | |
| CTensorTypes2 | |
| CTextFileReaderInstance | |
| CTextFileReaderReadOp | |
| CThreadedRecurrentNetworkExecutor | |
| CThreadLocalCUDAObjects | A struct to host thread-local cuda objects |
| CThreadPool | |
| CThresholdedReluGradientOp | |
| CThresholdedReluOp | |
| CThrowChildThreadExceptionOp | |
| CThrowExceptionOp | |
| CThrowInTheTowelIfGradientIsCalled | A helper class to indicate that the operator should have no gradient |
| CTileGradientOp | |
| CTileOp | |
| CTimeCounter | |
| CTimeObserver | |
| CTimeOperatorObserver | |
| CTimer | A simple timer object for measuring time |
| CTimerBeginOp | |
| CTimerEndOp | |
| CTimerGetAndEndOp | |
| CTimerGetOp | |
| CTimerInstance | |
| CToken | |
| CTokenizedString | |
| CTokenizer | |
| CTopKGradientOp | |
| CTopKOp | |
| CTransform | The Transform Base Object |
| CTransposeOp | |
| CTTContractionGradientOp | |
| CTTContractionOp | |
| CTTLinearGradientOp | |
| CTTLinearOp | |
| CTTPadGradientOp | |
| CTTPadOp | |
| CTypeIdentifier | A type id is a unique id for a given C++ type |
| CTypeMeta | TypeMeta is a thin class that allows us to store the type of a container such as a blob, or the data type of a tensor, with a unique run-time id |
| CTypeNameTraits | |
| CTypeNameTraits< int32_t > | |
| CTypeNameTraits< int64_t > | |
| CUnaryElementwiseWithArgsDNNLowPOp | |
| CUnaryElementwiseWithArgsOp | |
| CUnaryFunctorWithDefaultCtor | |
| CUniformFillOp | |
| CUniqueOp | Deduplicates input indices vector and optionally produces reverse remapping |
| CUniqueUniformFillOp | |
| CUnpackSegmentsOp | |
| CUnsupportedOperatorFeature | |
| CUpsampleBilinearGradientOp | |
| CUpsampleBilinearOp | |
| CUpsampleNearestGradientOp | |
| CUpsampleNearestOp | |
| CVariableLengthSequencePaddingOp | |
| CVideoDecoder | |
| CVideoInputOp | |
| CVideoIOContext | |
| CVideoMeta | |
| CWallClockTimeOp | |
| CWeightedMultiSamplingOp | |
| CWeightedSampleDequeueBlobsOp | |
| CWeightedSampleOp | |
| CWeightedSigmoidCrossEntropyWithLogitsGradientOp | |
| CWeightedSigmoidCrossEntropyWithLogitsOp | |
| CWeightedSumGradientOp | |
| CWeightedSumOp | |
| CWeightedSumReducer | |
| ►CWeightedSumReducer< T, CPUContext > | |
| CMeta | |
| CWeightedSumReducerDef | |
| ►CWeightedSumReducerGradient | |
| CMeta | |
| CWhereOp | |
| CWhileOp | |
| CWngradOp | |
| CWorker | |
| CWorkersPool | |
| CWorkspace | Workspace is a class that holds all the related objects created during runtime: (1) all blobs, and (2) all instantiated networks |
| CWorkspaceOptimizationPass | |
| CXavierFillOp | |
| CYellowFinOp | |
| CZeroGradientOp | |
| CZmqContext | |
| CZmqMessage | |
| CZmqSocket | |
| ►Ndnnlowp | |
| CDynamicHistogram | An equi-width histogram where the spread of bins change over time when we see new min or max values |
| CHistogram | Bin_width = (max - min)/nbins ith bin (zero-based indexing) contains [i*bin_width, (i+1)*bin_width) with an exception that (nbins - 1)th bin contains [(nbins-1)*bin_width, nbins*bin_width] |
| CKLDivergenceMinimization | A quantization scheme that minimizes Kullback-Leiber divergence |
| CL1ErrorMinimization | |
| CL2ErrorMinimization | A quantization scheme that minimizes L2 norm of quantization error |
| CNormMinimization | |
| CP99 | |
| CQuantizationErrorMinimization | |
| CQuantizationErrorStats | |
| CQuantizationFactory | |
| CSigmoid | Sigmoid(x) = (tanh(x/2) + 1)/2 Quantized sigmoid is computed as tanh under the hood, we just use different input/output quantization parameters |
| CTanh | We use the 3-region approach described in "Efficient VLSI Implementation of
Neural Networks with Hyperbolic Tangent Activation Function", IEEE Transactions on Very Large Scale Integration Systems, Zamanlooy and Mirhassani |
| ►Nnom | |
| ►Nalgorithm | |
| ►CGraphWrapper | |
| CEdgeWrapper | |
| CNodeWrapper | |
| CTarjans | Tarjans algorithm implementation |
| ►CTopoSort | Topological sort using DFS |
| CResult | |
| ►Nconverters | |
| CDotGenerator | |
| ►Nmatcher | |
| CDataFlowTestGraph | |
| CDataFlowTestGraphCriteria | |
| CMatchGraph | |
| CMatchPredicate | MatchGraph is a graph of MatchPredicate |
| CSubgraphMatchResult | |
| ►Nrepr | |
| ►Nnn | |
| Cget_impl | |
| Cget_impl< T, N, enable_if_t< inheritedFrom< T, NeuralNetData >::value > > | |
| Cget_impl< T, N, enable_if_t< inheritedFrom< T, NeuralNetOperator >::value > > | |
| CinheritedFrom | |
| Cis_impl | |
| Cis_impl< T, N, enable_if_t< inheritedFrom< T, NeuralNetData >::value > > | |
| Cis_impl< T, N, enable_if_t< inheritedFrom< T, NeuralNetOperator >::value > > | |
| CNodeHelper | |
| CAnnotation | Annotations allow for generic manipulation of neural network operations |
| CBasicBlock | A basic block holds a reference to a subgraph of the data flow graph as well as an ordering on instruction execution |
| CBranch | |
| CControlFlowGraph | Control flow graph is a graph of basic blocks that can be used as an analysis tool |
| CControlFlowGraphImpl | |
| CControlFlowGraphImpl< Graph< T, U... > > | |
| CData | |
| CGenericOperator | |
| CInstruction | |
| CNeuralNetData | |
| CNeuralNetOperator | |
| CNNModule | |
| CNNPhi | |
| CPhi | |
| CReturn | |
| CTensor | |
| CTerminator | |
| CValue | |
| CWhile | |
| CEdge | |
| CGraph | A simple graph implementation |
| CMatch | |
| CNode | |
| CNodeEqualityDefault | |
| CSubgraph | Effectively a constant reference to a graph |
| ►NONNX_NAMESPACE | |
| COpSet_PyTorch_ver1 | |
| ►Nordering_test | |
| CDataset | |
| ►Npybind11 | |
| ►Ndetail | |
| Ctype_caster< at::IntArrayRef > | |
| Ctype_caster< at::Tensor > | |
| Ctype_caster< c10::optional< T > > | |
| Ctype_caster< std::shared_ptr< torch::autograd::Function > > | |
| Ctype_caster< std::vector< torch::jit::Node * > > | |
| Ctype_caster< torch::autograd::Variable > | |
| Ctype_caster< torch::jit::AttributeKind > | |
| Ctype_caster< torch::jit::IValue > | |
| Ctype_caster< torch::jit::Symbol > | |
| ►Nska | |
| ►Ndetailv3 | |
| CAssignIfTrue | |
| CAssignIfTrue< T, false > | |
| Cfunctor_storage | |
| Cfunctor_storage< Result, Result(*)(Args...)> | |
| CHashPolicySelector | |
| CHashPolicySelector< T, void_t< typename T::hash_policy > > | |
| CKeyOrValueEquality | |
| CKeyOrValueHasher | |
| Cmake_void | |
| Csherwood_v3_entry | |
| ►Csherwood_v3_table | |
| Cconvertible_to_iterator | |
| Ctemplated_iterator | |
| Cfibonacci_hash_policy | |
| Cflat_hash_map | |
| Cflat_hash_set | |
| Cpower_of_two_hash_policy | |
| Cpower_of_two_std_hash | |
| Cprime_number_hash_policy | |
| ►Nstd | |
| Chash< c10::cuda::CUDAStream > | |
| Chash< c10::Device > | |
| Chash< c10::DeviceType > | |
| Chash< c10::hip::HIPStreamMasqueradingAsCUDA > | |
| Chash< c10::intrusive_ptr< TTarget, NullType > > | |
| Chash< c10::optional< T & > > | |
| Chash< c10::optional< T > > | |
| Chash< c10::Stream > | |
| Chash< c10::Symbol > | |
| Chash< c10::weak_intrusive_ptr< TTarget, NullType > > | |
| Chash< caffe2::DeviceOption > | |
| Chash< caffe2::onnx::DeviceType > | |
| Chash< test_is_hashable::Hashable > | |
| Chash< torch::autograd::Edge > | |
| Chash< torch::jit::ArgumentSpec > | |
| Chash< torch::jit::CompleteArgumentSpec > | |
| Cis_fundamental< at::Half > | |
| Citerator_traits< torch::jit::generic_graph_node_list_iterator< T > > | |
| Citerator_traits< torch::jit::script::ListIterator< T > > | |
| Cnumeric_limits< c10::Half > | |
| ►Ntest | |
| CAGIUnit | |
| CAGIUnit2 | |
| ►Ntest_concat | |
| CMyClass | |
| ►Ntest_count_if | |
| CMyClass | |
| ►Ntest_filter | |
| CMyClass | |
| ►Ntest_from_tuple | |
| CMyClass | |
| ►Ntest_head | |
| CMyClass | |
| ►Ntest_map | |
| CMyClass | |
| ►Ntest_map_types_to_values | |
| CClass1 | |
| CClass2 | |
| Cmap_make_shared | |
| Cmap_to_size | |
| Cmapper_call_func | |
| Cmapper_call_nonexistent_function | |
| ►Ntest_reverse | |
| CMyClass | |
| ►Ntest_size | |
| CMyClass | |
| ►Ntest_to_tuple | |
| CMyClass | |
| ►Ntest_true_for_each_type | |
| CMyClass | |
| CTest | |
| ►Ntorch | |
| ►Nautograd | |
| ►Ngenerated | |
| CTypeAndSize | |
| ►Nprofiler | |
| CCUDAStubs | |
| CEvent | |
| CRangeEventList | |
| CRecordFunction | |
| CRecordProfile | |
| ►Npython | |
| CPythonEngine | |
| CAccumulateGrad | |
| CAnomalyMetadata | |
| CAnomalyMode | |
| CAutoGradMode | |
| CClearCallbacks | |
| CCompareFunctionTaskTime | |
| CComputeRequiresGrad | |
| CCopyBackwards | |
| CCopySlices | |
| CDefaultFunctionType | |
| CDelayedError | |
| CEdge | Represents a particular input of a function |
| CEngine | |
| CError | |
| CFlatten | |
| CFunctionPostHook | |
| CFunctionPreHook | |
| CFunctionTask | |
| CGather | |
| CGradMode | |
| CGraphRoot | |
| ►CGraphTask | |
| ►CExecInfo | |
| CCapture | |
| CInputBuffer | |
| CInputMetadata | A tensor's type and shape |
| CNotImplemented | |
| CPyAnomalyMetadata | |
| CPyFunction | |
| CPyFunctionPostHook | |
| CPyFunctionPreHook | |
| CReadyQueue | |
| CSavedVariable | A snapshot of a variable at a certain version |
| CScatter | |
| Csymbolic_unconvertible | |
| CSymbolicContext | |
| CTHPCppFunction | |
| CVariable | A Variable augments a Tensor with the ability to interact in our autograd machinery |
| CVariableHooks | |
| CVariableInfo | |
| CVariableType | |
| CVariableTypeRegistry | |
| CVariableVersion | |
| ►Ncuda | |
| ►Nnccl | |
| ►Ndetail | |
| CAutoNcclGroup | |
| CNcclCommList | |
| Cunique_type_checker | |
| ►Ndata | |
| ►Ndatasets | |
| ►Ndetail | |
| ►CBatchDataBuffer | BatchDataBuffer manages a queue of UnwrappedBatchData |
| CUnwrappedBatchData | Struct that contains a raw unwrapped batch unit |
| Cis_optional | |
| Cis_optional< optional< T > > | |
| CBatchDataset | A dataset that can yield data only in batches |
| CChunkDataReader | Interface for chunk reader, which performs data chunking and reading of entire chunks |
| CChunkDataset | A stateful dataset that support hierarchical sampling and prefetching of entre chunks |
| CChunkDatasetOptions | Options to configure a ChunkDataset |
| CDataset | A dataset that can yield data in batches, or as individual examples |
| CMapDataset | A MapDataset is a dataset that applies a transform to a source dataset |
| CMNIST | The MNIST dataset |
| CSharedBatchDataset | A dataset that wraps another dataset in a shared pointer and implements the BatchDataset API, delegating all calls to the shared instance |
| CStatefulDataset | A stateful dataset is a dataset that maintains some internal state, which will be reset() at the beginning of each epoch |
| CTensorDataset | A dataset of tensors |
| ►Ndetail | |
| ►Nsequencers | |
| CNoSequencer | A Sequencer that does not enforce any ordering |
| COrderedSequencer | A Sequencer that buffers results and returns them in order of their sequence number |
| CSequencer | A Sequencer accepts a function that yields the next result of a DataLoader and then has the opportunity to influence the order in which these results are returned |
| CDataShuttle | Encapsulates the full life cycle of DataLoader jobs |
| CIteratorImpl | Base class for the ValidIterator and SentinelIterator |
| CQueue | A basic locked, blocking MPMC queue |
| CSentinelIterator | |
| CValidIterator | |
| ►Nsamplers | |
| CBatchSize | A wrapper around a batch size value, which implements the CustomBatchRequest interface |
| CCustomBatchRequest | A base class for custom index types |
| CDistributedRandomSampler | Select samples randomly |
| CDistributedSampler | A Sampler that selects a subset of indices to sample from and defines a sampling behavior |
| CDistributedSequentialSampler | Select samples sequentially |
| CRandomSampler | A Sampler that returns random indices |
| CSampler | A Sampler is an object that yields an index with which to access a dataset |
| CSequentialSampler | A Sampler that returns indices sequentially |
| CStreamSampler | A sampler for (potentially infinite) streams of data |
| ►Ntransforms | |
| CBatchLambda | A BatchTransform that applies a user-provided functor to a batch |
| CBatchTransform | A transformation of a batch to a new batch |
| CLambda | |
| CNormalize | Normalizes input tensors by subtracting the supplied mean and dividing by the given standard deviation |
| CStack | |
| CStack< Example<> > | A Collation for Example<Tensor, Tensor> types that stacks all data tensors into one tensor, and all target (label) tensors into one tensor |
| CStack< TensorExample > | A Collation for Example<Tensor, NoTarget> types that stacks all data tensors into one tensor |
| CTensorLambda | A Lambda specialized for the typical Example<Tensor, Tensor> input type |
| CTensorTransform | A Transform that is specialized for the typical Example<Tensor, Tensor> combination |
| CTransform | A transformation of individual input examples to individual output examples |
| ►CDataLoaderBase | |
| CJob | A Job is either a BatchRequest (new indices to fetch data at) or a QuitWorker object, to indicate the worker should shut down |
| CQuitWorker | |
| CResult | The finished result of a job |
| CSequenced | Simple mix-in to give something a sequence number |
| CDataLoaderOptions | Options to configure a DataLoader |
| CExample | An Example from a dataset |
| CExample< Data, example::NoTarget > | A specialization for Example that does not have have a target |
| CFullDataLoaderOptions | Like DataLoaderOptions, but without any unconfigured state |
| CIterator | |
| CStatefulDataLoader | A dataloader for stateful datasets |
| CStatelessDataLoader | A dataloader for stateless datasets |
| CWorkerException | An exception thrown when a DataLoader's worker thread throws an exception, which is caught |
| ►Ndetail | |
| Chas_forward | Detects if a type T has a forward() method |
| Cis_module_holder_of | |
| Cis_module_holder_of_impl | |
| Cis_module_holder_of_impl< false, T, C > | |
| Cis_module_holder_of_impl< true, T, C > | |
| CModuleHolderIndicator | |
| Cpack | |
| Creturn_type_of_forward_impl | |
| Creturn_type_of_forward_impl< false, C, Args... > | |
| Creturn_type_of_forward_impl< true, C, Args... > | |
| ►Njit | |
| ►Ndetail | |
| CDynamicDAG | |
| CIOEdges | |
| CVertex | |
| Cvertex_set | |
| Cvisited_list | |
| ►Nfuser | |
| ►Ncpu | |
| CCompilerConfig | |
| CDynamicLibrary | |
| CFusedKernelCPU | |
| CTempFile | |
| ►Ncuda | |
| CFusedKernelCUDA | |
| CArgSpec | |
| CFusedKernel | |
| CKernelCacheImpl | |
| CKernelSpec | |
| COutputMapAndSize | |
| CPartitionDesc | |
| CPartitionInfo | |
| CRegisterFusionBackend | |
| CTensorDesc | |
| CTensorInfo | |
| ►Npython | |
| ►CIODescriptor | |
| CVariableMetadata | |
| CParsedArgs | |
| ►Nscript | |
| CAnnotateValue | |
| CApply | |
| CAssert | |
| CAssign | |
| CAttribute | |
| CAugAssign | |
| CAugAssignKind | |
| CBinOp | |
| CBooleanDispatchValue | |
| CBoolInfo | |
| CBuiltinFunction | |
| CBuiltinFunctionRegistry | |
| CBuiltinModule | |
| CCastValue | |
| CClassDef | |
| CClassNewMethod | |
| CClassValue | |
| CCompound | |
| CConst | |
| CConstantParameterList | |
| CConstantPythonTupleValue | |
| CConstantTableValue | |
| CConstantValue | |
| CDecl | |
| CDef | |
| CDefContext | |
| CDictLiteral | |
| CEnvironment | |
| CErrorReport | |
| CExpr | |
| CExprStmt | |
| CFor | |
| CForkValue | |
| CGetAttrValue | |
| CGlobal | |
| CIdent | |
| CIf | |
| CIRParser | |
| CIsInstanceValue | |
| CLexer | |
| CList | |
| CListIterator | |
| CListLiteral | |
| CMatchedSchema | |
| CMaybe | |
| CMethod | |
| CMethodValue | |
| CModule | |
| CModuleAccessorValue | |
| CModuleValue | |
| CNamedIValue | |
| CNamedModule | |
| CNoneValue | |
| COpsValue | |
| COverloadedFunctionValue | |
| CParam | |
| CParsedLiteral | |
| CParser | |
| CParserImpl | |
| CPass | |
| Cpretty_tree | |
| CPrintValue | |
| CPythonModuleValue | |
| CPythonValue | |
| CRaise | |
| CRecursiveMethodCallError | |
| CRefinements | |
| CReturn | |
| CReturnInfo | |
| CSchemaParser | |
| CSchemaTypeParser | |
| CSelect | |
| CSelf | |
| CSharedParserData | |
| CSimpleValue | |
| CSliceExpr | |
| CSourceImporter | |
| CSourceRangeFactory | |
| CStarred | |
| CStmt | |
| CString | |
| CStringLiteral | |
| CSubscript | |
| CSugaredValue | |
| CTernaryIf | |
| Cto_ir | |
| CToken | |
| CTokenTrie | |
| CTree | |
| CTreeView | |
| CTupleLiteral | |
| CUnaryOp | |
| CVar | |
| CVarWithType | |
| CWhile | |
| ►Ntest | |
| CADTestSpec | |
| ►Ntesting | |
| CCheck | |
| CFileCheck | |
| CFileCheckImpl | |
| ►Ntracer | |
| ►CArgumentStash | |
| CIntArrayRefTrace | |
| CNoWarn | |
| ►CTracingState | |
| CTracingEnvironmentFrame | |
| CWeakTensorEq | |
| CWeakTensorHasher | |
| CWithNestedTracingFrame | |
| ►CAliasDb | Alias analysis pass |
| CWorkingSet | |
| CArgumentInfo | |
| CArgumentSpec | |
| CAttributeError | |
| CAttributeValue | |
| CBatchTensor | |
| CBlock | |
| CChunkOutput | |
| CCode | |
| CCodeImpl | |
| CCodeTemplate | |
| CCompleteArgumentInfo | |
| CCompleteArgumentInfoPOD | |
| CCompleteArgumentSpec | |
| CConcretePythonOp | |
| Cconst_value_list_with_types | |
| Cconstant_not_supported_error | |
| CContainerTensor | |
| CDeadCodeEliminator | |
| CElement | |
| CEqualNode | |
| CExecutionPlanState | |
| Cgeneric_graph_node_list | |
| Cgeneric_graph_node_list_iterator | |
| CGradient | |
| CGradientPair | |
| CGraph | |
| CGraphAttr | |
| CGraphExecutor | |
| CGraphExecutorImpl | |
| CGraphExecutorState | |
| CGraphsAttr | |
| CHashNode | |
| CIfView | |
| CInstruction | |
| CInterpreterContinuation | |
| CInterpreterState | |
| CInterpreterStateImpl | |
| CIValuePairComparator | |
| CJITException | |
| CListHandle | |
| CLoopView | |
| CMemoryDAG | |
| CNamedValue | |
| CNode | |
| COperator | |
| COperatorSet | |
| CPickler | |
| CPreprocessGraph | |
| Cpropagation_error | |
| CPythonOp | |
| CPythonPrintPass | |
| CQualifiedName | |
| CRegisterOperators | Registration class for new operators |
| CResourceGuard | |
| CReverseDetails | |
| CScalarAttributeValue | |
| CScope | |
| CSourceLocation | |
| CSourceRange | |
| CStringSourceLocation | |
| CSuspend | |
| CSymbolicVariable | |
| CTemplateEnv | |
| CToBatch | |
| CTopoMoveTestFixture | |
| CTreeToken | |
| Ctuple_slice | |
| CTuplePacker | |
| CTuplePacker< 0, Args... > | |
| CUnpickler | |
| CUse | |
| CUseList | |
| CValue | |
| Cvariable_tensor_list | |
| CVectorAttributeValue | |
| CWithCurrentScope | An utility class for setting temporary scopes |
| CWithInsertPoint | An utility class for setting temporary insertion points |
| ►Nnn | |
| ►Ndetail | |
| CDropoutImplBase | |
| CRNNImplBase | Base class for all RNN implementations (intended for code sharing) |
| CRNNOptionsBase | Common options for LSTM and GRU modules |
| ►CAnyModule | Stores a type erased Module |
| CPlaceholder | |
| CValue | A simplified implementation of std::any which stores a type erased object, whose concrete value can be retrieved at runtime by checking if the typeid() of a requested type matches the typeid() of the object stored |
| CBatchNormImpl | Applies Batch Normalization to an input |
| CBatchNormOptions | Options for the BatchNorm module |
| CCloneable | The clone() method in the base Module class does not have knowledge of the concrete runtime type of its subclasses |
| CConv1dImpl | Applies convolution over a 1-D input |
| CConv2dImpl | Applies convolution over a 2-D input |
| CConv3dImpl | Applies convolution over a 3-D input |
| CConvImpl | Base class for all (dimension-specialized) convolution modules |
| CConvOptions | Options for a D-dimensional convolution module |
| CDropoutImpl | Applies Dropout during training |
| CDropoutOptions | Options for Dropout and FeatureDropout |
| CEmbeddingImpl | Performs a lookup in a fixed size embedding table |
| CEmbeddingOptions | Options for the Embedding module |
| CFeatureDropoutImpl | Applies spatial Dropout to inputs with 2-D or 3-D features |
| CGRUImpl | A multi-layer gated recurrent unit (GRU) module |
| CLinearImpl | Applies a linear transformation with optional bias |
| CLinearOptions | Options for the Linear module |
| CLSTMImpl | A multi-layer long-short-term-memory (LSTM) module |
| CModule | The base class for all modules in PyTorch |
| CModuleHolder | A ModuleHolder is essentially a wrapper around std::shared_ptr<M> where M is an nn::Module subclass, with convenient constructors defined for the kind of constructions we want to allow for our modules |
| CRNNImpl | A multi-layer Elman RNN module with Tanh or ReLU activation |
| CRNNOptions | Options for RNN modules |
| CRNNOutput | The output of a single invocation of an RNN module's forward() method |
| CSequentialImpl | A list of Modules that acts as a Module itself |
| CTestValue | |
| ►Noptim | |
| ►Ndetail | |
| COptimizerBase | Base class for all optimizers, that does not yet define a step() mechanism |
| CAdagrad | |
| CAdagradOptions | |
| CAdam | |
| CAdamOptions | |
| CLBFGS | |
| CLBFGSOptions | |
| CLossClosureOptimizer | Optimizer that requires the loss function to be supplied to the step() function, as it may evaluate the loss function multiple times per step |
| COptimizer | Optimizer that defines a required step() method that takes no arguments and produces no values |
| CRMSprop | |
| CRMSpropOptions | |
| CSGD | |
| CSGDOptions | |
| ►Nserialize | |
| CInputArchive | A recursive representation of tensors that can be deserialized from a file or stream |
| COutputArchive | |
| ►Ntensors | |
| CPyTensorType | |
| ►Ntest | |
| CSeedingFixture | |
| CSimpleContainer | |
| ►Nutils | |
| CStridedData | |
| CTensorGroup | |
| Call_of | |
| Cany_of | |
| Cany_of< head, tail... > | |
| Cany_of<> | |
| CCountTensors | |
| CCountVariables | |
| CExpandingArray | A utility class that accepts either a container of D-many values, or a single value, which is internally repeated D times |
| CFunctionParameter | |
| CFunctionSignature | |
| Chash | |
| ►Chash< std::tuple< Types... > > | |
| Ctuple_hash | |
| Ctuple_hash< 0, Ts... > | |
| Chash< std::vector< T > > | |
| CIndexError | |
| CIndices | |
| CIterArgs | |
| CMakeIndices | |
| CMakeIndices< 0, Is... > | |
| CNoGradGuard | |
| Cnone_of | |
| ►COrderedDict | An ordered dictionary implementation, akin to Python's OrderedDict |
| CItem | |
| CParsedArgs | |
| CPythonArgParser | |
| CPythonArgs | |
| CPyTorchError | |
| CTHPVoidStorage | |
| CTHPVoidTensor | |
| CTupleParser | |
| CTypeError | |
| Cunique_type_for | |
| Cunique_type_for< T[]> | |
| Cunique_type_for< T[N]> | |
| CValueError | |
| C_cl_buffer_region | |
| C_cl_image_desc | |
| C_cl_image_format | |
| CA | |
| CA | Does bound shape inference given a C2 net |
| CAdd | |
| Cadd_const_past_pointer | If T is a pointer to X, return a pointer to const X |
| Cadd_lvalue_reference_if_not_pointer | If T is a pointer, just return it. If it is not, return T& |
| CAGIUnit | |
| CAImpl | |
| CAllgatherNCCLTest | |
| CAllocInfo | |
| CAllreduceNCCLTest | |
| CANeuralNetworksOperandType | ANeuralNetworksOperandType describes the type of an operand |
| CAnyModuleTest | |
| CAnyValueTest | |
| CAsyncAllreduceTest | |
| CAsyncBroadcastTest | |
| CAsyncInputIsOutputTest | |
| CAsyncTest | |
| CAutoGIL | |
| CAutogradTest | |
| CAutoNoGIL | |
| CAveragePool | |
| CAveragePoolRelu | |
| CB | |
| CBarrier | |
| CBatchNormalization | |
| Cbinary_function_traits | |
| CBroadcastNCCLTest | |
| CBufferTestModule | |
| CC | |
| CCaffe2IOSPredictor | |
| Ccall_duplicate_guard | |
| CCartPole | |
| Ccast_convert_val | |
| Ccast_convert_val< To, FromTy, FromTy > | |
| Ccast_retty | |
| Ccast_retty_impl | |
| Ccast_retty_impl< To, const From * > | |
| Ccast_retty_impl< To, const From *const > | |
| Ccast_retty_impl< To, const From > | |
| Ccast_retty_impl< To, From * > | |
| Ccast_retty_impl< To, std::unique_ptr< From > > | |
| Ccast_retty_wrap | |
| Ccast_retty_wrap< To, FromTy, FromTy > | |
| CChannelShuffle | |
| Ccl_char16 | |
| Ccl_char2 | |
| Ccl_char4 | |
| Ccl_char8 | |
| Ccl_double16 | |
| Ccl_double2 | |
| Ccl_double4 | |
| Ccl_double8 | |
| Ccl_float16 | |
| Ccl_float2 | |
| Ccl_float4 | |
| Ccl_float8 | |
| Ccl_int16 | |
| Ccl_int2 | |
| Ccl_int4 | |
| Ccl_int8 | |
| Ccl_long16 | |
| Ccl_long2 | |
| Ccl_long4 | |
| Ccl_long8 | |
| Ccl_short16 | |
| Ccl_short2 | |
| Ccl_short4 | |
| Ccl_short8 | |
| Ccl_uchar16 | |
| Ccl_uchar2 | |
| Ccl_uchar4 | |
| Ccl_uchar8 | |
| Ccl_uint16 | |
| Ccl_uint2 | |
| Ccl_uint4 | |
| Ccl_uint8 | |
| Ccl_ulong16 | |
| Ccl_ulong2 | |
| Ccl_ulong4 | |
| Ccl_ulong8 | |
| Ccl_ushort16 | |
| Ccl_ushort2 | |
| Ccl_ushort4 | |
| Ccl_ushort8 | |
| CClientSession | |
| CClientSocket | |
| CClip | |
| CCollectiveTest | |
| Ccompute_1d_tiled_context | |
| Ccompute_2d_context | |
| Ccompute_2d_tiled_context | |
| Ccompute_3d_tiled_context | |
| Ccompute_4d_tiled_context | |
| CConcat | |
| CConv | |
| CConvRelu | |
| CConvTranspose | |
| CCopyFromOpenCL | |
| CCopyToOpenCL | |
| CD | |
| CDeclare | |
| CDecref | |
| CDefaultDtypeTest | |
| CDelayedErrorCtor | |
| CDLContext | A Device context for Tensor and operator |
| CDLDataType | The data type the tensor can hold |
| CDLManagedTensor | C Tensor object, manage memory of DLTensor. This data structure is intended to faciliate the borrowing of DLTensor by another framework. It is not meant to transfer the tensor. When the borrowing framework doesn't need the tensor, it should call the deleter to notify the host that the resource is no longer needed |
| Cdlnnapi | |
| CDLTensor | Plain C Tensor object, does not manage memory |
| CDoubler | |
| CDummyChunkDataReader | |
| CDummyDataset | |
| CDummyTensorDataset | |
| CE | |
| CEmptyModule | |
| CExpandingArrayTest | |
| CExport | |
| CFC | |
| CFlatten | |
| CFoo | |
| CFoo< Half > | |
| Cfunction_traits | |
| ►Cfunction_traits< ReturnType(Args...)> | |
| Carg | |
| Cfunction_traits< ReturnType(ClassType::*)(Args...) const > | |
| Cfunction_traits< T ClassType::* > | |
| CFunctionDescription | |
| CGivenTensorFill | |
| Cimm_xmm_union | |
| CInfiniteStreamDataset | |
| CInputFlags | |
| CIntegrationTest | |
| Cis_module_holder_of | |
| Cis_module_holder_of_impl | |
| Cis_module_holder_of_impl< false, T, C > | |
| Cis_module_holder_of_impl< true, T, C > | |
| Cis_simple_type | |
| Cisa_impl | |
| Cisa_impl< To, From, typename std::enable_if< std::is_base_of< To, From >::value >::type > | Always allow upcasts, and perform no dynamic check for them |
| Cisa_impl_cl | |
| Cisa_impl_cl< To, const From * > | |
| Cisa_impl_cl< To, const From *const > | |
| Cisa_impl_cl< To, const From > | |
| Cisa_impl_cl< To, const std::unique_ptr< From > > | |
| Cisa_impl_cl< To, From * > | |
| Cisa_impl_cl< To, From *const > | |
| Cisa_impl_wrap | |
| Cisa_impl_wrap< To, FromTy, FromTy > | |
| CM | |
| CManagerServerSocket | |
| CManagerSocket | |
| CMatrixMultiplier | |
| CMaxPool | |
| CMaxPoolRelu | |
| CModuleHolderIndicator | |
| CModulesTest | |
| CModuleTest | |
| CModuleWithNonTensorForwardImpl | |
| CMSNPUGuardImpl | |
| CMyTemplate | |
| CMyTemplate< at::ScalarType::Bool > | |
| CMyTemplate< at::ScalarType::Half > | |
| CNCCLTest | |
| CNCCLTestBase | |
| CNCHW2NHWC | |
| CNestedModel | |
| CNet | |
| CNHWC2NCHW | |
| CNNEquality | |
| CNoCtor | |
| CNotifier | This class enables a listener pattern |
| COnnxAnnotation | |
| CParallelTest | |
| CParameterTestModule | |
| Cpython_error | |
| CReceive | |
| CReduceNCCLTest | |
| CRelu | |
| CReshape | |
| Creturn_type_of_forward_impl | |
| Creturn_type_of_forward_impl< false, C, Args... > | |
| Creturn_type_of_forward_impl< true, C, Args... > | |
| CRNNTest | |
| CSend | |
| CSequentialTest | |
| CSignalTest | |
| Csimplify_type | |
| Csimplify_type< const From > | |
| CSNPEContext | |
| CSocket | |
| CSoftmax | |
| CStorageType | |
| CStorageType<> | |
| CSum | |
| CSumRelu | |
| CT | |
| CTensor | |
| CTensorStringDataset | |
| CTestClass | |
| CTestContainer | |
| CTestIndex | |
| CTestIndexDataset | |
| CTestIndexSampler | |
| CTestModel | |
| CTestModule | |
| CTestRandom | |
| CTestValue | |
| CTHCCachingHostAllocator | |
| CTHCDescBuff | |
| CTHCIpcDeleter | |
| CTHCPEvent | |
| CTHCPStream | |
| CTHCRNGState | |
| CTHDiskFile__ | |
| CTHFile__ | |
| CTHFileVTable | |
| CTHMapAllocator | |
| CTHMemoryFile__ | |
| CTHNVRTC | |
| CTHPCopyInfo | |
| CTHPDevice | |
| CTHPDtype | |
| CTHPDTypeInfo | |
| CTHPEngine | |
| CTHPFInfo | |
| CTHPFunction | |
| CTHPGenerator | |
| CTHPIInfo | |
| CTHPLayout | |
| CTHPPointer | |
| CTHPSize | |
| CTHPStorage | |
| CTHPTypeInfo | |
| CTHPVariable | |
| CTHPWrapper | |
| CTHRefcountedMapAllocator | |
| CTHRefcountedMapAllocatorArgCheck | |
| Cunary_function_traits | |
| CUncopyableDataset | |
| CUnCopyableDataset | |
| CUnpackedInput | |
| CUnsizedDataset | |
| CVkAllocationCallbacks | |
| CVkApplicationInfo | |
| CVkAttachmentDescription | |
| CVkAttachmentReference | |
| CVkBindSparseInfo | |
| CVkBufferCopy | |
| CVkBufferCreateInfo | |
| CVkBufferImageCopy | |
| CVkBufferMemoryBarrier | |
| CVkBufferViewCreateInfo | |
| CVkClearAttachment | |
| CVkClearColorValue | |
| CVkClearDepthStencilValue | |
| CVkClearRect | |
| CVkClearValue | |
| CVkCommandBufferAllocateInfo | |
| CVkCommandBufferBeginInfo | |
| CVkCommandBufferInheritanceInfo | |
| CVkCommandPoolCreateInfo | |
| CVkComponentMapping | |
| CVkComputePipelineCreateInfo | |
| CVkCopyDescriptorSet | |
| CVkDebugMarkerMarkerInfoEXT | |
| CVkDebugMarkerObjectNameInfoEXT | |
| CVkDebugMarkerObjectTagInfoEXT | |
| CVkDebugReportCallbackCreateInfoEXT | |
| CVkDedicatedAllocationBufferCreateInfoNV | |
| CVkDedicatedAllocationImageCreateInfoNV | |
| CVkDedicatedAllocationMemoryAllocateInfoNV | |
| CVkDescriptorBufferInfo | |
| CVkDescriptorImageInfo | |
| CVkDescriptorPoolCreateInfo | |
| CVkDescriptorPoolSize | |
| CVkDescriptorSetAllocateInfo | |
| CVkDescriptorSetLayoutBinding | |
| CVkDescriptorSetLayoutCreateInfo | |
| CVkDeviceCreateInfo | |
| CVkDeviceQueueCreateInfo | |
| CVkDispatchIndirectCommand | |
| CVkDisplayModeCreateInfoKHR | |
| CVkDisplayModeParametersKHR | |
| CVkDisplayModePropertiesKHR | |
| CVkDisplayPlaneCapabilitiesKHR | |
| CVkDisplayPlanePropertiesKHR | |
| CVkDisplayPresentInfoKHR | |
| CVkDisplayPropertiesKHR | |
| CVkDisplaySurfaceCreateInfoKHR | |
| CVkDrawIndexedIndirectCommand | |
| CVkDrawIndirectCommand | |
| CVkEventCreateInfo | |
| CVkExportMemoryAllocateInfoNV | |
| CVkExtensionProperties | |
| CVkExtent2D | |
| CVkExtent3D | |
| CVkExternalImageFormatPropertiesNV | |
| CVkExternalMemoryImageCreateInfoNV | |
| CVkFenceCreateInfo | |
| CVkFormatProperties | |
| CVkFramebufferCreateInfo | |
| CVkGraphicsPipelineCreateInfo | |
| CVkImageBlit | |
| CVkImageCopy | |
| CVkImageCreateInfo | |
| CVkImageFormatProperties | |
| CVkImageMemoryBarrier | |
| CVkImageResolve | |
| CVkImageSubresource | |
| CVkImageSubresourceLayers | |
| CVkImageSubresourceRange | |
| CVkImageViewCreateInfo | |
| CVkInstanceCreateInfo | |
| CVkLayerProperties | |
| CVkMappedMemoryRange | |
| CVkMemoryAllocateInfo | |
| CVkMemoryBarrier | |
| CVkMemoryHeap | |
| CVkMemoryRequirements | |
| CVkMemoryType | |
| CVkOffset2D | |
| CVkOffset3D | |
| CVkPhysicalDeviceFeatures | |
| CVkPhysicalDeviceLimits | |
| CVkPhysicalDeviceMemoryProperties | |
| CVkPhysicalDeviceProperties | |
| CVkPhysicalDeviceSparseProperties | |
| CVkPipelineCacheCreateInfo | |
| CVkPipelineColorBlendAttachmentState | |
| CVkPipelineColorBlendStateCreateInfo | |
| CVkPipelineDepthStencilStateCreateInfo | |
| CVkPipelineDynamicStateCreateInfo | |
| CVkPipelineInputAssemblyStateCreateInfo | |
| CVkPipelineLayoutCreateInfo | |
| CVkPipelineMultisampleStateCreateInfo | |
| CVkPipelineRasterizationStateCreateInfo | |
| CVkPipelineRasterizationStateRasterizationOrderAMD | |
| CVkPipelineShaderStageCreateInfo | |
| CVkPipelineTessellationStateCreateInfo | |
| CVkPipelineVertexInputStateCreateInfo | |
| CVkPipelineViewportStateCreateInfo | |
| CVkPresentInfoKHR | |
| CVkPushConstantRange | |
| CVkQueryPoolCreateInfo | |
| CVkQueueFamilyProperties | |
| CVkRect2D | |
| CVkRenderPassBeginInfo | |
| CVkRenderPassCreateInfo | |
| CVkSamplerCreateInfo | |
| CVkSemaphoreCreateInfo | |
| CVkShaderModuleCreateInfo | |
| CVkSparseBufferMemoryBindInfo | |
| CVkSparseImageFormatProperties | |
| CVkSparseImageMemoryBind | |
| CVkSparseImageMemoryBindInfo | |
| CVkSparseImageMemoryRequirements | |
| CVkSparseImageOpaqueMemoryBindInfo | |
| CVkSparseMemoryBind | |
| CVkSpecializationInfo | |
| CVkSpecializationMapEntry | |
| CVkStencilOpState | |
| CVkSubmitInfo | |
| CVkSubpassDependency | |
| CVkSubpassDescription | |
| CVkSubresourceLayout | |
| CVkSurfaceCapabilitiesKHR | |
| CVkSurfaceFormatKHR | |
| CVkSwapchainCreateInfoKHR | |
| CVkValidationFlagsEXT | |
| CVkVertexInputAttributeDescription | |
| CVkVertexInputBindingDescription | |
| CVkViewport | |
| CVkWriteDescriptorSet | |
| CXLAAllocator | |
1.8.11
