Persistent Term

Lighting talk given at Chicago Elixir 2019-01-23

Transcript

1. persistent_term persistent_term 1
2. Hello — Clark Kampfe — Fast Radius — 3D printing manufacturing — Phoenix, Nerves in production — Yes we're hiring persistent_term 2
3. Problem — Global data — Big — Lots of concurrent access — Rarely changing persistent_term 3
4. Examples — Config data — Cluster hosts — Large precomputed math calculations persistent_term 4
5. Solutions Elsewhere — Locks (C, Java, etc.) — Immutable persistent data structures (Clojure, etc) — Compile-time ownership enforcement (Rust) persistent_term 5
6. Elixir/Erlang VM: The BEAM — Error handling with restarts/supervision — Concurrency story — Process GC is independent — Everything is copied (some exceptions) persistent_term 6
7. Solutions in Elixir/Erlang — GenServer — ETS — FastGlobal — persistent_term (new!) persistent_term 7
8. GenServer defmodule Pterm.MapServer do use GenServer # PUBLIC ###################################### def start_link(args) do GenServer.start_link(__MODULE__, args, name: __MODULE__) end def get(pid) do GenServer.call(pid, :get, 30_000) end # CALLBACKS ###################################### def init(%{data: data} = _args) do {:ok, data} end def handle_call(:get, _from, state) do {:reply, state, state} end end ### Client {:ok, server} = Pterm.MapServer.start_link(%{data: %{a: 1, b: 2}}) Pterm.MapServer.get(server) #=> %{a: 1, b: 2} persistent_term 8
9. GenServer — Like every other Erlang process — Easy, not fast — Idiomatic, battle-tested — Built in — Data is copied to caller: keyspace access patterns matter! — Process mailbox can bottleneck reads and writes persistent_term 9
10. ETS - Erlang Term Storage hosts = %{...} :ets.new(:hosts, [{:read_concurrency, true}, :named_table]) :ets.insert(:hosts, {:hosts_data, big_hosts_data}) [{:hosts_data, data}] = :ets.lookup(:hosts, :hosts_data) persistent_term 10
11. ETS - Erlang Term Storage — Basically, Redis — Big mutable hash table — Easy, fast — Built in — Not GC'd — Data is copied to caller: keyspace access patterns matter! persistent_term 11
12. FastGlobal hosts = %{...} FastGlobal.put(:hosts, hosts) FastGlobal.get(:hosts) persistent_term 12
13. FastGlobal — Data is compiled into module constant — Easy, fast — Compilation slows down with data size — Kind of a hack — Updates require recompilation — External library — Data is not copied to caller persistent_term 13
14. persistent_term hosts = %{...} :persistent_term.put({HostsModule, :hosts}, hosts) :persistent_term.get({HostsModule, :hosts}) true = :persistent_term.erase({HostsModule, :hosts}) persistent_term 14
15. persistent_term — new in OTP 21.2 (December 2018) — Big mutable global hash table — Easy, fast — Not GC'd — Built in — Updates are very expensive — Best for few, larger data — Data is not copied to caller persistent_term 15
16. persistent_term - Warning! Persistent terms is an advanced feature and is not a general replacement for ETS tables. Before using persistent terms, make sure to fully understand the consequence to system performance when updating or deleting persistent terms. — the OTP gods persistent_term 16
17. persistent_term considered dangerous On term deletion or replacement... All processes in the system will be scheduled to run a scan of their heaps for the term that has been deleted. While such scan is relatively light-weight, if there are many processes, the system can become less responsive until all process have scanned their heaps. — the OTP gods persistent_term 17
18. small, n = 10, parallelism = 6 persistent_term 18
19. medium, n = 10,000, parellelism = 6 persistent_term 19
20. large, n = 1,000,000, parallelism = 6 persistent_term 20
21. small, n = 1,000, parallelism = 60 persistent_term 21
22. medium, n = 10,000, parallelism = 60 persistent_term 22
23. large, n = 1,000,000, parallelism = 60 persistent_term 23
24. summary ### GenServer ETS FastGlobal persistent_term difficulty easy easy easy easy 1 read perf medium fast fast very fast 1 write perf medium fast very slow very slow many read perf slow fast fast very fast many write perf slow fast very slow very slow builtin? yes yes no yes lookup anything hashtable hashtable hashtable distributed can be no no no persistent_term 24
25. persistent_term 25