Add section about Haskell execution model #95
Conversation
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
doyougnu
reviewed
Jan 3, 2024
Comment on lines
+22
to
+23
| In addition, lazy evaluation makes control-flow and memory usage difficult to | ||
| understand. |
There was a problem hiding this comment.
Suggested change
| In addition, lazy evaluation makes control-flow and memory usage difficult to | |
| understand. | |
| And finally, lazy evaluation can make control-flow and memory usage difficult to | |
| understand. |
There was a problem hiding this comment.
This one is up to you. I just wanted to soften the claim because it makes it seem like this is an inherent feature of lazy evaluation and I'm not sure I agree with that.
| understand. | ||
|
|
||
| In this chapter we describe the compilation pipeline and the execution model. | ||
| For each stage of the pipeline we list what can be measured at runtime. |
There was a problem hiding this comment.
Suggested change
| For each stage of the pipeline we list what can be measured at runtime. | |
| We'll begin from the familiar world of the Haskell language and descend into the depths of the machine. Then, for each stage or `intermediate representation<https://en.wikipedia.org/wiki/Intermediate_representation>`_ in the pipeline we'll list what can be measured at runtime. |
Comment on lines
+119
to
+120
| objects: e.g. the heap object that represents `10 :: Int64` uses 24 bytes | ||
| instead of 16 bytes without profiling. Because of this, you may find that your |
There was a problem hiding this comment.
Suggested change
| objects: e.g. the heap object that represents `10 :: Int64` uses 24 bytes | |
| instead of 16 bytes without profiling. Because of this, you may find that your | |
| objects: e.g. the heap object that represents `10 :: Int64` uses 24 bytes without profiling, however with profiling this same object will use 16 bytes. Because of this, you may find that your |
Comment on lines
+122
to
+123
| code without this profiling enabled. **You have to be aware of the compilation | ||
| options you use when you make some runtime measurements.** |
There was a problem hiding this comment.
Suggested change
| code without this profiling enabled. **You have to be aware of the compilation | |
| options you use when you make some runtime measurements.** | |
| Therefore **Be careful. You have to be aware of the compilation | |
| options you use when you make some runtime measurements.** |
| Core: a simple and explicitly typed functional language. Types are basically | ||
| Haskell types. Type-class dictionaries are passed explicitly as records, | ||
| type-applications are used everywhere needed, coercions (proofs that we can | ||
| convert a type into another) are first class values, etc. |
There was a problem hiding this comment.
Suggested change
| convert a type into another) are first class values, etc. | |
| convert a type into another) are first class values, etc. | |
| Core is a good intermediate representation to observe the effect of polymorphism and optimization passes on your code. Core should also be used as a first stop on the journey into the pipeline because it is the intermediate representation that will be closest to the familiar Haskell code. See the :ref:`Reading Core <Reading Core>` chapter for more. |
doyougnu
reviewed
Jan 3, 2024
| layout for the target architecture. Then assembly code (textual) is generated | ||
| for the target architecture and an external assembler program generates machine | ||
| code (binary) for it. Finally an external linker is used to transform the | ||
| resulting code objects into a single executable or library. |
There was a problem hiding this comment.
We're missing a paragraph that states:
- what information can I get by reading Cmm that I cannot get by reading STG and Core?
- and then a link:
`:ref:`Reading Cmm <Reading Cmm>`
to the reading cmm chapter.
doyougnu
added a commit
to doyougnu/hs-opt-handbook.github.io
that referenced
this pull request
Jan 15, 2024
- required to land haskellfoundation#95
Co-authored-by: Jeffrey Young <[email protected]>
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
This adds a section about Haskell compilation pipeline and execution model.