ODS generation using PDL LSP.

[jumerckx]

Hey!

The readme contains a section on ODS integration. I was wondering if there's more rationale and info on the specific approach being taken here as this is something I'm also looking into. I believe the discussed implementation is still TBD?
Specifically I was wondering why the PDL LSP would be used (online, I only find references to the PDLL LSP, is this the one that's meant here?). And why would this one be used instead of the regular MLIR LSP?
Is there any particular not to go with an approach as done by mlir-hs, or less fletched out, julia?

Best,
Jules

[jackalcooper]

The readme contains a section on ODS integration....

It was not actually implemented. I should have updated the doc.

is still TBD?

no, because it as not needed as the development moves forward

PDL LSP would be used (online, I only find references to the PDLL LSP, is this the one that's meant here?). And why would this one be used instead of the regular MLIR LSP

yes you are right

Is there any particular not to go with an approach as done by mlir-hs, or less fletched out, JuliaLLVM/MLIR.jl#19?

it is mostly about the target audience. Beaver as a project for Elixir developers and it borrows conventions already exist in the community.

to be more specific, mlir-hs and JuliaLLVM/MLIR.jl#19 's approach is not taken for these reasons:

• most of elixir developers don't use C/C++ and the tablegen in terms of its grammar and source code generation involve too much C++ elements
• source code generation might introduce some unwanted effects and break single source of truth. as a downstream library which is a framework not the final product compiler, this is really not ideal. I mean you might generate some APIs your user can't really use because the dialect was not loaded/registered etc and you need to introduce more mechanisms to deal with it
• Beaver is intended to support every dialect and it can't be easily done with the tablegen approach. I mean Beaver is still a 5k loc project with almost every important MLIR feature covered while it could easily be couple of thousands loc to write tablegen processors for all dialects. I know it could be meaningless to talk about loc but smaller code base would make the project go further when the developers are limited to 1 or 2 in the beginning.

[jumerckx]

Thanks for the clear response! I agree with the sentiment of trying to C++ for this :)
Just to make sure that I grasp what's currently happening in Beaver, dialect operation wrappers are generated using the C API?
I'm not very familiar with Elixir so I didn't find the source yet, but I assume the C API is enough to give information on which arguments are expected (e.g. lhs::Value, rhs::Value, someAttribute::Attribute).
Are Attribute and Type wrappers also generated, here you mentioned that that wasn't possible yet, has this changed or is this a fundamental limitation?

[jackalcooper]

C API is enough to give information on which arguments are expected (e.g. lhs::Value, rhs::Value, someAttribute::Attribute).

I think except for ODS tablegen files, there is no concept for "arguments" like lhs or rhs. there are just operands and they are ordered. So C API doesn't support that I guess.

Are Attribute and Type wrappers also generated, here you mentioned that that wasn't possible yet, has this changed or is this a fundamental limitation?

no they are not. I used to have one but it turns out there are only 10 heavily used attributes to support. the implementation is here https://github.com/beaver-lodge/beaver/blob/main/lib/beaver/mlir/attribute.ex

[jumerckx]

Thank you!

it turns out there are only 10 heavily used attributes to support. the implementation is here main/lib/beaver/mlir/attribute.ex

That's really good to know. And what about custom types/attributes defined in different dialects?
For example, what happens when new types are registered using IRDL. I see that it is possible to use CMath.Complex in the tests, are these function available because the CMath dialect was generated from Elixir code as opposed to parsed from MLIR?

[jackalcooper]

For example, what happens when new types are registered using IRDL. I see that it is possible to use CMath.Complex in the tests, are these function available because the CMath dialect was generated from Elixir code as opposed to parsed from MLIR?

irdl dialect will reuse the elixir op function generation just like other dialects. irdl types and attributes are handled with special macros like deftype and defattr. every deftype will generate a function to create the type.