It can potentially be a lot of memory though, tens of thousands to even hundreds of thousands of atoms on some systems, plus you are copying that entire massive map on every call to Application.get_env since it’s not static (a persistent term would fix that though, but still eat memory, and no point putting atoms in the persistent term registery directly as that’s just duplicating the atom registry).
Did you call? ^.^
╰─➤ tail -n 22 bench/atom_map_or_existing_bench.exs
def actions(_cla, _setup),
do: %{
"map_access" => fn key ->
atom = atoms_map()[key]
if atom, do: atom, else: key
end,
"map_get" => fn key ->
Map.get(atoms_map(), key, key)
end,
"persistent_mapterm_access" => fn key ->
Map.get(:persistent_term.get(:all_atoms_map), key, key)
end,
"to_existing" => fn key ->
try do
String.to_existing_atom(key)
rescue ArgumentError ->
key
end
end,
}
end
╰─➤ mix bench atom_map_or_existing
Operating System: Linux"
CPU Information: AMD Phenom(tm) II X6 1090T Processor
Number of Available Cores: 6
Available memory: 15.67 GB
Elixir 1.8.1
Erlang 21.2.2
Benchmark suite executing with the following configuration:
warmup: 2 s
time: 2 s
memory time: 2 s
parallel: 1
inputs: $blah, true
Estimated total run time: 48 s
Benchmarking map_access with input $blah...
Benchmarking map_access with input true...
Benchmarking map_get with input $blah...
Benchmarking map_get with input true...
Benchmarking persistent_mapterm_access with input $blah...
Benchmarking persistent_mapterm_access with input true...
Benchmarking to_existing with input $blah...
Benchmarking to_existing with input true...
##### With input $blah #####
Name ips average deviation median 99th %
persistent_mapterm_access 7.98 M 0.125 μs ±16.96% 0.130 μs 0.22 μs
to_existing 4.45 M 0.22 μs ±119.53% 0.21 μs 0.33 μs
map_get 0.00118 M 846.05 μs ±75.88% 478 μs 2972.98 μs
map_access 0.00113 M 886.78 μs ±87.96% 488 μs 3203.40 μs
Comparison:
persistent_mapterm_access 7.98 M
to_existing 4.45 M - 1.79x slower
map_get 0.00118 M - 6753.50x slower
map_access 0.00113 M - 7078.61x slower
Memory usage statistics:
Name Memory usage
persistent_mapterm_access 136 B
to_existing 136 B - 1.00x memory usage
map_get 192 B - 1.41x memory usage
map_access 192 B - 1.41x memory usage
**All measurements for memory usage were the same**
##### With input true #####
Name ips average deviation median 99th %
persistent_mapterm_access 7.29 M 0.137 μs ±12.94% 0.130 μs 0.20 μs
to_existing 7.28 M 0.137 μs ±11.35% 0.130 μs 0.20 μs
map_access 0.00116 M 859.70 μs ±78.67% 474 μs 3089.70 μs
map_get 0.00116 M 865.42 μs ±77.40% 474 μs 3133.01 μs
Comparison:
persistent_mapterm_access 7.29 M
to_existing 7.28 M - 1.00x slower
map_access 0.00116 M - 6265.69x slower
map_get 0.00116 M - 6307.36x slower
Memory usage statistics:
Name Memory usage
persistent_mapterm_access 136 B
to_existing 136 B - 1.00x memory usage
map_access 192 B - 1.41x memory usage
map_get 192 B - 1.41x memory usage
**All measurements for memory usage were the same**
(I do an assert to verify $blah doesn’t exist as an atom of course)
In all cases the map from the application environment is the slowest by monumental amounts.
When the atom does exist then then the persistent mapterm and the to_existing_atom are about the same speed.
When the atom does NOT exist then the to_existing _atom is a bit better than half the speed of the persistent mapterm, which at those speeds (millions per second) is not worth caring about.
/me loves benchmarks
EDIT: The atoms_map() and the initialize_atoms_map() calls are just copy/pasted from this IndifferentAccess module and initialized only once on setup. ^.^
