Merge pull request #416 from phoenixframework/ac-local_max_carrier_sizes

Keep max carrier size since page is opened

Author: alexcastano

config/config.exs

@@ -10,7 +10,8 @@ if config_env() == :dev do
   config :esbuild,
     version: "0.14.41",
     default: [
-      args: ~w(js/app.js --bundle --minify --sourcemap=external --target=es2020 --outdir=../dist/js),
+      args:
+        ~w(js/app.js --bundle --minify --sourcemap=external --target=es2020 --outdir=../dist/js),
       cd: Path.expand("../assets", __DIR__),
       env: %{"NODE_PATH" => Path.expand("../deps", __DIR__)}
     ]

lib/phoenix/live_dashboard/pages/memory_allocators_page.ex

@@ -26,7 +26,7 @@ defmodule Phoenix.LiveDashboard.MemoryAllocatorsPage do
         dom_id="memory-allocators-table"
         page={@page}
         title="Memory Allocators"
-        row_fetcher={&fetch_memory_allocators/2}
+        row_fetcher={{&fetch_memory_allocators/3, nil}}
         rows_name="memory allocators"
         search={false}
         limit={false}
@@ -49,15 +49,14 @@ defmodule Phoenix.LiveDashboard.MemoryAllocatorsPage do
 
   defp chart_id(), do: "memory-allocators-chart"
 
-  defp fetch_memory_allocators(params, node) do
+  defp fetch_memory_allocators(params, node, state) do
     %{sort_by: sort_by, sort_dir: sort_dir} = params
 
-    allocs =
-      node
-      |> SystemInfo.fetch_memory_allocators()
-      |> Enum.sort_by(fn item -> item[sort_by] end, sort_dir)
+    {allocs, state} = SystemInfo.fetch_memory_allocators(node, state)
 
-    {allocs, length(allocs)}
+    allocs = Enum.sort_by(allocs, fn item -> item[sort_by] end, sort_dir)
+
+    {allocs, length(allocs), state}
   end
 
   @impl true
@@ -67,7 +66,7 @@ defmodule Phoenix.LiveDashboard.MemoryAllocatorsPage do
 
   @impl true
   def handle_refresh(socket) do
-    allocs = SystemInfo.fetch_memory_allocators(socket.assigns.page.node)
+    {allocs, _} = SystemInfo.fetch_memory_allocators(socket.assigns.page.node, nil)
     now = DateTime.utc_now() |> DateTime.to_unix(:microsecond)
 
     chart_data =

lib/phoenix/live_dashboard/system_info.ex

@@ -111,8 +111,8 @@ defmodule Phoenix.LiveDashboard.SystemInfo do
     :rpc.call(node, __MODULE__, :app_tree_callback, [application])
   end
 
-  def fetch_memory_allocators(node) do
-    :rpc.call(node, __MODULE__, :memory_allocators_callback, [])
+  def fetch_memory_allocators(node, max_carrier_sizes) do
+    :rpc.call(node, __MODULE__, :memory_allocators_callback, [max_carrier_sizes])
   end
 
   ## System callbacks
@@ -199,7 +199,7 @@ defmodule Phoenix.LiveDashboard.SystemInfo do
     }
   end
 
-  def memory_allocators_callback() do
+  def memory_allocators_callback(old_max_carrier_sizes) do
     allocs = :erlang.system_info(:alloc_util_allocators)
 
     :erlang.system_info({:allocator_sizes, allocs})
@@ -208,13 +208,14 @@ defmodule Phoenix.LiveDashboard.SystemInfo do
     end)
     |> prepend_total()
     |> Enum.map(fn {type, {block, current_cs, max_cs}} ->
-      [
+      %{
         name: type,
         block_size: block,
         carrier_size: current_cs,
         max_carrier_size: max_cs
-      ]
+      }
     end)
+    |> calc_max_carrier_sizes(old_max_carrier_sizes)
   end
 
   defp calc_allocator_sizes(allocator_sizes) do
@@ -260,6 +261,14 @@ defmodule Phoenix.LiveDashboard.SystemInfo do
     [total | allocator_sizes]
   end
 
+  defp calc_max_carrier_sizes(allocators, old_max_carrier_sizes) do
+    Enum.map_reduce(allocators, old_max_carrier_sizes || %{}, fn allocator, max_carrier_sizes ->
+      %{name: name, carrier_size: current} = allocator
+      max = Enum.max([old_max_carrier_sizes[name] || 0, current])
+      {Map.put(allocator, :max_carrier_size, max), Map.put(max_carrier_sizes, name, max)}
+    end)
+  end
+
   ## Process Callbacks
 
   @processes_keys [

test/phoenix/live_dashboard/system_info_test.exs

@@ -231,84 +231,77 @@ defmodule Phoenix.LiveDashboard.SystemInfoTest do
   end
 
   describe "fetch_memory_allocators" do
-    test "returns" do
-      assert list = SystemInfo.fetch_memory_allocators(node())
+    test "handles when no max_carrier_sizes is given" do
+      assert {list, max} = SystemInfo.fetch_memory_allocators(node(), nil)
 
       assert [
-               [
-                 name: :total,
-                 block_size: _,
-                 carrier_size: _,
-                 max_carrier_size: _
-               ],
-               [
-                 name: :temp_alloc,
-                 block_size: _,
-                 carrier_size: _,
-                 max_carrier_size: _
-               ],
-               [
-                 name: :sl_alloc,
-                 block_size: _,
-                 carrier_size: _,
-                 max_carrier_size: _
-               ],
-               [
-                 name: :std_alloc,
-                 block_size: _,
-                 carrier_size: _,
-                 max_carrier_size: _
-               ],
-               [
-                 name: :ll_alloc,
-                 block_size: _,
-                 carrier_size: _,
-                 max_carrier_size: _
-               ],
-               [
-                 name: :eheap_alloc,
-                 block_size: _,
-                 carrier_size: _,
-                 max_carrier_size: _
-               ],
-               [
-                 name: :ets_alloc,
-                 block_size: _,
-                 carrier_size: _,
-                 max_carrier_size: _
-               ],
-               [
-                 name: :fix_alloc,
-                 block_size: _,
-                 carrier_size: _,
-                 max_carrier_size: _
-               ],
-               [
-                 name: :literal_alloc,
-                 block_size: _,
-                 carrier_size: _,
-                 max_carrier_size: _
-               ],
-               [
-                 name: :binary_alloc,
-                 block_size: _,
-                 carrier_size: _,
-                 max_carrier_size: _
-               ],
-               [
-                 name: :driver_alloc,
-                 block_size: _,
-                 carrier_size: _,
-                 max_carrier_size: _
-               ]
+               %{name: :total, block_size: _, carrier_size: m1, max_carrier_size: m1},
+               %{name: :temp_alloc, block_size: _, carrier_size: m2, max_carrier_size: m2},
+               %{name: :sl_alloc, block_size: _, carrier_size: m3, max_carrier_size: m3},
+               %{name: :std_alloc, block_size: _, carrier_size: m4, max_carrier_size: m4},
+               %{name: :ll_alloc, block_size: _, carrier_size: m5, max_carrier_size: m5},
+               %{name: :eheap_alloc, block_size: _, carrier_size: m6, max_carrier_size: m6},
+               %{name: :ets_alloc, block_size: _, carrier_size: m7, max_carrier_size: m7},
+               %{name: :fix_alloc, block_size: _, carrier_size: m8, max_carrier_size: m8},
+               %{name: :literal_alloc, block_size: _, carrier_size: m9, max_carrier_size: m9},
+               %{name: :binary_alloc, block_size: _, carrier_size: m10, max_carrier_size: m10},
+               %{name: :driver_alloc, block_size: _, carrier_size: m11, max_carrier_size: m11}
              ] = list
 
+      assert %{
+               total: m1,
+               temp_alloc: m2,
+               sl_alloc: m3,
+               std_alloc: m4,
+               ll_alloc: m5,
+               eheap_alloc: m6,
+               ets_alloc: m7,
+               fix_alloc: m8,
+               literal_alloc: m9,
+               binary_alloc: m10,
+               driver_alloc: m11
+             } == max
+
       for alloc <- list do
         assert is_atom(alloc[:name])
         assert is_integer(alloc[:block_size])
         assert is_integer(alloc[:carrier_size])
         assert is_integer(alloc[:max_carrier_size])
       end
     end
+
+    test "handles max_carrier_sizes" do
+      top = 999_999_999_999_999_999
+
+      max = %{
+        total: top,
+        temp_alloc: top,
+        sl_alloc: top,
+        std_alloc: top,
+        ll_alloc: top,
+        eheap_alloc: top,
+        ets_alloc: top,
+        fix_alloc: top,
+        literal_alloc: top,
+        binary_alloc: top,
+        driver_alloc: top
+      }
+
+      assert {list, ^max} = SystemInfo.fetch_memory_allocators(node(), max)
+
+      assert [
+               %{name: :total, block_size: _, carrier_size: _, max_carrier_size: ^top},
+               %{name: :temp_alloc, block_size: _, carrier_size: _, max_carrier_size: ^top},
+               %{name: :sl_alloc, block_size: _, carrier_size: _, max_carrier_size: ^top},
+               %{name: :std_alloc, block_size: _, carrier_size: _, max_carrier_size: ^top},
+               %{name: :ll_alloc, block_size: _, carrier_size: _, max_carrier_size: ^top},
+               %{name: :eheap_alloc, block_size: _, carrier_size: _, max_carrier_size: ^top},
+               %{name: :ets_alloc, block_size: _, carrier_size: _, max_carrier_size: ^top},
+               %{name: :fix_alloc, block_size: _, carrier_size: _, max_carrier_size: ^top},
+               %{name: :literal_alloc, block_size: _, carrier_size: _, max_carrier_size: ^top},
+               %{name: :binary_alloc, block_size: _, carrier_size: _, max_carrier_size: ^top},
+               %{name: :driver_alloc, block_size: _, carrier_size: _, max_carrier_size: ^top}
+             ] = list
+    end
   end
 end