▼Ncmdline | |
►Ndetail | |
Clexical_cast_t | |
Clexical_cast_t< Target, Source, true > | |
Clexical_cast_t< std::string, Source, false > | |
Clexical_cast_t< Target, std::string, false > | |
Cis_same | |
Cis_same< T, T > | |
Cdefault_reader | |
Crange_reader | |
Coneof_reader | |
Cparser | |
▼NHalide | This file defines the class FunctionDAG, which is our representation of a Halide pipeline, and contains methods to using Halide's bounds tools to query properties of it |
►NBoundaryConditions | Namespace to hold functions for imposing boundary conditions on Halide Funcs |
NInternal | |
NConciseCasts | |
►NInternal | |
►NAutoscheduler | |
CCachingOptions | |
CCache | |
COptionalRational | |
CLoadJacobian | |
CSpan | |
►CBoundContents | |
CLayout | |
►CFunctionDAG | |
►CEdge | |
CBoundInfo | |
►CNode | |
CLoop | |
CRegionComputedInfo | |
CStage | |
CSymbolicInterval | |
►CLoopNest | |
CSites | |
►CStageScheduleState | |
CFuncVar | |
CState | |
CScopedTimer | |
CTimer | |
►NElf | |
Citerator_range | |
CSymbol | Describes a symbol |
CRelocation | Describes a relocation to be applied to an offset of a section in an Object |
CSection | Describes a section of an object file |
CLinker | Base class for a target architecture to implement the target specific aspects of linking |
CObject | Holds all of the relevant sections and symbols for an object |
NGeneratorMinMax | |
NIntegerDivision | |
NIntrospection | |
►NIRMatcher | An alternative template-metaprogramming approach to expression matching |
CMatcherState | To save stack space, the matcher objects are largely stateless and immutable |
►Cenable_if_pattern | |
Ctype | |
Cbindings | |
►CSpecificExpr | |
Cpattern_tag | |
►CWildConstInt | |
Cpattern_tag | |
►CWildConstUInt | |
Cpattern_tag | |
►CWildConstFloat | |
Cpattern_tag | |
►CWildConst | |
Cpattern_tag | |
►CWild | |
Cpattern_tag | |
►CIntLiteral | |
Cpattern_tag | |
►CBinOp | |
Cpattern_tag | |
►CCmpOp | |
Cpattern_tag | |
►CIntrin | |
Cpattern_tag | |
►CNotOp | |
Cpattern_tag | |
►CSelectOp | |
Cpattern_tag | |
►CBroadcastOp | |
Cpattern_tag | |
►CRampOp | |
Cpattern_tag | |
►CVectorReduceOp | |
Cpattern_tag | |
►CNegateOp | |
Cpattern_tag | |
►CCastOp | |
Cpattern_tag | |
►CFold | |
Cpattern_tag | |
►COverflows | |
Cpattern_tag | |
►COverflow | |
Cpattern_tag | |
►CIsConst | |
Cpattern_tag | |
►CCanProve | |
Cpattern_tag | |
►CIsFloat | |
Cpattern_tag | |
►CIsInt | |
Cpattern_tag | |
►CIsUInt | |
Cpattern_tag | |
►CIsScalar | |
Cpattern_tag | |
►CIsMaxValue | |
Cpattern_tag | |
►CIsMinValue | |
Cpattern_tag | |
CRewriter | |
NTest | |
CApplySplitResult | |
CAssociativePattern | Represent an associative op with its identity |
►CAssociativeOp | Represent the equivalent associative op of an update definition |
CReplacement | |
Caslog | |
CPipelineFeatures | |
CScheduleFeatures | |
CFeatureIntermediates | |
CWeights | |
CFindAllCalls | Visitor for keeping track of functions that are directly called and the arguments with which they are called |
CBox | Represents the bounds of a region of arbitrary dimension |
CBufferContents | |
Call_ints_and_optional_name | |
Call_ints_and_optional_name< First, Rest... > | |
Call_ints_and_optional_name< T > | |
Call_ints_and_optional_name<> | |
►CClosure | A helper class to manage closures |
CBuffer | Information about a buffer reference from a closure |
►CCodeGen_C | This class emits C++ code equivalent to a halide Stmt |
CAllocation | |
CCodeGen_GPU_Dev | A code generator that emits GPU code from a given Halide stmt |
►CCodeGen_LLVM | A code generator abstract base class |
CIntrinsic | Description of an intrinsic function overload |
►CParallelTask | Codegen a call to do_parallel_tasks |
CSemAcquire | |
►CCodeGen_Posix | A code generator that emits posix code from a given Halide stmt |
CAllocation | A struct describing heap or stack allocations |
CCodeGen_PyTorch | This class emits C++ code to wrap a Halide pipeline so that it can be used as a C++ extension operator in PyTorch |
CCompilerLogger | |
CJSONCompilerLogger | JSONCompilerLogger is a basic implementation of the CompilerLogger interface that saves logged data, then logs it all in JSON format in emit_to_stream() |
Cdebug | For optional debugging during codegen, use the debug class as follows: |
CDefinition | A Function definition which can either represent a init or an update definition |
CSpecialization | |
CReductionVariableInfo | Return a list of reduction variables the expression or tuple depends on |
CBufferInfo | Find all calls to image buffers and parameters in the function |
CDeviceArgument | A DeviceArgument looks similar to an Halide::Argument, but has behavioral differences that make it specific to the GPU pipeline; the fact that neither is-a nor has-a Halide::Argument is deliberate |
CHostClosure | A Closure modified to inspect GPU-specific memory accesses, and produce a vector of DeviceArgument objects |
CDimension | |
CErrorReport | |
CVoidifier | |
CIRNode | The abstract base classes for a node in the Halide IR |
CBaseStmtNode | IR nodes are split into expressions and statements |
CBaseExprNode | A base class for expression nodes |
CExprNode | We use the "curiously recurring template pattern" to avoid duplicated code in the IR Nodes |
CStmtNode | |
CIRHandle | IR nodes are passed around opaque handles to them |
CIntImm | Integer constants |
CUIntImm | Unsigned integer constants |
CFloatImm | Floating point constants |
CStringImm | String constants |
►CStmt | A reference-counted handle to a statement node |
CCompare | This lets you use a Stmt as a key in a map of the form map<Stmt, Foo, Stmt::Compare> |
CExprUsesVars | |
►CFunction | A reference-counted handle to Halide's internal representation of a function |
CCompare | This lets you use a Function as a key in a map of the form map<Function, Foo, Function::Compare> |
CFunctionPtr | A possibly-weak pointer to a Halide function |
CValueTracker | ValueTracker is an internal utility class that attempts to track and flag certain obvious Stub-related errors at Halide compile time: it tracks the constraints set on any Parameter-based argument (i.e., Input<Buffer> and Output<Buffer>) to ensure that incompatible values aren't set |
Ccond | |
Cselect_type | |
Cselect_type< First > | |
CGeneratorParamBase | |
CConvert | |
CGeneratorParamImpl | |
CGeneratorParam_Target | |
CGeneratorParam_MachineParams | |
CGeneratorParam_LoopLevel | |
CGeneratorParam_Arithmetic | |
CGeneratorParam_Bool | |
CGeneratorParam_Enum | |
CGeneratorParam_Type | |
CGeneratorParam_String | |
CGeneratorInput_Buffer | |
CStubInputBuffer | StubInputBuffer is the placeholder that a Stub uses when it requires a Buffer for an input (rather than merely a Func or Expr) |
CStubOutputBufferBase | |
CStubOutputBuffer | StubOutputBuffer is the placeholder that a Stub uses when it requires a Buffer for an output (rather than merely a Func) |
CStubInput | |
CGIOBase | GIOBase is the base class for all GeneratorInput<> and GeneratorOutput<> instantiations; it is not part of the public API and should never be used directly by user code |
CGeneratorInputBase | |
CGeneratorInputImpl | |
CGeneratorInput_Func | |
CGeneratorInput_DynamicScalar | |
CGeneratorInput_Scalar | |
CGeneratorInput_Arithmetic | |
Ctype_sink | |
Chas_static_halide_type_method | |
Chas_static_halide_type_method< T2, typename type_sink< decltype(T2::static_halide_type())>::type > | |
CGeneratorOutputBase | |
CGeneratorOutputImpl | |
CGeneratorOutput_Buffer | |
CGeneratorOutput_Func | |
CGeneratorOutput_Arithmetic | |
CGeneratorParam_Synthetic | |
CNoRealizations | |
CNoRealizations<> | |
CNoRealizations< T, Args... > | |
CStringOrLoopLevel | |
CGeneratorParamInfo | |
CGeneratorBase | |
CGeneratorRegistry | |
CRegisterGenerator | |
►CGeneratorStub | |
CNames | |
CHexagonAlignmentAnalyzer | |
CInferredArgument | An inferred argument |
CInterval | A class to represent ranges of Exprs |
CConstantInterval | A class to represent ranges of integers |
CRefCount | A class representing a reference count to be used with IntrusivePtr |
CIntrusivePtr | Intrusive shared pointers have a reference count (a RefCount object) stored in the class itself |
CCast | The actual IR nodes begin here |
CAdd | The sum of two expressions |
CSub | The difference of two expressions |
CMul | The product of two expressions |
CDiv | The ratio of two expressions |
CMod | The remainder of a / b |
CMin | The lesser of two values |
CMax | The greater of two values |
CEQ | Is the first expression equal to the second |
CNE | Is the first expression not equal to the second |
CLT | Is the first expression less than the second |
CLE | Is the first expression less than or equal to the second |
CGT | Is the first expression greater than the second |
CGE | Is the first expression greater than or equal to the second |
CAnd | Logical and - are both expressions true |
COr | Logical or - is at least one of the expression true |
CNot | Logical not - true if the expression false |
CSelect | A ternary operator |
CLoad | Load a value from a named symbol if predicate is true |
CRamp | A linear ramp vector node |
CBroadcast | A vector with 'lanes' elements, in which every element is 'value' |
CLet | A let expression, like you might find in a functional language |
CLetStmt | The statement form of a let node |
CAssertStmt | If the 'condition' is false, then evaluate and return the message, which should be a call to an error function |
CProducerConsumer | This node is a helpful annotation to do with permissions |
CStore | Store a 'value' to the buffer called 'name' at a given 'index' if 'predicate' is true |
CProvide | This defines the value of a function at a multi-dimensional location |
CAllocate | Allocate a scratch area called with the given name, type, and size |
CFree | Free the resources associated with the given buffer |
CRealize | Allocate a multi-dimensional buffer of the given type and size |
CBlock | A sequence of statements to be executed in-order |
CFork | A pair of statements executed concurrently |
CIfThenElse | An if-then-else block |
CEvaluate | Evaluate and discard an expression, presumably because it has some side-effect |
CCall | A function call |
CVariable | A named variable |
CFor | A for loop |
CAcquire | |
CShuffle | Construct a new vector by taking elements from another sequence of vectors |
CPrefetch | Represent a multi-dimensional region of a Func or an ImageParam that needs to be prefetched |
CAtomic | Lock all the Store nodes in the body statement |
CVectorReduce | Horizontally reduce a vector to a scalar or narrower vector using the given commutative and associative binary operator |
CIRDeepCompare | A compare struct suitable for use in std::map and std::set that computes a lexical ordering on IR nodes |
CIRCompareCache | Lossily track known equal exprs with a cache |
CExprWithCompareCache | A wrapper about Exprs so that they can be deeply compared with a cache for known-equal subexpressions |
CIRMutator | A base class for passes over the IR which modify it (e.g |
CIRGraphMutator | A mutator that caches and reapplies previously-done mutations, so that it can handle graphs of IR that have not had CSE done to them |
CBufferBuilder | A builder to help create Exprs representing halide_buffer_t structs (e.g |
CIndentation | |
CIRPrinter | An IRVisitor that emits IR to the given output stream in a human readable form |
CIRVisitor | A base class for algorithms that need to recursively walk over the IR |
CIRGraphVisitor | A base class for algorithms that walk recursively over the IR without visiting the same node twice |
CVariadicVisitor | A visitor/mutator capable of passing arbitrary arguments to the visit methods using CRTP and returning any types from them |
►CJITModule | |
CSymbol | |
CJITHandlers | |
CJITUserContext | |
CJITSharedRuntime | |
COutputInfo | |
CLoweredArgument | Definition of an argument to a LoweredFunc |
CLoweredFunc | Definition of a lowered function |
►CScope | A common pattern when traversing Halide IR is that you need to keep track of stuff when you find a Let or a LetStmt, and that it should hide previous values with the same name until you leave the Let or LetStmt nodes This class helps with that |
Cconst_iterator | Iterate through the scope |
CModulusRemainder | The result of modulus_remainder analysis |
CObjectInstanceRegistry | |
CParameter | A reference-counted handle to a parameter to a halide pipeline |
CPrefetchDirective | |
CPythonExtensionGen | |
►CReductionVariable | A single named dimension of a reduction domain |
CCompare | This lets you use a ReductionVariable as a key in a map of the form map<ReductionVariable, Foo, ReductionVariable::Compare> |
►CReductionDomain | A reference-counted handle on a reduction domain, which is just a vector of ReductionVariable |
CCompare | This lets you use a ReductionDomain as a key in a map of the form map<ReductionDomain, Foo, ReductionDomain::Compare> |
CCost | |
CRegionCosts | Auto scheduling component which is used to assign costs for computing a region of a function or one of its stages |
CGPUCompilationCache | |
CSplit | |
CDim | The Dim struct represents one loop in the schedule's representation of a loop nest |
CBound | A bound on a loop, typically from Func::bound |
CStorageDim | Properties of one axis of the storage of a Func |
CFusedPair | This represents two stages with fused loop nests from outermost to a specific loop level |
CFuncSchedule | A schedule for a Function of a Halide pipeline |
CStageSchedule | A schedule for a single stage of a Halide pipeline |
CSmallStack | A stack which can store one item very efficiently |
CSmallStack< void > | |
CScopedBinding | Helper class for pushing/popping Scope<> values, to allow for early-exit in Visitor/Mutators that preserves correctness |
CScopedBinding< void > | |
►CSimplify | |
CExprInfo | |
CScopedFact | |
CVarInfo | |
CSolverResult | |
CThreadPool | |
Cmeta_and | |
Cmeta_and< T1, Args... > | |
Cmeta_or | |
Cmeta_or< T1, Args... > | |
Call_are_convertible | |
CFileStat | |
CTemporaryFile | A simple utility class that creates a temporary file in its ctor and deletes that file in its dtor; this is useful for temporary files that you want to ensure are deleted when exiting a certain scope |
CScopedValue | Helper class for saving/restoring variable values on the stack, to allow for early-exit that preserves correctness |
Cinteger_sequence | |
Cnext_integer_sequence | |
Cnext_integer_sequence< integer_sequence< T, Ints... > > | |
Cmake_integer_sequence_helper | |
Cmake_integer_sequence_helper< T, N, N > | |
CStaticCast | |
CIsRoundtrippable | |
CWasmModule | Handle to compiled wasm code which can be called later |
CGpuObjectLifetimeTracker | |
NPyTorch | |
►NRuntime | |
►NInternal | |
►NCuda | |
CCUDA_MEMCPY3D_st | |
NMetal | |
NQurt | |
►NSynchronization | |
Cspin_control | |
Cword_lock_queue_data | |
Cword_lock | |
Cqueue_data | |
Chash_bucket | |
Chash_table | |
Cbucket_pair | |
Cvalidate_action | |
Cparking_control | |
Cmutex_parking_control | |
Cfast_mutex | |
Csignal_parking_control | |
Cbroadcast_parking_control | |
Cwait_parking_control | |
Cfast_cond | |
CCpuFeatures | |
Cdevice_copy | |
CCacheEntry | |
CHashMap | |
CTHashMap | |
CScopedMutexLock | |
CScopedSpinLock | |
Cwork | |
Cwork_queue_t | |
►CBuffer | A templated Buffer class that wraps halide_buffer_t and adds functionality |
►CDimension | Read-only access to the shape |
Citerator | An iterator class, so that you can iterate over coordinates in a dimensions using a range-based for loop |
CAllInts | |
CAllInts<> | |
CAllInts< T, Args... > | |
CAllInts< float, Args... > | |
CAllInts< double, Args... > | |
CAllocationHeader | A struct acting as a header for allocations owned by the Buffer class itself |
CDeviceRefCount | A similar struct for managing device allocations |
CBuffer | A Halide::Buffer is a named shared reference to a Halide::Runtime::Buffer |
CArgumentEstimates | |
CArgument | A struct representing an argument to a halide-generated function |
CCostModel | |
CDefaultCostModel | |
CDerivative | Helper structure storing the adjoints Func |
CError | A base class for Halide errors |
CRuntimeError | An error that occurs while running a JIT-compiled Halide pipeline |
CCompileError | An error that occurs while compiling a Halide pipeline that Halide attributes to a user error |
CInternalError | An error that occurs while compiling a Halide pipeline that Halide attributes to an internal compiler bug, or to an invalid use of Halide's internals |
CCompileTimeErrorReporter | CompileTimeErrorReporter is used at compile time (not runtime) when an error or warning is generated by Halide |
CExpr | A fragment of Halide syntax |
CExprCompare | This lets you use an Expr as a key in a map of the form map<Expr, Foo, ExprCompare> |
CRange | A single-dimensional span |
CExternalCode | |
CExternFuncArgument | An argument to an extern-defined Func |
Cfloat16_t | Class that provides a type that implements half precision floating point (IEEE754 2008 binary16) in software |
Cbfloat16_t | Class that provides a type that implements half precision floating point using the bfloat16 format |
CVarOrRVar | A class that can represent Vars or RVars |
CStage | A single definition of a Func |
CFuncRef | A fragment of front-end syntax of the form f(x, y, z), where x, y, z are Vars or Exprs |
CFuncTupleElementRef | A fragment of front-end syntax of the form f(x, y, z)[index], where x, y, z are Vars or Exprs |
CEvictionKey | Helper class for identifying purpose of an Expr passed to memoize |
CFunc | A halide function |
CGeneratorParam | GeneratorParam is a templated class that can be used to modify the behavior of the Generator at code-generation time |
CGeneratorInput | |
CGeneratorOutput | |
CGeneratorContext | GeneratorContext is a base class that is used when using Generators (or Stubs) directly; it is used to allow the outer context (typically, either a Generator or "top-level" code) to specify certain information to the inner context to ensure that inner and outer Generators are compiled in a compatible way |
CNamesInterface | |
CGenerator | |
CImageParam | An Image parameter to a halide pipeline |
CModule | A halide module |
COutputImageParam | A handle on the output buffer of a pipeline |
CParam | A scalar parameter to a halide pipeline |
►CParamMap | |
CParamMapping | |
CMachineParams | A struct representing the machine parameters to generate the auto-scheduled code for |
CCustomLoweringPass | A custom lowering pass |
CAutoSchedulerResults | |
►CPipeline | A class representing a Halide pipeline |
CRealizationArg | |
CExternSignature | |
CExternCFunction | |
CJITExtern | |
CRVar | A reduction variable represents a single dimension of a reduction domain (RDom) |
CRDom | A multi-dimensional domain over which to iterate |
CRealization | A Realization is a vector of references to existing Buffer objects |
CLoopLevel | A reference to a site in a Halide statement at the top of the body of a particular for loop |
CFuseLoopLevel | |
CTarget | A struct representing a target machine and os to generate code for |
CTuple | Create a small array of Exprs for defining and calling functions with multiple outputs |
CType | Types in the halide type system |
CVar | A Halide variable, to be used when defining functions |
CImplicitVar | |
CTestResult | |
CTask | |
CSimdOpCheckTest | |
Nhalide_register_generator | |
▼NHalideIntrospectionCanary | |
►CA | |
CB | |
▼Nllvm | |
CIRBuilder | |
NMessage | |