Home
last modified time | relevance | path

Searched full:operations (Results 1 – 25 of 2957) sorted by relevance

12345678910>>...119

/llvm-project/llvm/lib/Target/PowerPC/
H A DP10InstrResources.td13 // 22 Cycles Binary Floating Point operations, 2 input operands
21 // 22 Cycles Binary Floating Point operations, and 3 Cycles ALU operations, 2 input operands
27 // 24 Cycles Binary Floating Point operations, 2 input operands
33 // 26 Cycles Binary Floating Point operations, 1 input operands
41 // 26 Cycles Binary Floating Point operations, and 3 Cycles ALU operations, 1 input operands
47 // 27 Cycles Binary Floating Point operations, 1 input operands
53 // 27 Cycles Binary Floating Point operations, 2 input operands
62 // 27 Cycles Binary Floating Point operations, an
[all...]
/llvm-project/mlir/docs/Dialects/
H A DTransform.md9 This dialect provides operations that can be used to control transformation
15 on individual IR objects (operations or values) or sets thereof. For example, it
16 may involve finding loop-like operations with specific properties (e.g., large
18 operations, and then applying loop unrolling to the inner loops produced by the
25 The following IR gives a rough idea of what the operations in this dialect
26 may look like without using actually existing operations:
41 * sets of operations in the payload IR;
54 each of the operations that `%0` corresponds to.
57 operations. This is conceptually a set of operations an
[all...]
H A DOpenACCDialect.md18 operations, types, and attributes.
41 which can be packaged neatly with the `acc` dialect operations.
60 operations, like data operations, are expected to generate results
69 In order for the operations in the `acc` dialect to be optimizable
74 are adhered to. Current and planned operations, attributes, types must
79 The OpenACC dialect includes both high-level operations (which retain
81 intermediate-level operations (which are used to decompose clauses
82 from constructs), and low-level operations (to encode specifics
85 The high-level operations lis
153 Data Clause Decomposition'acc' Dialect""Operation Categories""Data Operations global() argument
193 Bounds'acc' Dialect""Operation Categories""Data Operations global() argument
240 Counters'acc' Dialect""Operation Categories""Data Operations global() argument
[all...]
/llvm-project/llvm/test/MC/RISCV/corev/
H A DXCValu-valid.s12 # CHECK-NO-EXT: instruction requires the following: 'XCValu' (CORE-V ALU Operations){{$}}
17 # CHECK-NO-EXT: instruction requires the following: 'XCValu' (CORE-V ALU Operations){{$}}
22 # CHECK-NO-EXT: instruction requires the following: 'XCValu' (CORE-V ALU Operations){{$}}
27 # CHECK-NO-EXT: instruction requires the following: 'XCValu' (CORE-V ALU Operations){{$}}
32 # CHECK-NO-EXT: instruction requires the following: 'XCValu' (CORE-V ALU Operations){{$}}
37 # CHECK-NO-EXT: instruction requires the following: 'XCValu' (CORE-V ALU Operations){{$}}
42 # CHECK-NO-EXT: instruction requires the following: 'XCValu' (CORE-V ALU Operations){{$}}
52 # CHECK-NO-EXT: instruction requires the following: 'XCValu' (CORE-V ALU Operations){{$}}
62 # CHECK-NO-EXT: instruction requires the following: 'XCValu' (CORE-V ALU Operations){{$}}
67 # CHECK-NO-EXT: instruction requires the following: 'XCValu' (CORE-V ALU Operations){{
[all...]
/llvm-project/clang-tools-extra/test/clang-tidy/checkers/readability/
H A Dmath-missing-parentheses.cpp37 …recedence than '+'; add parentheses to explicitly specify the order of operations [readability-mat… in f()
47 …recedence than '+'; add parentheses to explicitly specify the order of operations [readability-mat… in f()
48 …recedence than '-'; add parentheses to explicitly specify the order of operations [readability-mat… in f()
54 …recedence than '|'; add parentheses to explicitly specify the order of operations [readability-mat… in f()
55 …recedence than '&'; add parentheses to explicitly specify the order of operations [readability-mat… in f()
56 …recedence than '|'; add parentheses to explicitly specify the order of operations [readability-mat… in f()
62 …recedence than '+'; add parentheses to explicitly specify the order of operations [readability-mat… in f()
68 …recedence than '+'; add parentheses to explicitly specify the order of operations [readability-mat… in f()
74 …recedence than '|'; add parentheses to explicitly specify the order of operations [readability-mat… in f()
75 …recedence than '&'; add parentheses to explicitly specify the order of operations [readability-mat… in f()
[all …]
/llvm-project/mlir/include/mlir/Dialect/Async/
H A DPasses.td15 let summary = "Convert scf.parallel operations to multiple async compute ops "
28 "The number of available workers to execute async operations. If `-1` "
45 let summary = "Lower all high level async operations (e.g. async.execute) to"
46 "the explicit async.runtime and async.coro operations";
52 let summary = "Lower async.func operations to the explicit async.runtime and"
53 "async.coro operations";
59 let summary = "Automatic reference counting for Async runtime operations";
62 `async.execute` and `async.await` operations are lowered to the async
63 runtime API calls, and async coroutine operations.
66 the correct placing of the reference counting operations.
[all …]
/llvm-project/mlir/docs/Tutorials/transform/
H A DCh4.md1 # Chapter 4: Matching Payload with Transform Operations
7 that specific payload operations are identified by the caller when the transform
15 a subset of operations for _matching_ payload operations that need to be
18 _Match_ operations are simply transform operations with some additional
22 operation names or kinds of arguments. Using simple combinator operations, it
63 associations for operation handles. Instead, we can use match operations to
64 discover relevant operations in the payload IR. Match operations can be combined
65 with “regular” transform operations using, e.g., the
78 // Collect operations that match the criteria specified in named sequence.
130 `linalg.elemwise_binary` and `linalg.matmul` operations. In debug builds, the
[all …]
H A DCh1.md5 …operations in the IR and to chain them, that is to apply a transformation to operations produced b…
7 Transform IR operations operate on values that may be associated with payload IR operations, values…
9 …l operation, `transform.named_sequence` merely applies other transform operations listed in its bo…
37 For performance reasons, we would like to tile and fuse these operations to exploit cache locality.…
54 …operations or values that are useful in the sequence. These are also specified when calling `apply…
56 …operations. On the contrary, `transform.op<"X">` indicates that the handle is associated _only_ wi…
69 …associated with the transform IR values. For example, we can print the operations associated with …
95 …sequence with all `linalg.matmul` and `linalg.elemwise_binary` payload operations through the resp…
112 Note that `%arg2` is associated with both elementwise payload operations. Any handle is associated …
117 Now that we have handles to the operations we want to transform, we are ready to apply the transfor…
[all …]
H A DCh2.md7 The Transform dialect uses the dialect extension mechanism to allow additional operations to be inj…
21 // dialect definitions. List individual operations and dependent dialects
30 // the attributes or types used by transform operations. Do NOT declare as
35 // When transformations are applied, they may produce new operations from
37 // itself dependent on the dialects containing such new operations. To avoid
40 // - dependent dialects, which are used by the transform operations, and
41 // - generated dialects, which contain the entities (attributes, operations,
44 // In the following chapter, we will be add operations that generate function
45 // calls and structured control flow operations, so let's declare the
50 // Finally, we register the additional transform operations with the dialect.
[all …]
H A DChH.md16 scheduling part, can target the operations in the Transform dialect that are
17 later applied by the compiler. Sets of transform operations, or even new
27 operations, that correspond to the scheduling part of the DSL.
34 operations are similar to or different from the existing transformations.
85 // Convolution proper. While Linalg has named operations for 2D convolutions,
100 // Note the fastmath attributes that allow operations to be recombined into
129 initialization and the update are represented as two distinct Linalg operations
230 not apply to named operations that need to be “generalized” first by calling
232 dimensions and not the explicit loops materialized by tiling operations that
240 transformation to all suitable operations at, e.g., a function scope via
[all …]
/llvm-project/mlir/docs/Traits/
H A D_index.md6 operations, and types that suit a specific level of abstraction. `Traits` are a
8 across many different attributes/operations/types/etc.. `Traits` may be used to
20 `AttributeTrait::TraitBase`. For operations, this is `OpTrait::TraitBase`. For
42 operations in the regions will be verified before the verification of this
43 trait. The [verification order](../DefiningDialects/Operations.md/#verification-ordering)
158 To use an operation trait in the [ODS](../DefiningDialects/Operations.md) framework, we need to
180 See the documentation on [operation definitions](../DefiningDialects/Operations.md) for more
204 common across many different operations. Below is a list of some key traits that
215 This trait is carried by region holding operations that define a new scope for
217 Any SSA values of 'index' type that either dominate such operations, or are
[all …]
/llvm-project/mlir/include/mlir/Dialect/Vector/TransformOps/
H A DVectorTransformOps.td47 to expose more canonical forms of read/write/insert/extract operations.
64 dimensions into a rank-reduced version thanks to subview operations.
112 Indicates that vector bitcast operations should be lowered to
126 Indicates that vector broadcast operations should be lowered to
140 Indicates that vector contraction-like operations should be lowered to
159 Indicates that vector create_mask-like operations should be lowered to
170 Indicates that vector.create_mask and vector.constant_mask operations
184 Apply opt-in patterns that lower vector.mask operations surrounding
201 Indicates that mask operations should be lowered to fine-grained arithemtic
202 operations
[all...]
/llvm-project/mlir/docs/Rationale/
H A DSideEffectsAndSpeculation.md6 This rationale only applies to operations used in
14 Many MLIR operations don't exhibit any behavior other than consuming and
15 producing SSA values. These operations can be reordered with other operations as
20 However, a subset of MLIR operations have implicit behavior than isn't reflected
21 in their SSA data-flow semantics. These operations need special handing, and
24 This doc introduces a categorization of these operations and shows how these
25 operations are modeled in MLIR.
29 Operations with implicit behaviors can be broadly categorized as follows:
31 1. Operations wit
[all...]
/llvm-project/mlir/docs/
H A DLangRef.md31 *Operations*, and edges, called *Values*. Each Value is the result of exactly
33 [type system](#type-system). [Operations](#operations) are contained in
34 [Blocks](#blocks) and Blocks are contained in [Regions](#regions). Operations
37 in a given [kind of region](Interfaces.md/#regionkindinterfaces)). Operations
40 Operations can represent many different concepts, from higher-level concepts
44 gates. These different concepts are represented by different operations in MLIR
45 and the set of operations usable in MLIR can be arbitrarily extended.
47 MLIR also provides an extensible framework for transformations on operations,
49 set of passes on an arbitrary set of operations results in a significant scaling
53 [Interfaces](Interfaces.md), enabling transformations to operate on operations
[all …]
H A DSymbolsAndSymbolTables.md7 around this nesting structure; including the processing of operations within the
9 design is that it is able to process operations in parallel, utilizing multiple
14 operations defined above. Making this thread-safe requires expensive locking in
23 operations defined above regions that were defined as `IsolatedFromAbove` in a
24 safe way. It also allows for symbolically referencing operations defined below
32 result value, and may be referred to by other operations to provide a symbolic
35 symbol name, which is [referred to](#referencing-a-symbol) by operations like
41 necessary verification and accessors; it also supports operations, such as
63 the [`Symbol`](#symbol) operations. It verifies that all `Symbol` operations
[all...]
H A DDialectConversion.md5 illegal operations to those supported by a provided conversion target, via a set
18 When applying a conversion to a set of operations, there are several different
23 - A partial conversion will legalize as many operations to the target as
24 possible, but will allow pre-existing operations that were not
27 operations.
32 - A full conversion legalizes all input operations, and is only successful
33 if all operations are properly legalized to the given conversion target.
34 This ensures that only known operations will exist after the conversion
40 - An analysis conversion will analyze which operations are legalizable to
42 done by performing a 'partial' conversion and recording which operations
[all...]
/llvm-project/mlir/include/mlir/IR/
H A DBlock.h42 // Clear operations in the reverse order so that uses are destroyed in clear()
45 operations.pop_back();
135 /// This is the list of operations in the block. in getOperations()
137 OpListType &getOperations() { return operations; }
139 // Iteration over the operations in the block.
143 iterator begin() { return operations.begin(); } in rbegin()
144 iterator end() { return operations.end(); } in rend()
145 reverse_iterator rbegin() { return operations.rbegin(); }
146 reverse_iterator rend() { return operations.rend(); } in empty()
148 bool empty() { return operations in push_back()
395 OpListType operations; global() variable
[all...]
/llvm-project/mlir/docs/Tutorials/Toy/
H A DCh-2.md23 pre-defined instructions (*operations* in MLIR terminology) or types.
30 closed set of attributes (think: constant metadata), operations, or types. MLIR
35 In MLIR, [`Operations`](../../LangRef.md/#operations) are the core unit of
37 Operations can have application-specific semantics and can be used to represent
41 Here is the MLIR assembly for the Toy `transpose` operations:
54 will limit ourselves to single-result operations), which are SSA values.
67 values defined by other operations or referring to block arguments.
87 the set of operations in MLIR is extensible. Operations ar
313 Op vs Operation: Using MLIR OperationsChapter 2: Emitting Basic MLIR""Defining Toy Operations global() argument
350 Using the Operation Definition Specification (ODS) FrameworkChapter 2: Emitting Basic MLIR""Defining Toy Operations global() argument
[all...]
/llvm-project/llvm/docs/
H A DMemoryModelRelaxationAnnotations.rst16 memory operations to be reordered across ``acquire`` or ``release``
17 operations.
67 Tags can also be organised in lists to allow operations
87 Both synchronizing operations and memory operations can have
143 other operations is target dependent.
167 only synchronize with operations happening in ``addrspace(0)``.
205 ``VulkanMemoryModel``, where synchronizing operations only affect
206 memory operations that specify ``NonPrivatePointer`` semantics.
232 No such relation can be inferred about operations ``B`` and ``C``.
238 Whether ``vulkan:nonprivate`` would be specified on atomic operations is
[all …]
H A DAtomics.rst122 operations. A Monotonic load followed by an Acquire fence is roughly
192 operations; if you need such an operation, use explicit locking.
212 call. Reordering unordered operations is safe, though, and optimizers should
213 take advantage of that because unordered operations are common in languages
217 These operations are required to be atomic in the sense that if you use
221 instructions (or an instruction which does multiple memory operations, like
229 essentially guarantees that if you take all the operations affecting a specific
240 either be used for atomic operations which do not protect other memory (like
248 operations are unlikely to be used in ways which would make those
316 barrier (for fences and operations which both read and write memory).
[all …]
/llvm-project/mlir/include/mlir/Dialect/Arith/Transforms/
H A DPasses.td29 we know that the semantics of the signed and unsigned operations are the same,
43 results. It replaces operations with known-constant results with said constants,
46 // Explicitly depend on "arith" because this pass could create operations in
54 let summary = "Reduce integer operations bitwidth based on integer range analysis";
68 // Explicitly depend on "arith" because this pass could create operations in
76 let summary = "Emulate operations on unsupported floats with extf/truncf";
78 Emulate arith and vector floating point operations that use float types
80 such operations in order to produce arithmetic that can be performed while
83 This pass does not attempt to reason about the operations being performed
98 let summary = "Emulate 2*N-bit integer operations usin
[all...]
/llvm-project/mlir/include/mlir/Conversion/VectorToGPU/
H A DVectorToGPU.h23 /// matrix operations. If `useNvGpu` is true, then the patterns will populated
24 /// will prepare for conversion to `nvgpu` mma operations rather than the `gpu`
25 /// dialect WMMA operations.
29 /// Convert vector ops to MMA matrix operations nested under `rootOp`. This will
30 /// convert slice of operations that can be legally converted to MMA operations.
31 /// The rest of the vector operations are left untouched.
36 /// of operations that can be legally lowered on this path while the rest of
37 /// the vector operations are left untouched.
/llvm-project/mlir/include/mlir/Dialect/Index/IR/
H A DIndexDialect.td23 The Index dialect contains operations for manipulating values of the builtin
28 The operations in this dialect operate exclusively on scalar index types.
29 The dialect and its operations treat the index type as signless and contains
30 signed and unsigned versions of certain operations where the distinction is
31 meaningful. In particular, the operations and transformations are careful to
35 The folding semantics of the Index dialect operations ensure that folding
38 Operations are folded using 64-bit integer arithmetic.
40 For operations where the values of the upper 32 bits don't impact the values
60 Operations where the values of the upper 32 bits do impact the values of the
62 These are operations that right shift -- division, remainder, etc. These
[all …]
/llvm-project/mlir/include/mlir/Dialect/MemRef/Transforms/
H A DPasses.td15 let summary = "Legalize memref operations to be convertible to LLVM.";
32 let summary = "Emulate 2*N-bit integer operations using N-bit operations";
34 Emulate memref integer operations that use too wide integer types with
35 equivalent operations on supported narrow integer types. This is done by
59 contained in the op. Operations marked with the
61 trait are expected to be normalizable. Supported operations include affine
62 operations, memref.alloc, memref.dealloc, and func.return.
71 contains any operations that are not MemRefNormalizable, then the function
166 The pass resolves memref.dim of result of operations that
180 The pass resolves memref.dim of result of operations that
[all …]
/llvm-project/mlir/include/mlir/Transforms/
H A DPasses.td20 let summary = "Canonicalize operations";
23 operations by iteratively applying the canonicalization patterns of all
58 let summary = "Sink operations into conditional blocks";
60 This pass implements control-flow sink on operations that implement
61 `RegionBranchOpInterface` by moving dominating operations whose only uses
67 operations out of regions executed more than once. The implementation of
68 control-flow sink uses a simple and conversative cost model: operations are
72 blocks: ops in unreachable blocks may prevent other operations from being
77 Statistic<"numSunk", "num-sunk", "Number of operations sunk">,
87 operations
[all...]

12345678910>>...119