File 1052-erts-Add-extra-bif-msacc-states.patch of Package erlang

Overview Repositories Revisions Requests Users Attributes Meta

File 1052-erts-Add-extra-bif-msacc-states.patch of Package erlang (Revision c589bc075ed79a918315277f2ca40bc8)

Currently displaying revision c589bc075ed79a918315277f2ca40bc8 , Show latest

From f5d6f414691313a60468c9aa2f6fd862f94e69c2 Mon Sep 17 00:00:00 2001
From: Lukas Larsson <lukas@erlang-solutions.com>
Date: Sun, 19 Jun 2016 22:54:39 +0200
Subject: [PATCH 3/6] erts: Add extra bif msacc states

---
 erts/emulator/beam/beam_emu.c  |  16 +---
 erts/emulator/beam/erl_msacc.c | 190 +++++++++++++++++++++--------------------
 erts/emulator/beam/erl_msacc.h |  51 ++++++++---
 3 files changed, 137 insertions(+), 120 deletions(-)

diff --git a/erts/emulator/beam/beam_emu.c b/erts/emulator/beam/beam_emu.c
index 797880d..7419a62 100644
--- a/erts/emulator/beam/beam_emu.c
+++ b/erts/emulator/beam/beam_emu.c
@@ -2826,13 +2826,7 @@ do {						\
             goto context_switch3;
         }
 
-        if (ERTS_MSACC_IS_ENABLED_CACHED_X()) {
-            if (GET_BIF_MODULE(Arg(0)) == am_ets) {
-                ERTS_MSACC_SET_STATE_CACHED_M_X(ERTS_MSACC_STATE_ETS);
-            } else {
-                ERTS_MSACC_SET_STATE_CACHED_M_X(ERTS_MSACC_STATE_BIF);
-            }
-        }
+        ERTS_MSACC_SET_BIF_STATE_CACHED_X(GET_BIF_MODULE(Arg(0)), GET_BIF_ADDRESS(Arg(0)));
 
 	bf = GET_BIF_ADDRESS(Arg(0));
 
@@ -3593,13 +3587,7 @@ do {						\
                 goto context_switch;
             }
 
-            if (ERTS_MSACC_IS_ENABLED_CACHED_X()) {
-                if ((Eterm)I[-3] == am_ets) {
-                    ERTS_MSACC_SET_STATE_CACHED_M_X(ERTS_MSACC_STATE_ETS);
-                } else {
-                    ERTS_MSACC_SET_STATE_CACHED_M_X(ERTS_MSACC_STATE_BIF);
-                }
-            }
+            ERTS_MSACC_SET_BIF_STATE_CACHED_X((Eterm)I[-3], (BifFunction)Arg(0));
 
 	    c_p->current = I-3;	/* In case we apply process_info/1,2 or load_nif/1 */
 	    c_p->i = I;		/* In case we apply check_process_code/2. */
diff --git a/erts/emulator/beam/erl_msacc.c b/erts/emulator/beam/erl_msacc.c
index 544bc8b..421445f 100644
--- a/erts/emulator/beam/erl_msacc.c
+++ b/erts/emulator/beam/erl_msacc.c
@@ -40,10 +40,11 @@
 #include "erl_bif_unique.h"
 #include "erl_map.h"
 #include "erl_msacc.h"
+#include "erl_bif_table.h"
 
 #if ERTS_ENABLE_MSACC
 
-static Eterm erts_msacc_gather_stats(ErtsMsAcc *msacc, Eterm **hpp, Uint *szp);
+static Eterm erts_msacc_gather_stats(ErtsMsAcc *msacc, ErtsHeapFactory *factory);
 static void erts_msacc_reset(ErtsMsAcc *msacc);
 static ErtsMsAcc* get_msacc(void);
 
@@ -52,7 +53,9 @@ erts_tsd_key_t ERTS_WRITE_UNLIKELY(erts_msacc_key);
 #else
 ErtsMsAcc *ERTS_WRITE_UNLIKELY(erts_msacc) = NULL;
 #endif
+#ifndef ERTS_MSACC_ALWAYS_ON
 int ERTS_WRITE_UNLIKELY(erts_msacc_enabled);
+#endif
 
 static Eterm *erts_msacc_state_atoms = NULL;
 static erts_rwmtx_t msacc_mutex;
@@ -62,6 +65,12 @@ static ErtsMsAcc *msacc_unmanaged = NULL;
 static Uint msacc_unmanaged_count = 0;
 #endif
 
+#if ERTS_MSACC_STATE_COUNT < MAP_SMALL_MAP_LIMIT
+#define DEFAULT_MSACC_MSG_SIZE (3 + 1 + ERTS_MSACC_STATE_COUNT * 2 + 3 + REF_THING_SIZE)
+#else
+#define DEFAULT_MSACC_MSG_SIZE (3 + ERTS_MSACC_STATE_COUNT * 3 + 3 + REF_THING_SIZE)
+#endif
+
 /* we have to split initiation as atoms are not inited in early init */
 void erts_msacc_early_init(void) {
 #ifndef ERTS_MSACC_ALWAYS_ON
@@ -88,7 +97,8 @@ void erts_msacc_init(void) {
 void erts_msacc_init_thread(char *type, int id, int managed) {
     ErtsMsAcc *msacc;
 
-    msacc = erts_alloc(ERTS_ALC_T_MSACC, sizeof(ErtsMsAcc));
+    msacc = erts_alloc(ERTS_ALC_T_MSACC, sizeof(ErtsMsAcc) +
+                       sizeof(ErtsMsAccPerfCntr) * ERTS_MSACC_STATE_COUNT);
 
     msacc->type = strdup(type);
     msacc->id = make_small(id);
@@ -122,79 +132,80 @@ void erts_msacc_init_thread(char *type, int id, int managed) {
 #endif
 }
 
+#ifdef ERTS_MSACC_EXTENDED_STATES
+
+void erts_msacc_set_bif_state(ErtsMsAcc *__erts_msacc_cache, Eterm mod, void *fn) {
+
+#ifdef ERTS_MSACC_EXTENDED_BIFS
+#define BIF_LIST(Mod,Func,Arity,FuncAddr,Num)                           \
+    if (fn == &FuncAddr) {                                             \
+        ERTS_MSACC_SET_STATE_CACHED_M_X(ERTS_MSACC_STATIC_STATE_COUNT + Num); \
+    } else
+#include "erl_bif_list.h"
+#undef BIF_LIST
+    { /* The last else in the macro expansion,
+         this happens for internal bifs, i.e. traps etc */
+        ERTS_MSACC_SET_STATE_CACHED_M_X(ERTS_MSACC_STATE_BIF);
+    }
+#else
+    if (mod == am_ets) {
+        ERTS_MSACC_SET_STATE_CACHED_M_X(ERTS_MSACC_STATE_ETS);
+    } else {
+        ERTS_MSACC_SET_STATE_CACHED_M_X(ERTS_MSACC_STATE_BIF);
+    }
+#endif
+}
+
+#endif
+
 /*
  * Creates a structure looking like this
  * #{ type => scheduler, id => 1, counters => #{ State1 => Counter1 ... StateN => CounterN}}
  */
 static
-Eterm erts_msacc_gather_stats(ErtsMsAcc *msacc, Eterm **hpp, Uint *szp) {
+Eterm erts_msacc_gather_stats(ErtsMsAcc *msacc, ErtsHeapFactory *factory) {
+    Uint sz = 0;
+    Eterm *hp, cvs[ERTS_MSACC_STATE_COUNT];
+    Eterm key, state_map;
     int i;
-    Eterm *hp;
-    Eterm key, state_key, state_map;
-    Eterm res = THE_NON_VALUE;
-    flatmap_t *map;
-
-    if (szp) {
-      *szp += MAP_HEADER_FLATMAP_SZ + 1 + 2*(3);
-      *szp += MAP_HEADER_FLATMAP_SZ + 1 + 2*(ERTS_MSACC_STATE_COUNT);
-      for (i = 0; i < ERTS_MSACC_STATE_COUNT; i++) {
-          (void)erts_bld_sint64(NULL,szp,(Sint64)msacc->perf_counters[i]);
+    flatmap_t *map; 
+
+    hp = erts_produce_heap(factory, 4, 0);
+    key = TUPLE3(hp,am_counters,am_id,am_type);
+
+    for (i = 0; i < ERTS_MSACC_STATE_COUNT; i++) {
+        cvs[i] = erts_bld_sint64(NULL, &sz,(Sint64)msacc->counters[i].pc);
 #ifdef ERTS_MSACC_STATE_COUNTERS
-          (void)erts_bld_uint64(NULL,szp,msacc->state_counters[i]);
-          *szp += 3; /* tuple to put state+perf counter in */
+        erts_bld_uint64(NULL,&sz,msacc->counters[i].sc);
+        sz += 3;
 #endif
-      }
     }
 
-    if (hpp) {
-        Eterm counters[ERTS_MSACC_STATE_COUNT];
-        hp = *hpp;
-        for (i = 0; i < ERTS_MSACC_STATE_COUNT; i++) {
-            Eterm counter = erts_bld_sint64(&hp,NULL,(Sint64)msacc->perf_counters[i]);
+    hp = erts_produce_heap(factory, sz, 0);
+
+    for (i = 0; i < ERTS_MSACC_STATE_COUNT; i++) {
+        cvs[i] = erts_bld_sint64(&hp,NULL,(Sint64)msacc->counters[i].pc);
 #ifdef ERTS_MSACC_STATE_COUNTERS
-            Eterm counter__ = erts_bld_uint64(&hp,NULL,msacc->state_counters[i]);
-            counters[i] = TUPLE2(hp,counter,counter__);
-            hp += 3;
-#else
-            counters[i] = counter;
+        Eterm counter__ = erts_bld_uint64(&hp,NULL,msacc->counters[i].sc);
+        cvs[i] = TUPLE2(hp,cvs[i],counter__);
+        hp += 3;
 #endif
-        }
-
-      key = TUPLE3(hp,am_counters,am_id,am_type);
-      hp += 4;
-
-      state_key = make_tuple(hp);
-      hp[0] = make_arityval(ERTS_MSACC_STATE_COUNT);
-      
-      for (i = 0; i < ERTS_MSACC_STATE_COUNT; i++)
-        hp[1+i] = erts_msacc_state_atoms[i];
-      hp += 1 + ERTS_MSACC_STATE_COUNT;
-
-      map = (flatmap_t*)hp;
-      hp += MAP_HEADER_FLATMAP_SZ;
-      map->thing_word = MAP_HEADER_FLATMAP;
-      map->size = ERTS_MSACC_STATE_COUNT;
-      map->keys = state_key;
-      for (i = 0; i < ERTS_MSACC_STATE_COUNT; i++)
-            hp[i] = counters[i];
-      hp += ERTS_MSACC_STATE_COUNT;
-      state_map = make_flatmap(map);
-
-      map = (flatmap_t*)hp;
-      hp += MAP_HEADER_FLATMAP_SZ;
-      map->thing_word = MAP_HEADER_FLATMAP;
-      map->size = 3;
-      map->keys = key;
-      hp[0] = state_map;
-      hp[1] = msacc->id;
-      hp[2] = am_atom_put(msacc->type,strlen(msacc->type));
-      hp += 3;
-
-      *hpp = hp;
-      res = make_flatmap(map);
     }
 
-    return res;
+    state_map = erts_map_from_ks_and_vs(factory, erts_msacc_state_atoms, cvs,
+                                        ERTS_MSACC_STATE_COUNT);
+
+    hp = erts_produce_heap(factory, MAP_HEADER_FLATMAP_SZ + 3, 0);
+    map = (flatmap_t*)hp;
+    hp += MAP_HEADER_FLATMAP_SZ;
+    map->thing_word = MAP_HEADER_FLATMAP;
+    map->size = 3;
+    map->keys = key;
+    hp[0] = state_map;
+    hp[1] = msacc->id;
+    hp[2] = am_atom_put(msacc->type,strlen(msacc->type));
+
+    return make_flatmap(map);
 }
 
 typedef struct {
@@ -222,40 +233,31 @@ static void send_reply(ErtsMsAcc *msacc, ErtsMSAccReq *msaccrp) {
     ErtsSchedulerData *esdp = erts_get_scheduler_data();
     Process *rp = msaccrp->proc;
     ErtsMessage *msgp = NULL;
-    Eterm **hpp, *hp;
+    Eterm *hp;
     Eterm ref_copy = NIL, msg;
-    Uint sz, *szp;
-    ErlOffHeap *ohp = NULL;
     ErtsProcLocks rp_locks = (esdp && msaccrp->req_sched == esdp->no
                               ? ERTS_PROC_LOCK_MAIN : 0);
+    ErtsHeapFactory factory;
 
-    sz = 0;
-    hpp = NULL;
-    szp = &sz;
-
-    if (msacc->unmanaged) erts_mtx_lock(&msacc->mtx);
-
-    while (1) {
-	if (hpp)
-            ref_copy = STORE_NC(hpp, ohp, msaccrp->ref);
-	else
-            *szp += REF_THING_SIZE;
-
-	if (msaccrp->action != ERTS_MSACC_GATHER)
-            msg = ref_copy;
-	else {
-            msg = erts_msacc_gather_stats(msacc, hpp, szp);
-            msg = erts_bld_tuple(hpp, szp, 2, ref_copy, msg);
-	}
-	if (hpp)
-            break;
-
-	msgp = erts_alloc_message_heap(rp, &rp_locks, sz, &hp, &ohp);
-        hpp = &hp;
-	szp = NULL;
-    }
+    if (msaccrp->action == ERTS_MSACC_GATHER) {
+
+        msgp = erts_factory_message_create(&factory, rp, &rp_locks, DEFAULT_MSACC_MSG_SIZE);
+
+        if (msacc->unmanaged) erts_mtx_lock(&msacc->mtx);
 
-    if (msacc->unmanaged) erts_mtx_unlock(&msacc->mtx);
+        hp = erts_produce_heap(&factory, REF_THING_SIZE + 3 /* tuple */, 0);
+        ref_copy = STORE_NC(&hp, &msgp->hfrag.off_heap, msaccrp->ref);
+        msg = erts_msacc_gather_stats(msacc, &factory);
+        msg = TUPLE2(hp, ref_copy, msg);
+
+        if (msacc->unmanaged) erts_mtx_unlock(&msacc->mtx);
+
+        erts_factory_close(&factory);
+    } else {
+        ErlOffHeap *ohp = NULL;
+        msgp = erts_alloc_message_heap(rp, &rp_locks, REF_THING_SIZE, &hp, &ohp);
+        msg = STORE_NC(&hp, &msgp->hfrag.off_heap, msaccrp->ref);
+    }
 
     erts_queue_message(rp, rp_locks, msgp, msg, am_system);
 
@@ -308,9 +310,9 @@ static void erts_msacc_reset(ErtsMsAcc *msacc) {
   if (msacc->unmanaged) erts_mtx_lock(&msacc->mtx);
 
   for (i = 0; i < ERTS_MSACC_STATE_COUNT; i++) {
-      msacc->perf_counters[i] = 0;
+      msacc->counters[i].pc = 0;
 #ifdef ERTS_MSACC_STATE_COUNTERS
-      msacc->state_counters[i] = 0;
+      msacc->counters[i].sc = 0;
 #endif
   }
 
@@ -415,7 +417,7 @@ erts_msacc_request(Process *c_p, int action, Eterm *threads)
                 ErtsSysPerfCounter perf_counter;
                 /* if enabled update stats */
                 perf_counter = erts_sys_perf_counter();
-                unmanaged[i]->perf_counters[unmanaged[i]->state] +=
+                unmanaged[i]->counters[unmanaged[i]->state].pc +=
                     perf_counter - unmanaged[i]->perf_counter;
                 unmanaged[i]->perf_counter = perf_counter;
             }
@@ -454,7 +456,7 @@ erts_msacc_request(Process *c_p, int action, Eterm *threads)
         for (msacc = msacc_unmanaged; msacc != NULL; msacc = msacc->next) {
             erts_mtx_lock(&msacc->mtx);
             perf_counter = erts_sys_perf_counter();
-            msacc->perf_counters[msacc->state] += perf_counter - msacc->perf_counter;
+            msacc->counters[msacc->state].pc += perf_counter - msacc->perf_counter;
             msacc->perf_counter = 0;
             erts_mtx_unlock(&msacc->mtx);
         }
diff --git a/erts/emulator/beam/erl_msacc.h b/erts/emulator/beam/erl_msacc.h
index 284388f..96d7d22 100644
--- a/erts/emulator/beam/erl_msacc.h
+++ b/erts/emulator/beam/erl_msacc.h
@@ -35,6 +35,10 @@
    this reduces overhead a little bit when profiling */
 /* #define ERTS_MSACC_ALWAYS_ON 1 */
 
+/* Uncomment this to keep individual stats for all
+   of the bifs when extended states is enabled */
+/* #define ERTS_MSACC_EXTENDED_BIFS 1 */
+
 #define ERTS_MSACC_DISABLE 0
 #define ERTS_MSACC_ENABLE  1
 #define ERTS_MSACC_RESET   2
@@ -92,7 +96,13 @@ static char *erts_msacc_states[] = {
 #define ERTS_MSACC_STATE_SLEEP     13
 #define ERTS_MSACC_STATE_TIMERS    14
 
-#define ERTS_MSACC_STATE_COUNT 15
+#define ERTS_MSACC_STATIC_STATE_COUNT 15
+
+#ifdef ERTS_MSACC_EXTENDED_BIFS
+#define ERTS_MSACC_STATE_COUNT (ERTS_MSACC_STATIC_STATE_COUNT + BIF_SIZE)
+#else
+#define ERTS_MSACC_STATE_COUNT ERTS_MSACC_STATIC_STATE_COUNT
+#endif
 
 #if ERTS_MSACC_STATE_STRINGS
 static char *erts_msacc_states[] = {
@@ -111,22 +121,26 @@ static char *erts_msacc_states[] = {
     "send",
     "sleep",
     "timers"
+#ifdef ERTS_MSACC_EXTENDED_BIFS
+#define BIF_LIST(Mod,Func,Arity,FuncAddr,Num)   \
+        ,"bif_" #Mod "_" #Func "_" #Arity
+#include "erl_bif_list.h"
+#undef BIF_LIST
+#endif
 };
 #endif
 
 #endif
 
 typedef struct erl_msacc_t_ ErtsMsAcc;
-
-struct erl_msacc_t_ {
-
-    /* the the values below are protected by mtx iff unmanaged = 1 */
-    ErtsSysPerfCounter perf_counter;
-    ErtsSysPerfCounter perf_counters[ERTS_MSACC_STATE_COUNT];
+typedef struct erl_msacc_p_cnt_t_ {
+    ErtsSysPerfCounter pc;
 #ifdef ERTS_MSACC_STATE_COUNTERS
-    Uint64 state_counters[ERTS_MSACC_STATE_COUNT];
+    Uint64 sc;
 #endif
-    Uint state;
+} ErtsMsAccPerfCntr;
+
+struct erl_msacc_t_ {
 
     /* protected by msacc_mutex in erl_msacc.c, and should be constant */
     int unmanaged;
@@ -135,6 +149,12 @@ struct erl_msacc_t_ {
     erts_tid_t tid;
     Eterm id;
     char *type;
+
+    /* the the values below are protected by mtx iff unmanaged = 1 */
+    ErtsSysPerfCounter perf_counter;
+    Uint state;
+    ErtsMsAccPerfCntr counters[];
+
 };
 
 #if ERTS_ENABLE_MSACC
@@ -334,9 +354,9 @@ void erts_msacc_set_state_m__(ErtsMsAcc *msacc, Uint new_state, int increment) {
     msacc->perf_counter = erts_sys_perf_counter();
     diff = msacc->perf_counter - prev_perf_counter;
     ASSERT(diff >= 0);
-    msacc->perf_counters[msacc->state] += diff;
+    msacc->counters[msacc->state].pc += diff;
 #ifdef ERTS_MSACC_STATE_COUNTERS
-    msacc->state_counters[new_state] += increment;
+    msacc->counters[new_state].sc += increment;
 #endif
     msacc->state = new_state;
 }
@@ -364,7 +384,7 @@ void erts_msacc_set_state_m__(ErtsMsAcc *msacc, Uint new_state, int increment) {
 #define ERTS_MSACC_SET_STATE_CACHED_M(state)
 #define ERTS_MSACC_POP_STATE_M()
 #define ERTS_MSACC_PUSH_AND_SET_STATE_M(state)
-
+#define ERTS_MSACC_SET_BIF_STATE_CACHED_X(Mod,Addr)
 
 #endif /* ERTS_ENABLE_MSACC */
 
@@ -385,9 +405,13 @@ void erts_msacc_set_state_m__(ErtsMsAcc *msacc, Uint new_state, int increment) {
 #define ERTS_MSACC_SET_STATE_CACHED_M_X(state)
 #define ERTS_MSACC_POP_STATE_M_X()
 #define ERTS_MSACC_PUSH_AND_SET_STATE_M_X(state)
+#define ERTS_MSACC_PUSH_AND_SET_STATE_CACHED_M_X(state)
+#define ERTS_MSACC_SET_BIF_STATE_CACHED_X(Mod,Addr)
 
 #else
 
+void erts_msacc_set_bif_state(ErtsMsAcc *msacc, Eterm mod, void *addr);
+
 #define ERTS_MSACC_PUSH_STATE_X() ERTS_MSACC_PUSH_STATE()
 #define ERTS_MSACC_POP_STATE_X() ERTS_MSACC_POP_STATE()
 #define ERTS_MSACC_SET_STATE_X(state) ERTS_MSACC_SET_STATE(state)
@@ -403,6 +427,9 @@ void erts_msacc_set_state_m__(ErtsMsAcc *msacc, Uint new_state, int increment) {
 #define ERTS_MSACC_SET_STATE_CACHED_M_X(state) ERTS_MSACC_SET_STATE_CACHED_M(state)
 #define ERTS_MSACC_POP_STATE_M_X() ERTS_MSACC_POP_STATE_M()
 #define ERTS_MSACC_PUSH_AND_SET_STATE_M_X(state) ERTS_MSACC_PUSH_AND_SET_STATE_M(state)
+#define ERTS_MSACC_SET_BIF_STATE_CACHED_X(Mod,Addr)       \
+    if (ERTS_MSACC_IS_ENABLED_CACHED_X())               \
+        erts_msacc_set_bif_state(__erts_msacc_cache, Mod, Addr)
 
 #endif /* !ERTS_MSACC_EXTENDED_STATES */
 
-- 
2.1.4

Places

File 1052-erts-Add-extra-bif-msacc-states.patch of Package erlang (Revision c589bc075ed79a918315277f2ca40bc8)

Places