| 文件 | 最后提交记录 | 最后更新时间 |
|---|---|---|
[mlir][bufferization][NFC] Rename to_memref to to_buffer (#137180) As part of the work on transitioning bufferization dialect, ops, and associated logic to operate on newly added type interfaces (see 00eaff3e9c897c263a879416d0f151d7ca7eeaff), rename the bufferization.to_memref to highlight the generic nature of the op. Bufferization process produces buffers while memref is a builtin type rather than a generic term. Preserve the current API (to_buffer still produces a memref), however, as the new type interfaces are not used yet. | 1 年前 | |
[mlir][sparse] force a properly sized view on pos/crd/val under codegen (#91288) Codegen "vectors" for pos/crd/val use the capacity as memref size, not the actual used size. Although the sparsifier itself always uses just the defined pos/crd/val parts, printing these and passing them back to a runtime environment could benefit from wrapping the basic pos/crd/val getters into a proper memref view that sets the right size. | 2 年前 | |
[mlir][sparse] renaming sparse_tensor.sort_coo to sparse_tensor.sort (#68161) Rationale: the operation does not always sort COO tensors (also used for sparse_tensor.compress for example). | 2 年前 | |
[mlir][sparse] add canonicalization patterns for IterateOp. (#95569) | 2 年前 | |
| 1 年前 | ||
[mlir][sparse] implement direct IR alloc/empty/new for non-permutations (#72585) This change implements the correct *level* sizes set up for the direct IR codegen fields in the sparse storage scheme. This brings libgen and codegen together again. This is step 3 out of 3 to make sparse_tensor.new work for BSR | 2 年前 | |
[mlir][sparse] Migrate tests to use new syntax (#66543) **COO** lvlTypes = [ "compressed_nu", "singleton" ] to map = (d0, d1) -> (d0 : compressed(nonunique), d1 : singleton) lvlTypes = [ "compressed_nu_no", "singleton_no" ] to map = (d0, d1) -> (d0 : compressed(nonunique, nonordered), d1 : singleton(nonordered)) **SortedCOO** lvlTypes = [ "compressed_nu", "singleton" ] to map = (d0, d1) -> (d0 : compressed(nonunique), d1 : singleton) **BCOO** lvlTypes = [ "dense", "compressed_hi_nu", "singleton" ] to map = (d0, d1, d2) -> (d0 : dense, d1 : compressed(nonunique, high), d2 : singleton) **BCSR** lvlTypes = [ "compressed", "compressed", "dense", "dense" ], dimToLvl = affine_map<(d0, d1) -> (d0 floordiv 2, d1 floordiv 3, d0 mod 2, d1 mod 3)> to map = ( i, j ) -> ( i floordiv 2 : compressed, j floordiv 3 : compressed, i mod 2 : dense, j mod 3 : dense ) **Tensor and other supported formats(e.g. CCC, CDC, CCCC)** Currently, ELL and slice are not supported yet in the new syntax and the CHECK tests will be updated once printing is set to output the new syntax. Previous PRs: #66146, #66309, #66443 | 2 年前 | |
[mlir][sparse] Migrate tests to use new syntax (#66146) lvlTypes = [ "compressed" ] to map = (d0) -> (d0 : compressed) lvlTypes = [ "dense" ] to map = (d0) -> (d0 : dense) | 2 年前 | |
[mlir][bufferization][NFC] Rename to_memref to to_buffer (#137180) As part of the work on transitioning bufferization dialect, ops, and associated logic to operate on newly added type interfaces (see 00eaff3e9c897c263a879416d0f151d7ca7eeaff), rename the bufferization.to_memref to highlight the generic nature of the op. Bufferization process produces buffers while memref is a builtin type rather than a generic term. Preserve the current API (to_buffer still produces a memref), however, as the new type interfaces are not used yet. | 1 年前 | |
[mlir][llvm] Implement ConstantLike for ZeroOp, UndefOp, PoisonOp (#93690) These act as constants and should be propagated whenever possible. It is safe to do so for mlir.undef and mlir.poison because they remain "dirty" through out their lifetime and can be duplicated, merged, etc. per the LangRef. Signed-off-by: Guy David <guy.david@nextsilicon.com> | 2 年前 | |
[mlir][sparse] deallocate tmp coo buffer generated during stage-spars… (#82017) …e-ops pass. | 2 年前 | |
[mlir][sparse] split post-sparsification-rewriting into two passes. (#70727) | 2 年前 | |
[mlir][sparse] implements tensor.insert on sparse tensors. (#70737) | 2 年前 | |
[mlir][sparse] Migrate tests to use new syntax (#66146) lvlTypes = [ "compressed" ] to map = (d0) -> (d0 : compressed) lvlTypes = [ "dense" ] to map = (d0) -> (d0 : dense) | 2 年前 | |
[mlir][bufferization][NFC] Rename to_memref to to_buffer (#137180) As part of the work on transitioning bufferization dialect, ops, and associated logic to operate on newly added type interfaces (see 00eaff3e9c897c263a879416d0f151d7ca7eeaff), rename the bufferization.to_memref to highlight the generic nature of the op. Bufferization process produces buffers while memref is a builtin type rather than a generic term. Preserve the current API (to_buffer still produces a memref), however, as the new type interfaces are not used yet. | 1 年前 | |
[mlir][sparse] use a consistent order between [dis]assembleOp and sto… (#84079) …rage layout. | 2 年前 | |
[mlir][sparse] allow for direct-out passing of sparse tensor buffers (#88327) In order to support various external frameworks (JAX vs PyTorch) we need a bit more flexibility in [dis]assembling external buffers to and from sparse tensors in MLIR land. This PR adds a direct-out option that avoids the rigid pre-allocated for copy-out semantics. Note that over time, we expect the [dis]assemble operations to converge into something that supports all sorts of external frameworks. Until then, this option helps in experimenting with different options. | 2 年前 | |
[mlir][sparse] Use variable instead of inlining sparse encoding (#72561) Example: #CSR = #sparse_tensor.encoding<{ map = (d0, d1) -> (d0 : dense, d1 : compressed), }> // CHECK: #[[$CSR.*]] = #sparse_tensor.encoding<{ map = (d0, d1) -> (d0 : dense, d1 : compressed) }> // CHECK-LABEL: func private @sparse_csr( // CHECK-SAME: tensor<?x?xf32, **#[[$CSR]]**>) func.func private @sparse_csr(tensor<?x?xf32, #CSR>) | 2 年前 | |
[mlir][sparse] fuse concat and extract_slice op if possible. (#89825) | 2 年前 | |
[mlir][sparse] clone a empty sparse tensor when fuse convert into pro… (#92158) …ducer. | 2 年前 | |
[mlir][bufferization][NFC] Rename to_memref to to_buffer (#137180) As part of the work on transitioning bufferization dialect, ops, and associated logic to operate on newly added type interfaces (see 00eaff3e9c897c263a879416d0f151d7ca7eeaff), rename the bufferization.to_memref to highlight the generic nature of the op. Bufferization process produces buffers while memref is a builtin type rather than a generic term. Preserve the current API (to_buffer still produces a memref), however, as the new type interfaces are not used yet. | 1 年前 | |
[mlir][IR] Improve error message when parsing incorrect type (#134984) Improve error messages when parsing an incorrect type. Before: invalid kind of type specified After: invalid kind of type specified: expected builtin.tensor, but found 'tensor<*xi32>' This error message is produced when a certain operand/result type is expected according to an op's TableGen definition, but a different type is parsed. Type constraints (which may have nice error messages) are checked after parsing a type. If an incorrect type is parsed, we never get to the point of printing type constraint error messages. This may discourage users from specifying C++ classes with type constraints. (Explicitly specifying C++ classes is beneficial because the auto-generated C++ code will have richer type information; explicit casts are unnecessary, etc.) See #134981 for an example where specifying additional type information with type constraints (e.g., LLVM_AnyVector) lead to worse error messages. Note: In order to generate a better error message, the parser must retrieve a type's name from the C++ class. TableGen-generated type classes always have a name field, but hand-written C++ type classes may not. The HasStaticName template was copied from DialectImplementation.h (HasStaticDialectName). | 1 年前 | |
[mlir][sparse] Add verification for explicit/implicit value (#90111) 1. Verify that the type of explicit/implicit values should be the same as the tensor element type. 2. Verify that implicit value could only be zero. 3. Verify that explicit/implicit values should be numeric. 4. Fix the type change issue caused by SparseTensorType(enc). | 2 年前 | |
[mlir][sparse] add parallelization options to mini pipeline (#104233) | 1 年前 | |
[mlir][Vector] Remove vector.extractelement/insertelement from sparse vectorizer (#143270) This PR is part of the last step to remove vector.extractelement and vector.insertelement ops. RFC: https://discourse.llvm.org/t/rfc-psa-remove-vector-extractelement-and-vector-insertelement-ops-in-favor-of-vector-extract-and-vector-insert-ops It updates the Sparse Vectorizer to use vector.extract and vector.insert instead of vector.extractelement and vector.insertelement. | 1 年前 | |
| 1 年前 | ||
Changed the phrase sparse-compiler to sparsifier in comments (#71578) When the Powers That Be decided that the name "sparse compiler" should be changed to "sparsifier", we negected to change some of the comments in the code; this pull request completes the name change. | 2 年前 | |
[mlir][linalg][bufferize] Fix element-wise access optimization for sparse tensors (#87305) linalg.generic ops with sparse tensors do not necessarily bufferize to element-wise access, because insertions into a sparse tensor may change the layout of (or reallocate) the underlying sparse data structures. | 2 年前 | |
[mlir][sparse] Use variable instead of inlining sparse encoding (#72561) Example: #CSR = #sparse_tensor.encoding<{ map = (d0, d1) -> (d0 : dense, d1 : compressed), }> // CHECK: #[[$CSR.*]] = #sparse_tensor.encoding<{ map = (d0, d1) -> (d0 : dense, d1 : compressed) }> // CHECK-LABEL: func private @sparse_csr( // CHECK-SAME: tensor<?x?xf32, **#[[$CSR]]**>) func.func private @sparse_csr(tensor<?x?xf32, #CSR>) | 2 年前 | |
[mlir][sparse] use a consistent order between [dis]assembleOp and sto… (#84079) …rage layout. | 2 年前 | |
[mlir][sparse] Use variable instead of inlining sparse encoding (#72561) Example: #CSR = #sparse_tensor.encoding<{ map = (d0, d1) -> (d0 : dense, d1 : compressed), }> // CHECK: #[[$CSR.*]] = #sparse_tensor.encoding<{ map = (d0, d1) -> (d0 : dense, d1 : compressed) }> // CHECK-LABEL: func private @sparse_csr( // CHECK-SAME: tensor<?x?xf32, **#[[$CSR]]**>) func.func private @sparse_csr(tensor<?x?xf32, #CSR>) | 2 年前 | |
[mlir][sparse] Use variable instead of inlining sparse encoding (#72561) Example: #CSR = #sparse_tensor.encoding<{ map = (d0, d1) -> (d0 : dense, d1 : compressed), }> // CHECK: #[[$CSR.*]] = #sparse_tensor.encoding<{ map = (d0, d1) -> (d0 : dense, d1 : compressed) }> // CHECK-LABEL: func private @sparse_csr( // CHECK-SAME: tensor<?x?xf32, **#[[$CSR]]**>) func.func private @sparse_csr(tensor<?x?xf32, #CSR>) | 2 年前 | |
[mlir][sparse] Use variable instead of inlining sparse encoding (#72561) Example: #CSR = #sparse_tensor.encoding<{ map = (d0, d1) -> (d0 : dense, d1 : compressed), }> // CHECK: #[[$CSR.*]] = #sparse_tensor.encoding<{ map = (d0, d1) -> (d0 : dense, d1 : compressed) }> // CHECK-LABEL: func private @sparse_csr( // CHECK-SAME: tensor<?x?xf32, **#[[$CSR]]**>) func.func private @sparse_csr(tensor<?x?xf32, #CSR>) | 2 年前 | |
[mlir][sparse] introduce sparse_tensor.coiterate operation. (#101100) This PR introduces sparse_tensor.coiterate operation, which represents a loop that traverses multiple sparse iteration space. | 1 年前 | |
[mlir][sparse] allow multiple COO segments in sparse encodings. (#91786) **NOTE**: we still have implementation holes when handling multiple COO segments in the encoding. But the format should be considered to be legal. | 2 年前 | |
[mlir][SCF] Add scf.index_switch support for populateSCFStructuralTypeConversionsAndLegality (#160344) In a downstream project, there is a need for a type conversion pattern for scf.index_switch operation. A test is added into mlir/test/Dialect/SparseTensor/scf_1_N_conversion.mlir (not sure this functionality is really required for sparse tensors, but the test showcase that the new conversion pattern is functional) | 10 个月前 | |
[mlir][sparse] Use variable instead of inlining sparse encoding (#72561) Example: #CSR = #sparse_tensor.encoding<{ map = (d0, d1) -> (d0 : dense, d1 : compressed), }> // CHECK: #[[$CSR.*]] = #sparse_tensor.encoding<{ map = (d0, d1) -> (d0 : dense, d1 : compressed) }> // CHECK-LABEL: func private @sparse_csr( // CHECK-SAME: tensor<?x?xf32, **#[[$CSR]]**>) func.func private @sparse_csr(tensor<?x?xf32, #CSR>) | 2 年前 | |
[mlir][bufferization][NFC] Rename to_memref to to_buffer (#137180) As part of the work on transitioning bufferization dialect, ops, and associated logic to operate on newly added type interfaces (see 00eaff3e9c897c263a879416d0f151d7ca7eeaff), rename the bufferization.to_memref to highlight the generic nature of the op. Bufferization process produces buffers while memref is a builtin type rather than a generic term. Preserve the current API (to_buffer still produces a memref), however, as the new type interfaces are not used yet. | 1 年前 | |
[mlir][bufferization][NFC] Rename to_memref to to_buffer (#137180) As part of the work on transitioning bufferization dialect, ops, and associated logic to operate on newly added type interfaces (see 00eaff3e9c897c263a879416d0f151d7ca7eeaff), rename the bufferization.to_memref to highlight the generic nature of the op. Bufferization process produces buffers while memref is a builtin type rather than a generic term. Preserve the current API (to_buffer still produces a memref), however, as the new type interfaces are not used yet. | 1 年前 | |
[mlir][bufferization][NFC] Rename to_memref to to_buffer (#137180) As part of the work on transitioning bufferization dialect, ops, and associated logic to operate on newly added type interfaces (see 00eaff3e9c897c263a879416d0f151d7ca7eeaff), rename the bufferization.to_memref to highlight the generic nature of the op. Bufferization process produces buffers while memref is a builtin type rather than a generic term. Preserve the current API (to_buffer still produces a memref), however, as the new type interfaces are not used yet. | 1 年前 | |
[mlir][bufferization][NFC] Rename to_memref to to_buffer (#137180) As part of the work on transitioning bufferization dialect, ops, and associated logic to operate on newly added type interfaces (see 00eaff3e9c897c263a879416d0f151d7ca7eeaff), rename the bufferization.to_memref to highlight the generic nature of the op. Bufferization process produces buffers while memref is a builtin type rather than a generic term. Preserve the current API (to_buffer still produces a memref), however, as the new type interfaces are not used yet. | 1 年前 | |
[mlir][bufferization][NFC] Rename to_memref to to_buffer (#137180) As part of the work on transitioning bufferization dialect, ops, and associated logic to operate on newly added type interfaces (see 00eaff3e9c897c263a879416d0f151d7ca7eeaff), rename the bufferization.to_memref to highlight the generic nature of the op. Bufferization process produces buffers while memref is a builtin type rather than a generic term. Preserve the current API (to_buffer still produces a memref), however, as the new type interfaces are not used yet. | 1 年前 | |
[mlir][bufferization][NFC] Rename to_memref to to_buffer (#137180) As part of the work on transitioning bufferization dialect, ops, and associated logic to operate on newly added type interfaces (see 00eaff3e9c897c263a879416d0f151d7ca7eeaff), rename the bufferization.to_memref to highlight the generic nature of the op. Bufferization process produces buffers while memref is a builtin type rather than a generic term. Preserve the current API (to_buffer still produces a memref), however, as the new type interfaces are not used yet. | 1 年前 | |
[mlir][sparse] support sparsifying sparse kernels to sparse-iterator-based loop (#95858) | 2 年前 | |
[mlir][sparse] support sparsifying sparse kernels to sparse-iterator-based loop (#95858) | 2 年前 | |
[mlir][sparse] reuse tensor.insert operation to insert elements into … (#84987) …a sparse tensor. | 2 年前 | |
[mlir][sparse] schedule sparse kernels in a separate pass from sparsification. (#72423) | 2 年前 | |
[mlir][sparse] Use variable instead of inlining sparse encoding (#72561) Example: #CSR = #sparse_tensor.encoding<{ map = (d0, d1) -> (d0 : dense, d1 : compressed), }> // CHECK: #[[$CSR.*]] = #sparse_tensor.encoding<{ map = (d0, d1) -> (d0 : dense, d1 : compressed) }> // CHECK-LABEL: func private @sparse_csr( // CHECK-SAME: tensor<?x?xf32, **#[[$CSR]]**>) func.func private @sparse_csr(tensor<?x?xf32, #CSR>) | 2 年前 | |
[mlir][sparse] support sparsifying sparse kernels to sparse-iterator-based loop (#95858) | 2 年前 | |
[mlir][sparse] setup SparseIterator to help generating code to traverse a sparse tensor level. (#78345) | 2 年前 | |
[mlir][bufferization][NFC] Rename to_memref to to_buffer (#137180) As part of the work on transitioning bufferization dialect, ops, and associated logic to operate on newly added type interfaces (see 00eaff3e9c897c263a879416d0f151d7ca7eeaff), rename the bufferization.to_memref to highlight the generic nature of the op. Bufferization process produces buffers while memref is a builtin type rather than a generic term. Preserve the current API (to_buffer still produces a memref), however, as the new type interfaces are not used yet. | 1 年前 | |
[mlir][bufferization][NFC] Rename to_memref to to_buffer (#137180) As part of the work on transitioning bufferization dialect, ops, and associated logic to operate on newly added type interfaces (see 00eaff3e9c897c263a879416d0f151d7ca7eeaff), rename the bufferization.to_memref to highlight the generic nature of the op. Bufferization process produces buffers while memref is a builtin type rather than a generic term. Preserve the current API (to_buffer still produces a memref), however, as the new type interfaces are not used yet. | 1 年前 | |
[mlir][sparse] reuse tensor.insert operation to insert elements into … (#84987) …a sparse tensor. | 2 年前 | |
[mlir][bufferization][NFC] Rename to_memref to to_buffer (#137180) As part of the work on transitioning bufferization dialect, ops, and associated logic to operate on newly added type interfaces (see 00eaff3e9c897c263a879416d0f151d7ca7eeaff), rename the bufferization.to_memref to highlight the generic nature of the op. Bufferization process produces buffers while memref is a builtin type rather than a generic term. Preserve the current API (to_buffer still produces a memref), however, as the new type interfaces are not used yet. | 1 年前 | |
[mlir][sparse] expose emit strategy option to mini pipeline (#96238) | 2 年前 | |
[mlir][sparse] introduce sparse_tensor.iterate operation (#88955) A sparse_tensor.iterate iterates over a sparse iteration space extracted from sparse_tensor.extract_iteration_space operation introduced in https://github.com/llvm/llvm-project/pull/88554. | 2 年前 | |
[mlir][bufferization][NFC] Rename to_memref to to_buffer (#137180) As part of the work on transitioning bufferization dialect, ops, and associated logic to operate on newly added type interfaces (see 00eaff3e9c897c263a879416d0f151d7ca7eeaff), rename the bufferization.to_memref to highlight the generic nature of the op. Bufferization process produces buffers while memref is a builtin type rather than a generic term. Preserve the current API (to_buffer still produces a memref), however, as the new type interfaces are not used yet. | 1 年前 | |
[mlir][bufferization][NFC] Rename to_memref to to_buffer (#137180) As part of the work on transitioning bufferization dialect, ops, and associated logic to operate on newly added type interfaces (see 00eaff3e9c897c263a879416d0f151d7ca7eeaff), rename the bufferization.to_memref to highlight the generic nature of the op. Bufferization process produces buffers while memref is a builtin type rather than a generic term. Preserve the current API (to_buffer still produces a memref), however, as the new type interfaces are not used yet. | 1 年前 | |
[mlir][bufferization][NFC] Rename to_memref to to_buffer (#137180) As part of the work on transitioning bufferization dialect, ops, and associated logic to operate on newly added type interfaces (see 00eaff3e9c897c263a879416d0f151d7ca7eeaff), rename the bufferization.to_memref to highlight the generic nature of the op. Bufferization process produces buffers while memref is a builtin type rather than a generic term. Preserve the current API (to_buffer still produces a memref), however, as the new type interfaces are not used yet. | 1 年前 | |
[mlir][bufferization][NFC] Rename to_memref to to_buffer (#137180) As part of the work on transitioning bufferization dialect, ops, and associated logic to operate on newly added type interfaces (see 00eaff3e9c897c263a879416d0f151d7ca7eeaff), rename the bufferization.to_memref to highlight the generic nature of the op. Bufferization process produces buffers while memref is a builtin type rather than a generic term. Preserve the current API (to_buffer still produces a memref), however, as the new type interfaces are not used yet. | 1 年前 | |
[mlir][bufferization][NFC] Rename to_memref to to_buffer (#137180) As part of the work on transitioning bufferization dialect, ops, and associated logic to operate on newly added type interfaces (see 00eaff3e9c897c263a879416d0f151d7ca7eeaff), rename the bufferization.to_memref to highlight the generic nature of the op. Bufferization process produces buffers while memref is a builtin type rather than a generic term. Preserve the current API (to_buffer still produces a memref), however, as the new type interfaces are not used yet. | 1 年前 | |
[mlir][sparse] support sparsifying sparse kernels to sparse-iterator-based loop (#95858) | 2 年前 | |
[mlir][sparse] Support explicit/implicit value for complex type (#90771) | 2 年前 | |
[mlir][bufferization][NFC] Rename to_memref to to_buffer (#137180) As part of the work on transitioning bufferization dialect, ops, and associated logic to operate on newly added type interfaces (see 00eaff3e9c897c263a879416d0f151d7ca7eeaff), rename the bufferization.to_memref to highlight the generic nature of the op. Bufferization process produces buffers while memref is a builtin type rather than a generic term. Preserve the current API (to_buffer still produces a memref), however, as the new type interfaces are not used yet. | 1 年前 | |
[mlir][sparse] support sparsifying sparse kernels to sparse-iterator-based loop (#95858) | 2 年前 | |
[mlir][bufferization][NFC] Rename to_memref to to_buffer (#137180) As part of the work on transitioning bufferization dialect, ops, and associated logic to operate on newly added type interfaces (see 00eaff3e9c897c263a879416d0f151d7ca7eeaff), rename the bufferization.to_memref to highlight the generic nature of the op. Bufferization process produces buffers while memref is a builtin type rather than a generic term. Preserve the current API (to_buffer still produces a memref), however, as the new type interfaces are not used yet. | 1 年前 | |
[mlir][bufferization][NFC] Rename to_memref to to_buffer (#137180) As part of the work on transitioning bufferization dialect, ops, and associated logic to operate on newly added type interfaces (see 00eaff3e9c897c263a879416d0f151d7ca7eeaff), rename the bufferization.to_memref to highlight the generic nature of the op. Bufferization process produces buffers while memref is a builtin type rather than a generic term. Preserve the current API (to_buffer still produces a memref), however, as the new type interfaces are not used yet. | 1 年前 | |
[mlir][sparse] schedule sparse kernels in a separate pass from sparsification. (#72423) | 2 年前 | |
[mlir][bufferization][NFC] Rename to_memref to to_buffer (#137180) As part of the work on transitioning bufferization dialect, ops, and associated logic to operate on newly added type interfaces (see 00eaff3e9c897c263a879416d0f151d7ca7eeaff), rename the bufferization.to_memref to highlight the generic nature of the op. Bufferization process produces buffers while memref is a builtin type rather than a generic term. Preserve the current API (to_buffer still produces a memref), however, as the new type interfaces are not used yet. | 1 年前 | |
[mlir][bufferization][NFC] Rename to_memref to to_buffer (#137180) As part of the work on transitioning bufferization dialect, ops, and associated logic to operate on newly added type interfaces (see 00eaff3e9c897c263a879416d0f151d7ca7eeaff), rename the bufferization.to_memref to highlight the generic nature of the op. Bufferization process produces buffers while memref is a builtin type rather than a generic term. Preserve the current API (to_buffer still produces a memref), however, as the new type interfaces are not used yet. | 1 年前 | |
[mlir][bufferization][NFC] Rename to_memref to to_buffer (#137180) As part of the work on transitioning bufferization dialect, ops, and associated logic to operate on newly added type interfaces (see 00eaff3e9c897c263a879416d0f151d7ca7eeaff), rename the bufferization.to_memref to highlight the generic nature of the op. Bufferization process produces buffers while memref is a builtin type rather than a generic term. Preserve the current API (to_buffer still produces a memref), however, as the new type interfaces are not used yet. | 1 年前 | |
[mlir][sparse] reuse tensor.insert operation to insert elements into … (#84987) …a sparse tensor. | 2 年前 | |
[mlir][sparse] recognize ReLu operation during sparsification (#92016) This is a proof of concept recognition of the most basic forms of ReLu operations, used to show-case sparsification of end-to-end PyTorch models. In the long run, we must avoid lowering such constructs too early (with this need for raising them back). See discussion at https://discourse.llvm.org/t/min-max-abs-relu-recognition-starter-project/78918 | 2 年前 | |
[mlir][sparse] support sparsifying sparse kernels to sparse-iterator-based loop (#95858) | 2 年前 | |
[mlir][bufferization][NFC] Rename to_memref to to_buffer (#137180) As part of the work on transitioning bufferization dialect, ops, and associated logic to operate on newly added type interfaces (see 00eaff3e9c897c263a879416d0f151d7ca7eeaff), rename the bufferization.to_memref to highlight the generic nature of the op. Bufferization process produces buffers while memref is a builtin type rather than a generic term. Preserve the current API (to_buffer still produces a memref), however, as the new type interfaces are not used yet. | 1 年前 | |
[mlir][bufferization][NFC] Rename to_memref to to_buffer (#137180) As part of the work on transitioning bufferization dialect, ops, and associated logic to operate on newly added type interfaces (see 00eaff3e9c897c263a879416d0f151d7ca7eeaff), rename the bufferization.to_memref to highlight the generic nature of the op. Bufferization process produces buffers while memref is a builtin type rather than a generic term. Preserve the current API (to_buffer still produces a memref), however, as the new type interfaces are not used yet. | 1 年前 | |
[mlir][bufferization][NFC] Rename to_memref to to_buffer (#137180) As part of the work on transitioning bufferization dialect, ops, and associated logic to operate on newly added type interfaces (see 00eaff3e9c897c263a879416d0f151d7ca7eeaff), rename the bufferization.to_memref to highlight the generic nature of the op. Bufferization process produces buffers while memref is a builtin type rather than a generic term. Preserve the current API (to_buffer still produces a memref), however, as the new type interfaces are not used yet. | 1 年前 | |
[mlir][sparse] implement lowering rules for ExtractIterSpaceOp. (#89143) **DO NOT MERGE** until https://github.com/llvm/llvm-project/pull/89003 | 2 年前 | |
[mlir][Transforms] GreedyPatternRewriteDriver: Do not CSE constants during iterations (#75897) The GreedyPatternRewriteDriver tries to iteratively fold ops and apply rewrite patterns to ops. It has special handling for constants: they are CSE'd and sometimes moved to parent regions to allow for additional CSE'ing. This happens in OperationFolder. To allow for efficient CSE'ing, OperationFolder maintains an internal lookup data structure to find the existing constant ops with the same value for each IsolatedFromAbove region: c++ /// A mapping between an insertion region and the constants that have been /// created within it. DenseMap<Region *, ConstantMap> foldScopes; Rewrite patterns are allowed to modify operations. In particular, they may move operations (including constants) from one region to another one. Such an IR rewrite can make the above lookup data structure inconsistent. We encountered such a bug in a downstream project. This bug materialized in the form of an op that uses the result of a constant op from a different IsolatedFromAbove region (that is not accessible). This commit changes the behavior of the GreedyPatternRewriteDriver such that OperationFolder is used to CSE constants at the beginning of each iteration (as the worklist is populated), but no longer during an iteration. OperationFolder is no longer used after populating the worklist, so we do not have to care about inconsistent state in the OperationFolder due to IR rewrites. The GreedyPatternRewriteDriver now performs the op folding by itself instead of calling OperationFolder::tryToFold. This change changes the order of constant ops in test cases, but not the region in which they appear. All broken test cases were fixed by turning CHECK into CHECK-DAG. Alternatives considered: The state of OperationFolder could be partially invalidated with every notifyOperationModified notification. That is more fragile than the solution in this commit because incorrect rewriter API usage can lead to missing notifications and hard-to-debug IsolatedFromAbove violations. (It did not fix the above mention bug in a downstream project, which could be due to incorrect rewriter API usage or due to another conceptual problem that I missed.) Moreover, ops are frequently getting modified during a greedy pattern rewrite, so we would likely keep invalidating large parts of the state of OperationFolder over and over. Migration guide: Turn CHECK into CHECK-DAG in test cases. Constant ops are no longer folded during a greedy pattern rewrite. If you rely on folding (and rematerialization) of constant ops during a greedy pattern rewrite, turn the folder into a pattern. | 2 年前 | |
[mlir][sparse] support sparsifying sparse kernels to sparse-iterator-based loop (#95858) | 2 年前 | |
[mlir][sparse] reuse tensor.insert operation to insert elements into … (#84987) …a sparse tensor. | 2 年前 | |
[mlir][Vector] Remove vector.extractelement/insertelement from sparse vectorizer (#143270) This PR is part of the last step to remove vector.extractelement and vector.insertelement ops. RFC: https://discourse.llvm.org/t/rfc-psa-remove-vector-extractelement-and-vector-insertelement-ops-in-favor-of-vector-extract-and-vector-insert-ops It updates the Sparse Vectorizer to use vector.extract and vector.insert instead of vector.extractelement and vector.insertelement. | 1 年前 | |
[mlir][Vector] Remove vector.extractelement/insertelement from sparse vectorizer (#143270) This PR is part of the last step to remove vector.extractelement and vector.insertelement ops. RFC: https://discourse.llvm.org/t/rfc-psa-remove-vector-extractelement-and-vector-insertelement-ops-in-favor-of-vector-extract-and-vector-insert-ops It updates the Sparse Vectorizer to use vector.extract and vector.insert instead of vector.extractelement and vector.insertelement. | 1 年前 | |
Changed all code and comments that used the phrase "sparse compiler" to instead use "sparsifier" (#71875) The changes in this p.r. mostly center around the tests that use the flag sparse_compiler (also: sparse-compiler). | 2 年前 | |
[mlir][bufferization][NFC] Rename to_memref to to_buffer (#137180) As part of the work on transitioning bufferization dialect, ops, and associated logic to operate on newly added type interfaces (see 00eaff3e9c897c263a879416d0f151d7ca7eeaff), rename the bufferization.to_memref to highlight the generic nature of the op. Bufferization process produces buffers while memref is a builtin type rather than a generic term. Preserve the current API (to_buffer still produces a memref), however, as the new type interfaces are not used yet. | 1 年前 | |
[mlir][sparse] made sparse vectorizer more robust on position of invariants (#80766) Because the sparse vectorizer relies on the code coming out of the sparsifier, the "patterns" are not always made very general. However, a recent change in the generated code revealed an obvious situation where the subscript analysis could be made a bit more robust. Fixes: https://github.com/llvm/llvm-project/issues/79897 | 2 年前 | |
[mlir][sparse] schedule sparse kernels in a separate pass from sparsification. (#72423) | 2 年前 | |
[mlir][Vector] Fold vector.constant_mask to SplatElementsAttr (#146724) Adds a folder to vector.constant_mask to fold to SplatElementsAttr when possible | 1 年前 | |
[mlir][LLVM] Switch undef for poison for uninitialized values (#125629) LLVM itself is generally moving away from using undef and towards using poison, to the point of having a lint that caches new uses of undef in tests. In order to not trip the lint on new patterns and to conform to the evolution of LLVM - Rename valious ::undef() methods on StructBuilder subclasses to ::poison() - Audit the uses of UndefOp in the MLIR libraries and replace almost all of them with PoisonOp The remaining uses of undef are initializing uninitialized memrefs, explicit conversions to undef from SPIR-V, and a few cases in AMDGPUToROCDL where usage like %v = insertelement <M x iN> undef, iN %v, i32 0 %arg = bitcast <M x iN> %v to i(M * N) is used to handle "i32" arguments that are are really packed vectors of smaller types that won't always be fully initialized. | 1 年前 | |
[mlir][bufferization][NFC] Rename to_memref to to_buffer (#137180) As part of the work on transitioning bufferization dialect, ops, and associated logic to operate on newly added type interfaces (see 00eaff3e9c897c263a879416d0f151d7ca7eeaff), rename the bufferization.to_memref to highlight the generic nature of the op. Bufferization process produces buffers while memref is a builtin type rather than a generic term. Preserve the current API (to_buffer still produces a memref), however, as the new type interfaces are not used yet. | 1 年前 | |
[mlir][bufferization][NFC] Rename to_memref to to_buffer (#137180) As part of the work on transitioning bufferization dialect, ops, and associated logic to operate on newly added type interfaces (see 00eaff3e9c897c263a879416d0f151d7ca7eeaff), rename the bufferization.to_memref to highlight the generic nature of the op. Bufferization process produces buffers while memref is a builtin type rather than a generic term. Preserve the current API (to_buffer still produces a memref), however, as the new type interfaces are not used yet. | 1 年前 | |
[mlir][sparse] ensure [dis]assembler wrapper methods properly inline (#81907) | 2 年前 | |
[mlir] introduce debug transform dialect extension (#77595) Introduce a new extension for simple print-debugging of the transform dialect scripts. The initial version of this extension consists of two ops that are printing the payload objects associated with transform dialect values. Similar ops were already available in the test extenion and several downstream projects, and were extensively used for testing. | 2 年前 | |
[mlir][sparse] schedule sparse kernels in a separate pass from sparsification. (#72423) | 2 年前 | |
[mlir][bufferization][NFC] Rename to_memref to to_buffer (#137180) As part of the work on transitioning bufferization dialect, ops, and associated logic to operate on newly added type interfaces (see 00eaff3e9c897c263a879416d0f151d7ca7eeaff), rename the bufferization.to_memref to highlight the generic nature of the op. Bufferization process produces buffers while memref is a builtin type rather than a generic term. Preserve the current API (to_buffer still produces a memref), however, as the new type interfaces are not used yet. | 1 年前 | |
[mlir][Vector] Remove vector.extractelement/insertelement from sparse vectorizer (#143270) This PR is part of the last step to remove vector.extractelement and vector.insertelement ops. RFC: https://discourse.llvm.org/t/rfc-psa-remove-vector-extractelement-and-vector-insertelement-ops-in-favor-of-vector-extract-and-vector-insert-ops It updates the Sparse Vectorizer to use vector.extract and vector.insert instead of vector.extractelement and vector.insertelement. | 1 年前 |
| 文件 | 最后提交记录 | 最后更新时间 |
|---|---|---|
| 1 年前 | ||
| 2 年前 | ||
| 2 年前 | ||
| 2 年前 | ||
| 1 年前 | ||
| 2 年前 | ||
| 2 年前 | ||
| 2 年前 | ||
| 1 年前 | ||
| 2 年前 | ||
| 2 年前 | ||
| 2 年前 | ||
| 2 年前 | ||
| 2 年前 | ||
| 1 年前 | ||
| 2 年前 | ||
| 2 年前 | ||
| 2 年前 | ||
| 2 年前 | ||
| 2 年前 | ||
| 1 年前 | ||
| 1 年前 | ||
| 2 年前 | ||
| 1 年前 | ||
| 1 年前 | ||
| 1 年前 | ||
| 2 年前 | ||
| 2 年前 | ||
| 2 年前 | ||
| 2 年前 | ||
| 2 年前 | ||
| 2 年前 | ||
| 2 年前 | ||
| 1 年前 | ||
| 2 年前 | ||
| 10 个月前 | ||
| 2 年前 | ||
| 1 年前 | ||
| 1 年前 | ||
| 1 年前 | ||
| 1 年前 | ||
| 1 年前 | ||
| 1 年前 | ||
| 2 年前 | ||
| 2 年前 | ||
| 2 年前 | ||
| 2 年前 | ||
| 2 年前 | ||
| 2 年前 | ||
| 2 年前 | ||
| 1 年前 | ||
| 1 年前 | ||
| 2 年前 | ||
| 1 年前 | ||
| 2 年前 | ||
| 2 年前 | ||
| 1 年前 | ||
| 1 年前 | ||
| 1 年前 | ||
| 1 年前 | ||
| 1 年前 | ||
| 2 年前 | ||
| 2 年前 | ||
| 1 年前 | ||
| 2 年前 | ||
| 1 年前 | ||
| 1 年前 | ||
| 2 年前 | ||
| 1 年前 | ||
| 1 年前 | ||
| 1 年前 | ||
| 2 年前 | ||
| 2 年前 | ||
| 2 年前 | ||
| 1 年前 | ||
| 1 年前 | ||
| 1 年前 | ||
| 2 年前 | ||
| 2 年前 | ||
| 2 年前 | ||
| 2 年前 | ||
| 1 年前 | ||
| 1 年前 | ||
| 2 年前 | ||
| 1 年前 | ||
| 2 年前 | ||
| 2 年前 | ||
| 1 年前 | ||
| 1 年前 | ||
| 1 年前 | ||
| 1 年前 | ||
| 2 年前 | ||
| 2 年前 | ||
| 2 年前 | ||
| 1 年前 | ||
| 1 年前 |