In Pharo9, we have speed up Pragma access.
https://blog.marcusdenker.de/speeding-up-pragma-access
https://blog.marcusdenker.de/speeding-up-pragma-access-part-ii
I think we further improve things, this time with regard to how Pragmas are
stored in the method objects.
**Describe the problem**
Pragmas are stored mixed with associations in the AdditionalMethodState. I
propose to store all Pragmas as one pre-allocated
array as a property #pragmas instead.
This will speedup both pragma access and property access and will radically
simplify the code.
**Classes involved**
CompiledMethod, AdditionalMethodState, Compiler backed
**Current Situation**
This is how Pragmas are now stored. It is a bit strange:
- if there is a pragma, we create a method with an AdditionalMethodState
object, referenced from the second-last literal.
- This is a variable subclass, implementing a dictionary, no hashing, just
linear search (that is ok as dicts <10 are faster without hashing most likely)
- What is *very* strange: it contains associations (for properties) and
Pragmas, mixed.
This means that all code very odd as it has to always check:
```smalltalk
propertyAt: aKey ifAbsent: aBlock
"Answer the property value associated with aKey or, if aKey isn't
found, answer the result of evaluating aBlock."
1 to: self basicSize do: [:i |
| propertyOrPragma "<Association|Pragma>" |
propertyOrPragma := self basicAt: i.
(propertyOrPragma isAssociation
and: [propertyOrPragma key == aKey]) ifTrue:
[^propertyOrPragma value]].
^aBlock value
```
while we have a second api that gives us either a pragma or a property,
whatever it finds first:
```smalltalk
at: aKey ifAbsent: aBlock
"Answer the property value or pragma associated with aKey or,
if aKey isnt found, answer the result of evaluating aBlock."
1 to: self basicSize do:
[:i |
| propertyOrPragma "<Association|Pragma>" |
(propertyOrPragma := self basicAt: i) key == aKey ifTrue:
[^propertyOrPragma isAssociation
ifTrue: [propertyOrPragma value]
ifFalse: [propertyOrPragma]]].
^aBlock value
```
and if you ask for #pragmas (which is the main API), it has to create the
array, iterating and checking for each entry:
```smalltalk
pragmas
"Return the Pragma objects. Properties are stored as Associations"
^ Array new: self basicSize streamContents: [ :pragmaStream |
1 to: self basicSize do: [ :i |
| propertyOrPragma "<Association|Pragma>" |
(propertyOrPragma := self basicAt: i) isAssociation
ifFalse: [
pragmaStream nextPut: propertyOrPragma ] ] ]
```
This is slow for pragmas, the array is created on demand. This is slow for
properties, as we need to check an skip pragmas when searching.
For speed, the code for pragmas on CompiledMethod has to do that:
```smalltalk
pragmas
| selectorOrProperties |
^(selectorOrProperties := self penultimateLiteral) isMethodProperties
ifTrue: [selectorOrProperties pragmas]
ifFalse: [#()]
```
Just to avoid creating an empty array via the streamContents: method. Which, if
you ask for pragmas of all methods, does matter. And this is what "Senders Of"
does...
And this is very, very strange. In the past this lead to very odd things like
"sender of" for #isFFIMethod giving all method that had the property
#isFFIMethod set. (I fixed that already)
I propose to clean this up.
**Proposal**
I want to have a clear layer: properties are there to add state to
CompiledMethods, the Pragma implementation just uses
this lower level layer.
AdditionalMethodState should have *no* code related to Pragmas.
So instead of putting pragmas into the AdditionalMethodState directly, we just
add one property #pragmas for those methods
where pragmas are used. The compiler then pre-allocates the array and puts it
there. (Pragmas are statically known, properties
can be set and removed at runtime).
Which means that on CompiledMethod, we just have:
```smalltalk
pragmas
^ self propertyAt: #pragmas ifAbsent: [ #() ]
```
pragmas and pragmasDo: on AdditionalMethodState can be removed, we can remove
the propertyAt* API there and just use
the Dictionary API (which makes sense, as AdditionalMethodState is just a
property dictionary with a backpointer)
The only thing we need to do for this to work is to change the code in the
compiler backend to be:
```smalltalk
addPragma: aPragma
properties ifNil: [ properties := AdditionalMethodState new ].
properties
at: #pragmas
ifAbsent: [ properties := properties copyWith: #pragmas -> #(
) ].
properties
at: #pragmas
put: ((properties at: #pragmas) copyWith: aPragma)
```
(bit ugly... need to use copyWith: as the high level API needs the
compiledMethod set in the AdditionalMethodState)
And some smaller changes here and there (e.g. setting the backpointer in
pragmas after the compiledMethod is created).
I did first implementation, It seems to work but this showed that we have to
take care with the bootrap.
(see [here](https://github.com/pharo-project/pharo/pull/7930/files) for the
closed PR)
