Lines Matching defs:builder
54 Type mlir::sparse_tensor::getOverheadType(Builder &builder, OverheadType ot) {
57 return builder.getIndexType();
59 return builder.getIntegerType(64);
61 return builder.getIntegerType(32);
63 return builder.getIntegerType(16);
65 return builder.getIntegerType(8);
81 // `STEA::get{Pos,Crd}Type` methods agree with `getOverheadType(builder,
151 Value sparse_tensor::genCast(OpBuilder &builder, Location loc, Value value,
159 return builder.create<arith::IndexCastOp>(loc, dstTp, value);
163 return mlir::convertScalarToDtype(builder, loc, value, dstTp, isUnsignedCast);
166 Value sparse_tensor::genScalarToTensor(OpBuilder &builder, Location loc,
171 elem = sparse_tensor::genCast(builder, loc, elem, rtp.getElementType());
172 return builder.create<tensor::FromElementsOp>(loc, rtp, elem);
174 return sparse_tensor::genCast(builder, loc, elem, dstTp);
177 Value sparse_tensor::genIndexLoad(OpBuilder &builder, Location loc, Value mem,
179 Value load = builder.create<memref::LoadOp>(loc, mem, s);
182 load = builder.create<arith::ExtUIOp>(loc, builder.getI64Type(), load);
184 builder.create<arith::IndexCastOp>(loc, builder.getIndexType(), load);
189 mlir::TypedAttr mlir::sparse_tensor::getOneAttr(Builder &builder, Type tp) {
191 return builder.getFloatAttr(tp, 1.0);
193 return builder.getIndexAttr(1);
195 return builder.getIntegerAttr(tp, APInt(intTp.getWidth(), 1));
198 if (auto one = getOneAttr(builder, shapedTp.getElementType()))
204 Value mlir::sparse_tensor::genIsNonzero(OpBuilder &builder, mlir::Location loc,
207 Value zero = constantZero(builder, loc, tp);
209 return builder.create<arith::CmpFOp>(loc, arith::CmpFPredicate::UNE, v,
212 return builder.create<arith::CmpIOp>(loc, arith::CmpIPredicate::ne, v,
215 return builder.create<complex::NotEqualOp>(loc, v, zero);
220 OpBuilder &builder, Location loc, SmallVectorImpl<Value> &dstShape,
227 auto dstDim = constantIndex(builder, loc, 1);
229 dstDim = builder.create<arith::MulIOp>(loc, dstDim, srcShape[i]);
261 Value productVal = constantIndex(builder, loc, product);
263 builder.create<arith::DivUIOp>(loc, srcDim, productVal);
267 dstShape.push_back(constantIndex(builder, loc, staticDstShape[j]));
276 OpBuilder &builder, Location loc,
290 Value linear = constantIndex(builder, loc, 1);
292 linear = builder.create<arith::MulIOp>(loc, linear, sizes[j]);
300 linear = builder.create<arith::DivUIOp>(loc, linear, sizes[j]);
302 const Value mul = builder.create<arith::MulIOp>(loc, srcCvs[j], linear);
303 val = val ? builder.create<arith::AddIOp>(loc, val, mul) : mul;
306 val = builder.create<arith::DivUIOp>(loc, val, linear);
309 val = builder.create<arith::RemUIOp>(loc, old, linear);
344 OpBuilder &builder, Location loc, StringRef name, TypeRange resultType,
346 auto module = builder.getBlock()->getParentOp()->getParentOfType<ModuleOp>();
349 return builder.create<func::CallOp>(loc, resultType, fn, operands);
356 Type mlir::sparse_tensor::getOpaquePointerType(Builder &builder) {
357 return getOpaquePointerType(builder.getContext());
360 Value mlir::sparse_tensor::genAlloca(OpBuilder &builder, Location loc,
364 return builder.create<memref::AllocaOp>(loc, memTp);
366 return genAlloca(builder, loc, constantIndex(builder, loc, sz), tp);
369 Value mlir::sparse_tensor::genAlloca(OpBuilder &builder, Location loc, Value sz,
372 return builder.create<memref::AllocaOp>(loc, memTp, ValueRange{sz});
375 Value mlir::sparse_tensor::genAllocaScalar(OpBuilder &builder, Location loc,
377 return builder.create<memref::AllocaOp>(loc, MemRefType::get({}, tp));
380 Value mlir::sparse_tensor::allocaBuffer(OpBuilder &builder, Location loc,
384 Value buffer = genAlloca(builder, loc, sz, values[0].getType());
386 Value idx = constantIndex(builder, loc, i);
387 builder.create<memref::StoreOp>(loc, values[i], buffer, idx);
392 Value mlir::sparse_tensor::allocDenseTensor(OpBuilder &builder, Location loc,
403 Value mem = builder.create<memref::AllocOp>(loc, memTp, dynamicSizes);
404 Value zero = constantZero(builder, loc, elemTp);
405 builder.create<linalg::FillOp>(loc, ValueRange{zero}, ValueRange{mem});
409 void mlir::sparse_tensor::deallocDenseTensor(OpBuilder &builder, Location loc,
411 builder.create<memref::DeallocOp>(loc, buffer);
414 void mlir::sparse_tensor::sizesFromSrc(OpBuilder &builder,
419 sizes.push_back(linalg::createOrFoldDimOp(builder, loc, src, d));
433 OpBuilder &builder, Location loc, SparseElementsAttr attr, AffineMap order,
436 order = builder.getMultiDimIdentityMap(attr.getType().getRank());
490 cvs.push_back(builder.create<arith::ConstantIndexOp>(loc, crd));
496 val = builder.create<complex::ConstantOp>(loc, attr.getElementType(),
500 val = builder.create<arith::ConstantOp>(loc, valAttr);
507 SmallVector<Value> sparse_tensor::loadAll(OpBuilder &builder, Location loc,
520 Value v = builder.create<memref::LoadOp>(loc, mem,
521 constantIndex(builder, loc, i));
523 v = builder.create<arith::AddIOp>(loc, v, offsetVal);
529 void sparse_tensor::storeAll(OpBuilder &builder, Location loc, Value mem,
542 ? builder.create<arith::AddIOp>(loc, v.value(), offsetVal)
544 builder.create<memref::StoreOp>(loc, w, mem,
545 constantIndex(builder, loc, v.index()));
550 sparse_tensor::genToMemref(OpBuilder &builder, Location loc, Value tensor) {
553 return builder.create<bufferization::ToMemrefOp>(loc, mTp, tensor)
557 Value sparse_tensor::createOrFoldSliceOffsetOp(OpBuilder &builder, Location loc,
563 return constantIndex(builder, loc, *offset);
564 return builder.create<ToSliceOffsetOp>(loc, tensor, APInt(64, dim));
567 Value sparse_tensor::createOrFoldSliceStrideOp(OpBuilder &builder, Location loc,
573 return constantIndex(builder, loc, *stride);
574 return builder.create<ToSliceStrideOp>(loc, tensor, APInt(64, dim));
577 Value sparse_tensor::genReader(OpBuilder &builder, Location loc,
588 dimSizesValues.push_back(constantIndex(builder, loc, s));
590 Value dimShapesBuffer = allocaBuffer(builder, loc, dimSizesValues);
594 Type opaqueTp = getOpaquePointerType(builder);
596 Value valTp = constantPrimaryTypeEncoding(builder, loc, eltTp);
598 createFuncCall(builder, loc, "createCheckedSparseTensorReader", opaqueTp,
606 Type indexTp = builder.getIndexType();
609 createFuncCall(builder, loc, "getSparseTensorReaderDimSizes", memTp,
616 dimSizesValues[d] = builder.create<memref::LoadOp>(
617 loc, dimSizesBuffer, constantIndex(builder, loc, d));
624 OpBuilder &builder, Location loc, SparseTensorType stt,
641 iotaValues.push_back(constantIndex(builder, loc, l));
644 dim2lvlBuffer = lvl2dimBuffer = allocaBuffer(builder, loc, iotaValues);
684 dim2lvlValues[l] = constantIndex(builder, loc, encodeDim(d, cf, cm));
693 lvlSz = builder.create<arith::DivUIOp>(loc, lvlSz,
694 constantIndex(builder, loc, cf));
696 lvlSz = constantIndex(builder, loc, cm);
727 lvl2dimValues[d] = constantIndex(builder, loc, encodeLvl(l, c, ll));
730 dim2lvlBuffer = allocaBuffer(builder, loc, dim2lvlValues);
731 lvl2dimBuffer = allocaBuffer(builder, loc, lvl2dimValues);
732 return allocaBuffer(builder, loc, lvlSizesValues); // lvlSizesBuffer