enso/docs/runtime/README.md
Pavel Marek f0de43a970
Add org.enso.compiler.dumpIr system prop (#10740)
Working on compiler IR is a daunting task. I have therefore added a new system property `enso.compiler.dumpIr` that will help with that. It dumps the encountered IRs to `ir-dumps` directory in the [GraphViz](www.graphviz.org) format. More info in updated docs.

Note that all the functionality to dump IRs to `dot` files was already implemented. This PR just adds the command line option and updates docs.

# Important Notes
- `--dump-graphs` cmd line option is removed as per [Jaroslav's request](https://github.com/enso-org/enso/pull/10740#pullrequestreview-2216676140).
- To dump graphs, use `-Dgraal.Dump=Truffle:2` system property passed via `JAVA_OPTS` env var.

If you run `env JAVA_OPTS='-Denso.compiler.dumpIr=true' enso --run tmp.enso` where `tmp.enso` is, e.g.:
```
from Standard.Base import all
main = 42
```
You will then have something like:
```
$ ls ir-dumps
Standard.Base.Data.Filter_Condition.dot     Standard.Base.Data.Time.dot              Standard.Base.System.Advanced.dot       Standard.Base.Warning.dot
Standard.Base.Data.Locale.dot               Standard.Base.Enso_Cloud.Enso_File.dot   Standard.Base.System.File.Advanced.dot  tmp.dot
Standard.Base.Data.Numeric.dot              Standard.Base.Errors.dot                 Standard.Base.System.File.dot
Standard.Base.Data.Numeric.Internal.dot     Standard.Base.Network.HTTP.Internal.dot  Standard.Base.System.File.Generic.dot
Standard.Base.Data.Text.Regex.Internal.dot  Standard.Base.Runtime.dot                Standard.Base.System.Internal.dot
```
You can then visualize any of these with `dot -Tsvg -O ir-dumps/tmp.dot`.

An example how that could look like is
![image.svg](https://github.com/user-attachments/assets/26ab8415-72cf-46da-bc63-f475e9fa628e)
2024-08-06 12:00:27 +00:00

56 lines
2.6 KiB
Markdown

---
layout: section-summary
title: Enso Runtime
category: runtime
tags: [runtime, readme]
order: 0
---
# Enso Runtime
The Enso runtime refers to both the compiler and the optimising JIT runtime for
Enso. While this might seem like a strange choice, it makes sense internally as
the components are integrated to a level not seen in most languages. It
encompasses the following functionality:
- **Parsing:** Taking Enso code as input and generating an AST that maintains a
sophisticated set of information about the input.
- **Desugaring:** Reducing the user-facing Enso code into a simplified language
known as `Core`.
- **Type Inference:** Inferring the types of bindings in the user's code.
- **Type Checking:** Checking that the inferred and provided types for bindings
match up across the codebase.
- **Optimisation:** Static optimisation processes to improve the performance of
the user's program.
- **Code Execution:** Actually running the Enso code.
- **Introspection Hooks:** Providing hooks into the running code to allow the
language server to inspect information about the code as it runs.
This folder contains all of the documentation related to the runtime, which is
broken up as follows:
- [**Caching:**](./caching.md) A description of the runtime's value caching
mechanism.
- [**Demand Analysis:**](./demand-analysis.md) A specification for the demand
analysis process in the Enso compiler that assists users with working with
suspended computations.
- [**Function Calling Flow:**](./function-call-flow.md) A description of the
involved logic that goes into a calling a function performantly in the Enso
runtime, while also supporting the flexible function syntax.
- [**Runtime Features:**](./runtime-features.md) A description of (and plan for)
the features of the Enso runtime.
- [**Unbounded Recursion:**](./unbounded-recursion.md) An exploration of
techniques for achieving unbounded recursion on the JVM.
- [**Instruments:**](./instruments.md) A description of instrumentation in the
language runtime.
- [**Execution Server Flow:**](./execution-server-flow.md) An explanation of how
the execution server orchestrates Enso's execution.
- [**Builtin Base Methods:**](./builtin-base-methods.md) An explanation of the
DSL we use for defining builtin types and methods.
- [**Searcher:**](./searcher.md) An explanation of how the searcher works.
- [**Instruments:**](./instruments.md) An explanation of how we compile Truffle
instrumentation.
- [**Compiler IR:**](./compiler-ir.md) An explanation of the Enso compiler IR.
- [**IR Caching:**](./ir-caching.md) An explanation of how we cache the compiler
IR to reduce startup times.