Batch pid => threadId mappings

Summary:
# Context
The DAP specification wants to use numeric "threadIds" to identify "threads", which correspond to Erlang processes. This means that we need to keep a mapping between pids and these threadIds. For this, we have a dedicated gen_server that will given a pid will give us a new threadId, if it was never seen, or the previous one used.

# Problem
For the "threads" request, we need to get the list of processes, and map their pids to threadIds. So far, we were doing it one by one, which, when the number of processes is high, introduces a noticeable overhead

# This diff
We add a way to convert all the pids to threadIds in one operation, and use it to implement the "threads" request

Reviewed By: TheGeorge

Differential Revision: D72171773

fbshipit-source-id: e1fb01514155cfeffa863dceee54abedab1cfc78

Author: jcpetruzza

edb/src/edb_dap_id_mappings.erl

@@ -37,7 +37,7 @@ This module implements the mapping fo PIDs to thread-ids, etc, generically.
 
 %% API
 -export([start_link_thread_ids_server/0, start_link_frame_ids_server/0, start_link_var_reference_ids_server/0]).
--export([pid_to_thread_id/1, thread_id_to_pid/1]).
+-export([pid_to_thread_id/1, pids_to_thread_ids/1, thread_id_to_pid/1]).
 -export([pid_frame_to_frame_id/1, frame_id_to_pid_frame/1]).
 -export([var_reference_to_frame_scope/1, frame_scope_to_var_reference/1]).
 -export([reset/0]).
@@ -89,6 +89,10 @@ start_link_var_reference_ids_server() ->
 pid_to_thread_id(Pid) when is_pid(Pid) ->
     gen_server:call(?THREAD_IDS_SERVER, {get_id, Pid}).
 
+-spec pids_to_thread_ids([pid()]) -> #{pid() => id()}.
+pids_to_thread_ids(Pids) ->
+    gen_server:call(?THREAD_IDS_SERVER, {get_ids, Pids}).
+
 -spec thread_id_to_pid(id()) -> {ok, pid()} | {error, not_found}.
 thread_id_to_pid(Id) when is_integer(Id) ->
     gen_server:call(?THREAD_IDS_SERVER, {from_id, Id}).
@@ -150,11 +154,23 @@ init(ServerType) ->
 
 -spec handle_call
     ({get_id, A}, gen_server:from(), state(A)) -> {reply, id(), state(A)};
+    ({get_ids, [A]}, gen_server:from(), state(A)) -> {reply, #{A => id()}, state(A)};
     ({from_id, id()}, gen_server:from(), state(A)) -> {reply, {ok, A} | {error, not_found}, state(A)};
     (reset, gen_server:from(), state(A)) -> {reply, ok, state(A)}.
 handle_call({get_id, A}, _From, State0) ->
     {Id, State1} = id_mapping_get_id(A, State0),
     {reply, Id, State1};
+handle_call({get_ids, As}, _From, State0) ->
+    {Ids, State1} = lists:foldl(
+        fun(A, {IdsN, StateN}) ->
+            {Id, StateN_plus_1} = id_mapping_get_id(A, StateN),
+            IdsN_plus_1 = IdsN#{A => Id},
+            {IdsN_plus_1, StateN_plus_1}
+        end,
+        {#{}, State0},
+        As
+    ),
+    {reply, Ids, State1};
 handle_call({from_id, Id}, _From, State0) ->
     Result = id_mapping_from_id(Id, State0),
     {reply, Result, State0};

edb/src/edb_dap_request_threads.erl

@@ -53,17 +53,21 @@ parse_arguments(Args) ->
     Args :: arguments().
 handle(#{state := attached}, _Args) ->
     ProcessesInfo = edb:processes([message_queue_len, pid_string, registered_name]),
-    Threads = [thread(Pid, Info) || Pid := Info <- ProcessesInfo],
+    ThreadIds = edb_dap_id_mappings:pids_to_thread_ids(maps:keys(ProcessesInfo)),
+    Threads = [thread(Pid, ThreadIds, Info) || Pid := Info <- ProcessesInfo],
     #{response => edb_dap_request:success(#{threads => Threads})};
 handle(_UnexpectedState, _) ->
     edb_dap_request:unexpected_request().
 
 %% ------------------------------------------------------------------
 %% Helpers
 %% ------------------------------------------------------------------
--spec thread(pid(), edb:process_info()) -> thread().
-thread(Pid, Info) ->
-    Id = edb_dap_id_mappings:pid_to_thread_id(Pid),
+-spec thread(Pid, ThreadIds, Info) -> thread() when
+    Pid :: pid(),
+    ThreadIds :: #{pid() => edb_dap:thread_id()},
+    Info :: edb:process_info().
+thread(Pid, ThreadIds, Info) ->
+    Id = maps:get(Pid, ThreadIds),
     #{
         id => Id,
         name => thread_name(Info)

edb/test/edb_dap_id_mappings_SUITE.erl

@@ -49,8 +49,12 @@ test_it_works(_Config) ->
     % Assigns a new id to each pid, only if needed
     ThreadId1 = 1 = edb_dap_id_mappings:pid_to_thread_id(Pid1),
     ThreadId2 = 2 = edb_dap_id_mappings:pid_to_thread_id(Pid2),
-    ThreadId3 = 3 = edb_dap_id_mappings:pid_to_thread_id(Pid3),
-    ThreadId4 = 4 = edb_dap_id_mappings:pid_to_thread_id(Pid4),
+    #{
+        Pid1 := ThreadId1,
+        Pid2 := ThreadId2,
+        Pid3 := 3 = ThreadId3,
+        Pid4 := 4 = ThreadId4
+    } = edb_dap_id_mappings:pids_to_thread_ids([Pid1, Pid2, Pid3, Pid4]),
 
     ThreadId1 = edb_dap_id_mappings:pid_to_thread_id(Pid1),
     ThreadId2 = edb_dap_id_mappings:pid_to_thread_id(Pid2),