[mlir-c] Add binding to enable populating default attributes on create

[jpienaar]

Summary

Follow the approach set by infer return types attributes setting during
construction and add call to populate default attributes. This method
returns no error state and treating the absence of registered op merely
as warning as it doesn't invalidate the validity of the op being
constructed (contrary to return type inference case).

Previously I also had C binding that invokes it on the op (it matches
the C++ side) but its not the preferred way of invoking the populating,
so not exposing C API side.

Showed usage Python side but intention is for that to be follow up and
will remove before submitting.

[rriddle]

mlir/lib/Bindings/Python/IRCore.cpp

1215–1216

Can you file an issue to detail and track this? Would be good to have more context on the desired state.

[jfurtek]

Is there any chance someone with commit privileges can land this? It was approved a month ago.

fastmath support in the arithmetic dialect needs this diff (or something like it) for a default value. There are many Python tests that create arithmetic operations without providing a value for fastmath (because it doesn't exist yet), and I think this will help.

[vzakhari]

In D129395#3707688, @jfurtek wrote:

Is there any chance someone with commit privileges can land this? It was approved a month ago.

fastmath support in the arithmetic dialect needs this diff (or something like it) for a default value. There are many Python tests that create arithmetic operations without providing a value for fastmath (because it doesn't exist yet), and I think this will help.

I think @jpienaar has commit privileges, but I can commit this after removing the FIXME code in mlir/lib/Bindings/Python/IRCore.cpp. @jpienaar, @rriddle, would you be okay with this?

[jpienaar]

This should now be default behavior in all cases (C++ build, C, Python). Sorry I didn't get notification here and I was blocked on some procedural parts of landing previous one until last week. Let me know if that change worked.

mlir/include/mlir-c/IR.h

struct MlirOperationState {
   MlirValue *operands;
   intptr_t nRegions;
   MlirRegion *regions;
   intptr_t nSuccessors;
   MlirBlock *successors;
   intptr_t nAttributes;
   MlirNamedAttribute *attributes;
   bool enableResultTypeInference;
+  bool enablePopulateDefaultAttributes;
 };
 typedef struct MlirOperationState MlirOperationState;
 
 /// Constructs an operation state from a name and a location.
 MLIR_CAPI_EXPORTED MlirOperationState mlirOperationStateGet(MlirStringRef name,
                                                             MlirLocation loc);
 
 /// Adds a list of components to the operation state.

 /// Enables result type inference for the operation under construction. If
 /// enabled, then the caller must not have called
 /// mlirOperationStateAddResults(). Note that if enabled, the
 /// mlirOperationCreate() call is failable: it will return a null operation
 /// on inference failure and will emit diagnostics.
 MLIR_CAPI_EXPORTED void
 mlirOperationStateEnableResultTypeInference(MlirOperationState *state);
 
+/// Enables populating default attributes for the operation under construction.
+/// If enabled, then the caller must not have called
+/// mlirOperationStateAddResults().
+MLIR_CAPI_EXPORTED void
+mlirOperationStateEnablePopulateDefaultAttributes(MlirOperationState *state);
+
 //===----------------------------------------------------------------------===//
 // Op Printing flags API.
 // While many of these are simple settings that could be represented in a
 // struct, they are wrapped in a heap allocated object and accessed via
 // functions to maximize the possibility of compatibility over time.
 //===----------------------------------------------------------------------===//
 
 /// Creates new printing flags with defaults, intended for customization.

mlir/lib/Bindings/Python/IRCore.cpp

if (regions) {
     llvm::SmallVector<MlirRegion, 4> mlirRegions;
     mlirRegions.resize(regions);
     for (int i = 0; i < regions; ++i)
       mlirRegions[i] = mlirRegionCreate();
     mlirOperationStateAddOwnedRegions(&state, mlirRegions.size(),
                                       mlirRegions.data());
   }
 
+  // FIXME: Just to show how it would be used Python side. I'd want to go and
+  // remove the special casing for known default attribute types while here.
+  state.enablePopulateDefaultAttributes = true;
+
   // Construct the operation.
   MlirOperation operation = mlirOperationCreate(&state);
   PyOperationRef created =
       PyOperation::createDetached(location->getContext(), operation);
   maybeInsertOperation(created, maybeIp);
 
   return created->createOpView();
 }

mlir/lib/CAPI/IR/IR.cpp

MlirOperationState mlirOperationStateGet(MlirStringRef name, MlirLocation loc) {
   state.operands = nullptr;
   state.nRegions = 0;
   state.regions = nullptr;
   state.nSuccessors = 0;
   state.successors = nullptr;
   state.nAttributes = 0;
   state.attributes = nullptr;
   state.enableResultTypeInference = false;
+  state.enablePopulateDefaultAttributes = false;
   return state;
 }
 
 #define APPEND_ELEMS(type, sizeName, elemName)                                 \
   state->elemName =                                                            \
       (type *)realloc(state->elemName, (state->sizeName + n) * sizeof(type));  \
   memcpy(state->elemName + state->sizeName, elemName, n * sizeof(type));       \
   state->sizeName += n;
if (succeeded(inferInterface->inferReturnTypes(
           context, state.location, state.operands,
           state.attributes.getDictionary(context), state.regions, state.types)))
     return success();
 
   // Diagnostic emitted by interface.
   return failure();
 }
 
+static void populateDefaultAttributes(OperationState &state) {
+  Optional<RegisteredOperationName> info = state.name.getRegisteredInfo();
+  if (!info) {
+    // Treat as warning only if non-registered operation.
+    emitWarning(state.location)
+        << "populating default attributes was requested for the operation "
+        << state.name
+        << ", but the operation was not registered. Ensure that the dialect "
+           "containing the operation is linked into MLIR and registered with "
+           "the context";
+    return;
+  }
+
+  info->populateDefaultAttrs(state.attributes);
+}
+
 MlirOperation mlirOperationCreate(MlirOperationState *state) {
   assert(state);
   OperationState cppState(unwrap(state->location), unwrap(state->name));
   SmallVector<Type, 4> resultStorage;
   SmallVector<Value, 8> operandStorage;
   SmallVector<Block *, 2> successorStorage;
   cppState.addTypes(unwrapList(state->nResults, state->results, resultStorage));
   cppState.addOperands(
for (intptr_t i = 0; i < state->nRegions; ++i)
     cppState.addRegion(std::unique_ptr<Region>(unwrap(state->regions[i])));
 
   free(state->results);
   free(state->operands);
   free(state->successors);
   free(state->regions);
   free(state->attributes);
 
+  // Populate default attributes state.
+  if (state->enablePopulateDefaultAttributes)
+    populateDefaultAttributes(cppState);
+
   // Infer result types.
   if (state->enableResultTypeInference) {
     assert(cppState.types.empty() &&
            "result type inference enabled and result types provided");
     if (failed(inferOperationTypes(cppState)))
       return {nullptr};
   }
 

mlir/test/CAPI/ir.c

static int createOperationWithTypeInference(MlirContext ctx) {
   // CHECK: RESULT_TYPE_INFERENCE: !shape.size
   fprintf(stderr, "RESULT_TYPE_INFERENCE: ");
   mlirTypeDump(mlirValueGetType(mlirOperationGetResult(op, 0)));
   fprintf(stderr, "\n");
   mlirOperationDestroy(op);
   return 0;
 }
 
+/// Creates operations with default attributes populated.
+static int createOperationWithDefaultAttrs(MlirContext ctx) {
+  MlirLocation loc = mlirLocationUnknownGet(ctx);
+
+  // The scf.foreach_thread has default valued attributes and is only used for
+  // that reason.
+  MlirOperationState state = mlirOperationStateGet(
+      mlirStringRefCreateFromCString("scf.foreach_thread"), loc);
+
+  // Create without and with default attributes populates.
+  state.enablePopulateDefaultAttributes = false;
+  MlirOperation opNodef = mlirOperationCreate(&state);
+  state.enablePopulateDefaultAttributes = true;
+  MlirOperation opDef = mlirOperationCreate(&state);
+
+  if (mlirOperationIsNull(opDef) || mlirOperationIsNull(opNodef)) {
+    fprintf(stderr, "ERROR: Result op creation unexpectedly failed");
+    return 1;
+  }
+
+  // CHECK: NOPOPULATE_DEFAULT: "scf.foreach_thread"() : () -> ()
+  fprintf(stderr, "NOPOPULATE_DEFAULT: ");
+  mlirOperationDump(opNodef);
+  // CHECK:      POPULATE_DEFAULT: "scf.foreach_thread"()
+  // CHECK-SAME:   {thread_dim_mapping = []} : () -> ()
+  fprintf(stderr, "POPULATE_DEFAULT: ");
+  mlirOperationDump(opDef);
+  fprintf(stderr, "\n");
+  mlirOperationDestroy(opDef);
+  mlirOperationDestroy(opNodef);
+  return 0;
+}
+
 /// Dumps instances of all builtin types to check that C API works correctly.
 /// Additionally, performs simple identity checks that a builtin type
 /// constructed with C API can be inspected and has the expected type. The
 /// latter achieves full coverage of C API for builtin types. Returns 0 on
 /// success and a non-zero error code on failure.
 static int printBuiltinTypes(MlirContext ctx) {
   // Integer types.
   MlirType i32 = mlirIntegerTypeGet(ctx, 32);

 int main() {
   MlirContext ctx = mlirContextCreate();
   mlirRegisterAllDialects(ctx);
   if (constructAndTraverseIr(ctx))
     return 1;
   buildWithInsertionsAndPrint(ctx);
   if (createOperationWithTypeInference(ctx))
     return 2;
-
-  if (printBuiltinTypes(ctx))
+  if (createOperationWithDefaultAttrs(ctx))
     return 3;
-  if (printBuiltinAttributes(ctx))
+  if (printBuiltinTypes(ctx))
     return 4;
-  if (printAffineMap(ctx))
+  if (printBuiltinAttributes(ctx))
     return 5;
-  if (printAffineExpr(ctx))
+  if (printAffineMap(ctx))
     return 6;
-  if (affineMapFromExprs(ctx))
+  if (printAffineExpr(ctx))
     return 7;
-  if (printIntegerSet(ctx))
+  if (affineMapFromExprs(ctx))
     return 8;
-  if (registerOnlyStd())
+  if (printIntegerSet(ctx))
     return 9;
-  if (testBackreferences())
+  if (registerOnlyStd())
     return 10;
-  if (testOperands())
+  if (testBackreferences())
     return 11;
-  if (testClone())
+  if (testOperands())
     return 12;
-  if (testTypeID(ctx))
+  if (testClone())
     return 13;
-  if (testSymbolTable(ctx))
+  if (testTypeID(ctx))
     return 14;
-  if (testDialectRegistry())
+  if (testSymbolTable(ctx))
     return 15;
+  if (testDialectRegistry())
+    return 16;
 
   mlirContextDestroy(ctx);
 
   testDiagnostics();
   return 0;
 }