# `Beaver.MLIR.ExecutionEngine`

This module defines functions working with MLIR ExecutionEngine.

# `dirty`

```elixir
@type dirty() :: nil | :io_bound | :cpu_bound
```

# `enable_pic`

```elixir
@type enable_pic() :: boolean()
```

# `invoke_opts`

```elixir
@type invoke_opts() :: [{:dirty, dirty()}]
```

# `object_dump`

```elixir
@type object_dump() :: boolean()
```

# `opt_level`

```elixir
@type opt_level() :: 0 | 1 | 2 | 3
```

# `opts`

```elixir
@type opts() :: [
  shared_lib_paths: [shared_lib_path()],
  opt_level: opt_level(),
  object_dump: object_dump(),
  enable_pic: enable_pic(),
  dirty: dirty(),
  telemetry: ([atom()], map(), map() -> any())
]
```

# `shared_lib_path`

```elixir
@type shared_lib_path() :: String.t()
```

# `t`

```elixir
@type t() :: %Beaver.MLIR.ExecutionEngine{ref: term()}
```

# `create!`

Create a MLIR JIT engine for a module and check if successful. Usually this module should be of LLVM dialect.

# `create!`

```elixir
@spec create!(Beaver.MLIR.Module.t(), opts()) :: t()
```

# `destroy`

# `emit_object!`

```elixir
@spec emit_object!(t(), Path.t()) :: Path.t()
```

Write the object captured by an engine created with `object_dump: true`.

# `init`

Initialize the JIT runtime.

If not already initialized, this will be called implicitly when first invocation happens.

# `invoke!`

```elixir
@spec invoke!(
  t(),
  String.t() | Beaver.MLIR.StringRef.t(),
  list(),
  any(),
  invoke_opts()
) :: :ok
```

invoke a function by symbol name.

# `lookup`

```elixir
@spec lookup(t(), String.t() | Beaver.MLIR.StringRef.t(), keyword()) ::
  Beaver.Native.OpaquePtr.t()
```

Look up a symbol in an execution engine.

# `make`

# `register_symbol`

```elixir
@spec register_symbol(
  t(),
  String.t() | Beaver.MLIR.StringRef.t(),
  Beaver.Native.OpaquePtr.t()
) :: t()
```

Register a native pointer under a symbol name.

# `runtime_libs`

Get the paths to the runtime libraries provided by MLIR.