Prefer inline representation over static?

[overlookmotel]

Currently, static representation takes priority over inline.

For example, Atom::from("bananas") performs the following operations:

• Calculate hash of "bananas".
• Calculate index in static set (several arithmetic operations).
• String comparison of "bananas" and the string in the static set at that index.

If "bananas" is not in the static set, it falls back to inline representation.

Is there a reason why strings of 7 bytes or less don't skip all the above, and go direct to using inline representation?

As far as I can see, inline representation is much cheaper, and which representation takes priority doesn't matter for the rest of Atom's implementation - as long as it's consistent.

Short strings could still be input to the codegen so they can be used in atom!(), but codegen would not add them to the static set, and instead generate pack_inline() calls (instead of pack_static()).

I can't see any downside to this, and imagine it could be significantly more performant for use cases where there are lots of short strings in use. But am I missing something?

If you think this may be worth looking into, I'd be happy to implement and benchmark.

[overlookmotel]

A very quick benchmark:

Before:

Atom::from("")
    time:   [18.124 ns 18.163 ns 18.209 ns]

Atom::from("i")
    time:   [23.256 ns 23.311 ns 23.373 ns]

Atom::from("bananas")
    time:   [25.756 ns 25.827 ns 25.902 ns]

After:

Atom::from("")
    time:   [5.3891 ns 5.4092 ns 5.4281 ns]
    change: [-70.539% -70.401% -70.263%] (p = 0.00 < 0.05)
    Performance has improved.

Atom::from("i")
    time:   [8.5015 ns 8.5451 ns 8.6017 ns]
    change: [-64.009% -63.692% -63.438%] (p = 0.00 < 0.05)
    Performance has improved.

Atom::from("bananas")
    time:   [10.098 ns 10.124 ns 10.149 ns]
    change: [-61.047% -60.838% -60.657%] (p = 0.00 < 0.05)
    Performance has improved.

from() is 2.5x faster for short strings if inline representation has priority over static.

I also wonder if reducing the size of the static set (because it no longer contains any strings under 8 bytes) might improve performance for static strings too - but I've not tested that.

The change is really simple: src/atom.rs
Benchmark code here: benches/inline.rs

If you don't see a downside to this, would be happy to make a PR (also including necessary changes to the codegen).

[nicoburns]

Implemented in #278