27c6d55cae
This PR adds the additional generation of what I'm calling "value
builders" (a term I'm not married to) that look like this:
```python
def empty(sizes, element_type, *, loc=None, ip=None):
return get_result_or_results(tensor.EmptyOp(sizes=sizes, element_type=element_type, loc=loc, ip=ip))
```
which instantiates a `tensor.EmptyOp` and then immediately grabs the
result (`OpResult`) and then returns that *instead of a handle to the
op*.
What's the point of adding these when `EmptyOp.result` already exists?
My claim/feeling/intuition is that eDSL users are more comfortable with
a value centric programming model (i.e., passing values as operands) as
opposed to an operator instantiation programming model. Thus this change
enables (or at least goes towards) the bindings supporting such a user
and use case. For example,
```python
i32 = IntegerType.get_signless(32)
...
ten1 = tensor.empty((10, 10), i32)
ten2 = tensor.empty((10, 10), i32)
ten3 = arith.addi(ten1, ten2)
```
Note, in order to present a "pythonic" API and enable "pythonic" eDSLs,
the generated identifiers (op names and operand names) are snake case
instead of camel case and thus `llvm::convertToSnakeFromCamelCase`
needed a small fix. Thus this PR is stacked on top of
https://github.com/llvm/llvm-project/pull/68375.
In addition, as a kind of victory lap, this PR adds a "rangefor" that
looks and acts exactly like python's `range` but emits `scf.for`.
160 lines
4.9 KiB
Python
160 lines
4.9 KiB
Python
# RUN: %PYTHON %s | FileCheck %s
|
|
|
|
from mlir.ir import *
|
|
from mlir.dialects import arith
|
|
from mlir.dialects import func
|
|
from mlir.dialects import scf
|
|
|
|
|
|
def constructAndPrintInModule(f):
|
|
print("\nTEST:", f.__name__)
|
|
with Context(), Location.unknown():
|
|
module = Module.create()
|
|
with InsertionPoint(module.body):
|
|
f()
|
|
print(module)
|
|
return f
|
|
|
|
|
|
# CHECK-LABEL: TEST: testSimpleLoop
|
|
@constructAndPrintInModule
|
|
def testSimpleLoop():
|
|
index_type = IndexType.get()
|
|
|
|
@func.FuncOp.from_py_func(index_type, index_type, index_type)
|
|
def simple_loop(lb, ub, step):
|
|
loop = scf.ForOp(lb, ub, step, [lb, lb])
|
|
with InsertionPoint(loop.body):
|
|
scf.YieldOp(loop.inner_iter_args)
|
|
return
|
|
|
|
|
|
# CHECK: func @simple_loop(%[[ARG0:.*]]: index, %[[ARG1:.*]]: index, %[[ARG2:.*]]: index)
|
|
# CHECK: scf.for %{{.*}} = %[[ARG0]] to %[[ARG1]] step %[[ARG2]]
|
|
# CHECK: iter_args(%[[I1:.*]] = %[[ARG0]], %[[I2:.*]] = %[[ARG0]])
|
|
# CHECK: scf.yield %[[I1]], %[[I2]]
|
|
|
|
|
|
# CHECK-LABEL: TEST: testInductionVar
|
|
@constructAndPrintInModule
|
|
def testInductionVar():
|
|
index_type = IndexType.get()
|
|
|
|
@func.FuncOp.from_py_func(index_type, index_type, index_type)
|
|
def induction_var(lb, ub, step):
|
|
loop = scf.ForOp(lb, ub, step, [lb])
|
|
with InsertionPoint(loop.body):
|
|
scf.YieldOp([loop.induction_variable])
|
|
return
|
|
|
|
|
|
# CHECK: func @induction_var(%[[ARG0:.*]]: index, %[[ARG1:.*]]: index, %[[ARG2:.*]]: index)
|
|
# CHECK: scf.for %[[IV:.*]] = %[[ARG0]] to %[[ARG1]] step %[[ARG2]]
|
|
# CHECK: scf.yield %[[IV]]
|
|
|
|
|
|
# CHECK-LABEL: TEST: testForSugar
|
|
@constructAndPrintInModule
|
|
def testForSugar():
|
|
index_type = IndexType.get()
|
|
range = scf.for_
|
|
|
|
@func.FuncOp.from_py_func(index_type, index_type, index_type)
|
|
def range_loop(lb, ub, step):
|
|
for i in range(lb, ub, step):
|
|
add = arith.addi(i, i)
|
|
scf.yield_([])
|
|
return
|
|
|
|
|
|
# CHECK: func.func @range_loop(%[[ARG0:.*]]: index, %[[ARG1:.*]]: index, %[[ARG2:.*]]: index) {
|
|
# CHECK: scf.for %[[IV:.*]] = %[[ARG0]] to %[[ARG1]] step %[[ARG2]]
|
|
# CHECK: %0 = arith.addi %[[IV]], %[[IV]] : index
|
|
# CHECK: }
|
|
# CHECK: return
|
|
# CHECK: }
|
|
|
|
|
|
@constructAndPrintInModule
|
|
def testOpsAsArguments():
|
|
index_type = IndexType.get()
|
|
callee = func.FuncOp("callee", ([], [index_type, index_type]), visibility="private")
|
|
f = func.FuncOp("ops_as_arguments", ([], []))
|
|
with InsertionPoint(f.add_entry_block()):
|
|
lb = arith.ConstantOp.create_index(0)
|
|
ub = arith.ConstantOp.create_index(42)
|
|
step = arith.ConstantOp.create_index(2)
|
|
iter_args = func.CallOp(callee, [])
|
|
loop = scf.ForOp(lb, ub, step, iter_args)
|
|
with InsertionPoint(loop.body):
|
|
scf.YieldOp(loop.inner_iter_args)
|
|
func.ReturnOp([])
|
|
|
|
|
|
# CHECK-LABEL: TEST: testOpsAsArguments
|
|
# CHECK: func private @callee() -> (index, index)
|
|
# CHECK: func @ops_as_arguments() {
|
|
# CHECK: %[[LB:.*]] = arith.constant 0
|
|
# CHECK: %[[UB:.*]] = arith.constant 42
|
|
# CHECK: %[[STEP:.*]] = arith.constant 2
|
|
# CHECK: %[[ARGS:.*]]:2 = call @callee()
|
|
# CHECK: scf.for %arg0 = %c0 to %c42 step %c2
|
|
# CHECK: iter_args(%{{.*}} = %[[ARGS]]#0, %{{.*}} = %[[ARGS]]#1)
|
|
# CHECK: scf.yield %{{.*}}, %{{.*}}
|
|
# CHECK: return
|
|
|
|
|
|
@constructAndPrintInModule
|
|
def testIfWithoutElse():
|
|
bool = IntegerType.get_signless(1)
|
|
i32 = IntegerType.get_signless(32)
|
|
|
|
@func.FuncOp.from_py_func(bool)
|
|
def simple_if(cond):
|
|
if_op = scf.IfOp(cond)
|
|
with InsertionPoint(if_op.then_block):
|
|
one = arith.ConstantOp(i32, 1)
|
|
add = arith.AddIOp(one, one)
|
|
scf.YieldOp([])
|
|
return
|
|
|
|
|
|
# CHECK: func @simple_if(%[[ARG0:.*]]: i1)
|
|
# CHECK: scf.if %[[ARG0:.*]]
|
|
# CHECK: %[[ONE:.*]] = arith.constant 1
|
|
# CHECK: %[[ADD:.*]] = arith.addi %[[ONE]], %[[ONE]]
|
|
# CHECK: return
|
|
|
|
|
|
@constructAndPrintInModule
|
|
def testIfWithElse():
|
|
bool = IntegerType.get_signless(1)
|
|
i32 = IntegerType.get_signless(32)
|
|
|
|
@func.FuncOp.from_py_func(bool)
|
|
def simple_if_else(cond):
|
|
if_op = scf.IfOp(cond, [i32, i32], hasElse=True)
|
|
with InsertionPoint(if_op.then_block):
|
|
x_true = arith.ConstantOp(i32, 0)
|
|
y_true = arith.ConstantOp(i32, 1)
|
|
scf.YieldOp([x_true, y_true])
|
|
with InsertionPoint(if_op.else_block):
|
|
x_false = arith.ConstantOp(i32, 2)
|
|
y_false = arith.ConstantOp(i32, 3)
|
|
scf.YieldOp([x_false, y_false])
|
|
add = arith.AddIOp(if_op.results[0], if_op.results[1])
|
|
return
|
|
|
|
|
|
# CHECK: func @simple_if_else(%[[ARG0:.*]]: i1)
|
|
# CHECK: %[[RET:.*]]:2 = scf.if %[[ARG0:.*]]
|
|
# CHECK: %[[ZERO:.*]] = arith.constant 0
|
|
# CHECK: %[[ONE:.*]] = arith.constant 1
|
|
# CHECK: scf.yield %[[ZERO]], %[[ONE]]
|
|
# CHECK: } else {
|
|
# CHECK: %[[TWO:.*]] = arith.constant 2
|
|
# CHECK: %[[THREE:.*]] = arith.constant 3
|
|
# CHECK: scf.yield %[[TWO]], %[[THREE]]
|
|
# CHECK: arith.addi %[[RET]]#0, %[[RET]]#1
|
|
# CHECK: return
|