From 903a6472a364716f4e004f152eb7556b95ef7857 Mon Sep 17 00:00:00 2001
From: lexprfuncall <lexprfuncall@localhost.localdomain>
Date: Thu, 11 Jul 2024 22:29:37 -0700
Subject: [PATCH] Improve the concurrency of erts_fun_table insertions

While the erts_fun_table is protected by a read-write lock but, when
inserting a fun, the runtime always acquires a writer lock allowing it
to insert if the lookup fails.  This has the undesirable effect of
serializing the insertions even in the degenerate case where the fun
is already present and the table does not need to be modified.

This change uses a reader lock initially to offer more concurrency in
the case where the fun is present, which can be a common case for
applications that repeatedly transmit essentially the same fun objects
between nodes.  If the lookup fails, the code behaves as it did before
and falls back to acquiring a writer lock and doing a lookup and
insert as needed.
---
 erts/emulator/beam/erl_fun.c | 27 ++++++++++++++++++++++++---
 1 file changed, 24 insertions(+), 3 deletions(-)

diff --git a/erts/emulator/beam/erl_fun.c b/erts/emulator/beam/erl_fun.c
index 3e7e86e977fe..e6c1744fb6ba 100644
--- a/erts/emulator/beam/erl_fun.c
+++ b/erts/emulator/beam/erl_fun.c
@@ -122,6 +122,7 @@ erts_put_fun_entry2(Eterm mod, int old_uniq, int old_index,
     ErlFunEntryContainer *fc;
     ErlFunEntry *tp;
     erts_aint_t refc;
+    int is_read_lock;
 
     tp = &template.entry;
 
@@ -135,14 +136,34 @@ erts_put_fun_entry2(Eterm mod, int old_uniq, int old_index,
 
     sys_memcpy(tp->uniq, uniq, sizeof(tp->uniq));
 
-    erts_fun_write_lock();
-    fc = (ErlFunEntryContainer*)hash_put(&erts_fun_table, (void*)&template);
+    /*
+     * Start with a shared, reader-lock which avoids contention when an insert
+     * is not required.
+     */
+    is_read_lock = 1;
+    erts_fun_read_lock();
+    fc = (ErlFunEntryContainer*)hash_get(&erts_fun_table, (void*)&template);
+    if (fc == NULL) {
+        /*
+         * Key is not present.  Acquire an exclusive, writer-lock and retry with
+         * a lookup that will insert if the key is still not present.
+         */
+        erts_fun_read_unlock();
+        is_read_lock = 0;
+        erts_fun_write_lock();
+        fc = (ErlFunEntryContainer*)hash_put(&erts_fun_table, (void*)&template);
+    }
+
     refc = erts_refc_inctest(&fc->entry.refc, 0);
     if (refc < 2) {
         /* New or pending delete */
         erts_refc_inc(&fc->entry.refc, 1);
     }
-    erts_fun_write_unlock();
+
+    if (is_read_lock)
+        erts_fun_read_unlock();
+    else
+        erts_fun_write_unlock();
 
     return &fc->entry;
 }