From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from smtp54.i.mail.ru (smtp54.i.mail.ru [217.69.128.34]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by dev.tarantool.org (Postfix) with ESMTPS id 0CC4A469719 for ; Mon, 5 Oct 2020 09:30:38 +0300 (MSK) From: Sergey Kaplun Date: Mon, 5 Oct 2020 09:30:10 +0300 Message-Id: <2280bc3a2e32356455c3aebae711bafe2c4332f5.1601878708.git.skaplun@tarantool.org> In-Reply-To: References: MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Subject: [Tarantool-patches] [PATCH v4 1/2] core: introduce various platform metrics List-Id: Tarantool development patches List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: Igor Munkin , Sergey Ostanevich Cc: tarantool-patches@dev.tarantool.org This patch introduces the following counters: - overall amount of allocated tables, cdata and udata objects - number of incremental GC steps grouped by GC state - number of string hashes hits and misses - amount of allocated and freed memory - number of trace aborts and restored snapshots Interfaces to obtain these metrics via both Lua and C API are introduced in the next patch. Part of tarantool/tarantool#5187 --- src/lj_asm.c | 2 ++ src/lj_asm_arm.h | 7 +++++++ src/lj_asm_arm64.h | 7 +++++++ src/lj_asm_mips.h | 4 ++++ src/lj_asm_ppc.h | 3 +++ src/lj_asm_x86.h | 4 ++++ src/lj_cdata.c | 2 ++ src/lj_cdata.h | 2 ++ src/lj_gc.c | 4 ++++ src/lj_gc.h | 6 +----- src/lj_jit.h | 3 +++ src/lj_obj.h | 28 +++++++++++++++++++++++++--- src/lj_snap.c | 1 + src/lj_state.c | 2 +- src/lj_str.c | 5 +++++ src/lj_tab.c | 2 ++ src/lj_trace.c | 6 +++++- src/lj_udata.c | 2 ++ 18 files changed, 80 insertions(+), 10 deletions(-) diff --git a/src/lj_asm.c b/src/lj_asm.c index c2cf5a9..8fb3ccd 100644 --- a/src/lj_asm.c +++ b/src/lj_asm.c @@ -2273,6 +2273,7 @@ void lj_asm_trace(jit_State *J, GCtrace *T) as->J = J; as->T = T; J->curfinal = lj_trace_alloc(J->L, T); /* This copies the IR, too. */ + J->tracenum++; as->flags = J->flags; as->loopref = J->loopref; as->realign = NULL; @@ -2379,6 +2380,7 @@ void lj_asm_trace(jit_State *J, GCtrace *T) lj_trace_free(J2G(J), J->curfinal); J->curfinal = NULL; /* In case lj_trace_alloc() OOMs. */ J->curfinal = lj_trace_alloc(J->L, T); + J->tracenum++; as->realign = NULL; } diff --git a/src/lj_asm_arm.h b/src/lj_asm_arm.h index 37bfa40..4fd08b9 100644 --- a/src/lj_asm_arm.h +++ b/src/lj_asm_arm.h @@ -1257,9 +1257,16 @@ static void asm_cnew(ASMState *as, IRIns *ir) { uint32_t k = emit_isk12(ARMI_MOV, id); Reg r = k ? RID_R1 : ra_allock(as, id, allow); + allow = rset_exclude(allow, r); + Reg gr = ra_allock(as, i32ptr(J2G(as->J)), allow); emit_lso(as, ARMI_STRB, RID_TMP, RID_RET, offsetof(GCcdata, gct)); emit_lsox(as, ARMI_STRH, r, RID_RET, offsetof(GCcdata, ctypeid)); emit_d(as, ARMI_MOV|ARMI_K12|~LJ_TCDATA, RID_TMP); + emit_lso(as, ARMI_STR, RID_TMP, gr, + (int32_t)offsetof(global_State, gc.cdatanum)); + emit_dn(as, ARMI_ADD|ARMI_K12|1, RID_TMP, RID_TMP); + emit_lso(as, ARMI_LDR, RID_TMP, gr, + (int32_t)offsetof(global_State, gc.cdatanum)); if (k) emit_d(as, ARMI_MOV^k, RID_R1); } args[0] = ASMREF_L; /* lua_State *L */ diff --git a/src/lj_asm_arm64.h b/src/lj_asm_arm64.h index 8fd92e7..a32ba2d 100644 --- a/src/lj_asm_arm64.h +++ b/src/lj_asm_arm64.h @@ -1220,9 +1220,16 @@ static void asm_cnew(ASMState *as, IRIns *ir) /* Initialize gct and ctypeid. lj_mem_newgco() already sets marked. */ { Reg r = (id < 65536) ? RID_X1 : ra_allock(as, id, allow); + allow = rset_exclude(allow, r); + Reg gr = ra_allock(as, i64ptr(J2G(as->J)), allow); emit_lso(as, A64I_STRB, RID_TMP, RID_RET, offsetof(GCcdata, gct)); emit_lso(as, A64I_STRH, r, RID_RET, offsetof(GCcdata, ctypeid)); emit_d(as, A64I_MOVZw | A64F_U16(~LJ_TCDATA), RID_TMP); + emit_lso(as, A64I_STRx, RID_TMP, gr, + (int32_t)offsetof(global_State, gc.cdatanum)); + emit_dn(as, (A64I_ADDx^A64I_K12) | A64F_U12(1), RID_TMP, RID_TMP); + emit_lso(as, A64I_LDRx, RID_TMP, gr, + (int32_t)offsetof(global_State, gc.cdatanum)); if (id < 65536) emit_d(as, A64I_MOVZw | A64F_U16(id), RID_X1); } args[0] = ASMREF_L; /* lua_State *L */ diff --git a/src/lj_asm_mips.h b/src/lj_asm_mips.h index affe7d8..f4b4b5d 100644 --- a/src/lj_asm_mips.h +++ b/src/lj_asm_mips.h @@ -1473,11 +1473,15 @@ static void asm_cnew(ASMState *as, IRIns *ir) return; } + /* Code incrementing cdatanum is sparse to avoid mips data hazards. */ + emit_setgl(as, RID_RET+2, gc.cdatanum); /* Initialize gct and ctypeid. lj_mem_newgco() already sets marked. */ emit_tsi(as, MIPSI_SB, RID_RET+1, RID_RET, offsetof(GCcdata, gct)); emit_tsi(as, MIPSI_SH, RID_TMP, RID_RET, offsetof(GCcdata, ctypeid)); + emit_tsi(as, MIPSI_AADDIU, RID_RET+2, RID_RET+2, 1); emit_ti(as, MIPSI_LI, RID_RET+1, ~LJ_TCDATA); emit_ti(as, MIPSI_LI, RID_TMP, id); /* Lower 16 bit used. Sign-ext ok. */ + emit_getgl(as, RID_RET+2, gc.cdatanum); args[0] = ASMREF_L; /* lua_State *L */ args[1] = ASMREF_TMP1; /* MSize size */ asm_gencall(as, ci, args); diff --git a/src/lj_asm_ppc.h b/src/lj_asm_ppc.h index 6daa861..aa2d45c 100644 --- a/src/lj_asm_ppc.h +++ b/src/lj_asm_ppc.h @@ -1057,6 +1057,9 @@ static void asm_cnew(ASMState *as, IRIns *ir) return; } + emit_setgl(as, RID_TMP, gc.cdatanum); + emit_tai(as, PPCI_ADDIC, RID_TMP, RID_TMP, 1); + emit_getgl(as, RID_TMP, gc.cdatanum); /* Initialize gct and ctypeid. lj_mem_newgco() already sets marked. */ emit_tai(as, PPCI_STB, RID_RET+1, RID_RET, offsetof(GCcdata, gct)); emit_tai(as, PPCI_STH, RID_TMP, RID_RET, offsetof(GCcdata, ctypeid)); diff --git a/src/lj_asm_x86.h b/src/lj_asm_x86.h index 3e189b1..959fc2d 100644 --- a/src/lj_asm_x86.h +++ b/src/lj_asm_x86.h @@ -1835,6 +1835,10 @@ static void asm_cnew(ASMState *as, IRIns *ir) return; } + /* Increment cdatanum counter by address directly. */ + emit_i8(as, 1); + emit_rmro(as, XO_ARITHi8, XOg_ADD, RID_NONE, + ptr2addr(&J2G(as->J)->gc.cdatanum)); /* Combine initialization of marked, gct and ctypeid. */ emit_movtomro(as, RID_ECX, RID_RET, offsetof(GCcdata, marked)); emit_gri(as, XG_ARITHi(XOg_OR), RID_ECX, diff --git a/src/lj_cdata.c b/src/lj_cdata.c index 68e16d7..0dd8553 100644 --- a/src/lj_cdata.c +++ b/src/lj_cdata.c @@ -46,6 +46,7 @@ GCcdata *lj_cdata_newv(lua_State *L, CTypeID id, CTSize sz, CTSize align) cd->marked |= 0x80; cd->gct = ~LJ_TCDATA; cd->ctypeid = id; + g->gc.cdatanum++; return cd; } @@ -82,6 +83,7 @@ void LJ_FASTCALL lj_cdata_free(global_State *g, GCcdata *cd) } else { lj_mem_free(g, memcdatav(cd), sizecdatav(cd)); } + g->gc.cdatanum--; } void lj_cdata_setfin(lua_State *L, GCcdata *cd, GCobj *obj, uint32_t it) diff --git a/src/lj_cdata.h b/src/lj_cdata.h index 5bb0f5d..66b023b 100644 --- a/src/lj_cdata.h +++ b/src/lj_cdata.h @@ -45,6 +45,7 @@ static LJ_AINLINE GCcdata *lj_cdata_new(CTState *cts, CTypeID id, CTSize sz) cd = (GCcdata *)lj_mem_newgco(cts->L, sizeof(GCcdata) + sz); cd->gct = ~LJ_TCDATA; cd->ctypeid = ctype_check(cts, id); + G(cts->L)->gc.cdatanum++; return cd; } @@ -54,6 +55,7 @@ static LJ_AINLINE GCcdata *lj_cdata_new_(lua_State *L, CTypeID id, CTSize sz) GCcdata *cd = (GCcdata *)lj_mem_newgco(L, sizeof(GCcdata) + sz); cd->gct = ~LJ_TCDATA; cd->ctypeid = id; + G(L)->gc.cdatanum++; return cd; } diff --git a/src/lj_gc.c b/src/lj_gc.c index 1c8e6ce..44c8aa1 100644 --- a/src/lj_gc.c +++ b/src/lj_gc.c @@ -634,6 +634,7 @@ static void atomic(global_State *g, lua_State *L) static size_t gc_onestep(lua_State *L) { global_State *g = G(L); + g->gc.state_count[g->gc.state]++; switch (g->gc.state) { case GCSpause: gc_mark_start(g); /* Start a new GC cycle by marking all GC roots. */ @@ -857,6 +858,8 @@ void *lj_mem_realloc(lua_State *L, void *p, GCSize osz, GCSize nsz) lua_assert((nsz == 0) == (p == NULL)); lua_assert(checkptrGC(p)); g->gc.total = (g->gc.total - osz) + nsz; + g->gc.allocated += nsz; + g->gc.freed += osz; return p; } @@ -869,6 +872,7 @@ void * LJ_FASTCALL lj_mem_newgco(lua_State *L, GCSize size) lj_err_mem(L); lua_assert(checkptrGC(o)); g->gc.total += size; + g->gc.allocated += size; setgcrefr(o->gch.nextgc, g->gc.root); setgcref(g->gc.root, o); newwhite(g, o); diff --git a/src/lj_gc.h b/src/lj_gc.h index 669bbe9..2051220 100644 --- a/src/lj_gc.h +++ b/src/lj_gc.h @@ -8,11 +8,6 @@ #include "lj_obj.h" -/* Garbage collector states. Order matters. */ -enum { - GCSpause, GCSpropagate, GCSatomic, GCSsweepstring, GCSsweep, GCSfinalize -}; - /* Bitmasks for marked field of GCobj. */ #define LJ_GC_WHITE0 0x01 #define LJ_GC_WHITE1 0x02 @@ -117,6 +112,7 @@ LJ_FUNC void *lj_mem_grow(lua_State *L, void *p, static LJ_AINLINE void lj_mem_free(global_State *g, void *p, size_t osize) { g->gc.total -= (GCSize)osize; + g->gc.freed += osize; g->allocf(g->allocd, p, osize, 0); } diff --git a/src/lj_jit.h b/src/lj_jit.h index 7eb3d2a..d82292f 100644 --- a/src/lj_jit.h +++ b/src/lj_jit.h @@ -474,6 +474,9 @@ typedef struct jit_State { MCode *mcbot; /* Bottom of current mcode area. */ size_t szmcarea; /* Size of current mcode area. */ size_t szallmcarea; /* Total size of all allocated mcode areas. */ + size_t tracenum; /* Overall number of traces. */ + size_t nsnaprestore; /* Overall number of snap restores. */ + size_t ntraceabort; /* Overall number of abort traces. */ TValue errinfo; /* Additional info element for trace errors. */ diff --git a/src/lj_obj.h b/src/lj_obj.h index f368578..600b68d 100644 --- a/src/lj_obj.h +++ b/src/lj_obj.h @@ -571,6 +571,17 @@ typedef enum { #define basemt_obj(g, o) ((g)->gcroot[GCROOT_BASEMT+itypemap(o)]) #define mmname_str(g, mm) (strref((g)->gcroot[GCROOT_MMNAME+(mm)])) +/* Garbage collector states. Order matters. */ +enum { + GCSpause, /* Start a GC cycle and mark the root set.*/ + GCSpropagate, /* One gray object is processed. */ + GCSatomic, /* Atomic transition from mark to sweep phase. */ + GCSsweepstring, /* Sweep one chain of strings. */ + GCSsweep, /* Sweep few objects from root. */ + GCSfinalize, /* Finalize one userdata or cdata object. */ + GCSmax +}; + typedef struct GCState { GCSize total; /* Memory currently allocated. */ GCSize threshold; /* Memory threshold. */ @@ -589,6 +600,15 @@ typedef struct GCState { GCSize estimate; /* Estimate of memory actually in use. */ MSize stepmul; /* Incremental GC step granularity. */ MSize pause; /* Pause between successive GC cycles. */ + + size_t freed; /* Total amount of freed memory. */ + size_t allocated; /* Total amount of allocated memory. */ + size_t state_count[GCSmax]; /* Count of incremental GC steps per state. */ + size_t tabnum; /* Amount of allocated table objects. */ + size_t udatanum; /* Amount of allocated udata objects. */ +#ifdef LJ_HASFFI + size_t cdatanum; /* Amount of allocated cdata objects. */ +#endif } GCState; /* Global state, shared by all threads of a Lua universe. */ @@ -602,22 +622,24 @@ typedef struct global_State { BloomFilter next[2]; } strbloom; #endif + size_t strhash_hit; /* Strings amount found in string hash. */ + size_t strhash_miss; /* Strings amount allocated and put into string hash. */ lua_Alloc allocf; /* Memory allocator. */ void *allocd; /* Memory allocator data. */ GCState gc; /* Garbage collector. */ - volatile int32_t vmstate; /* VM state or current JIT code trace number. */ SBuf tmpbuf; /* Temporary string buffer. */ GCstr strempty; /* Empty string. */ uint8_t stremptyz; /* Zero terminator of empty string. */ uint8_t hookmask; /* Hook mask. */ uint8_t dispatchmode; /* Dispatch mode. */ uint8_t vmevmask; /* VM event mask. */ + int32_t hookcount; /* Instruction hook countdown. */ GCRef mainthref; /* Link to main thread. */ TValue registrytv; /* Anchor for registry. */ - TValue tmptv, tmptv2; /* Temporary TValues. */ + TValue tmptv2, tmptv; /* Temporary TValues. */ Node nilnode; /* Fallback 1-element hash part (nil key and value). */ GCupval uvhead; /* Head of double-linked list of all open upvalues. */ - int32_t hookcount; /* Instruction hook countdown. */ + volatile int32_t vmstate; /* VM state or current JIT code trace number. */ int32_t hookcstart; /* Start count for instruction hook counter. */ lua_Hook hookf; /* Hook function. */ lua_CFunction wrapf; /* Wrapper for C function calls. */ diff --git a/src/lj_snap.c b/src/lj_snap.c index 7554caf..4cf27e7 100644 --- a/src/lj_snap.c +++ b/src/lj_snap.c @@ -904,6 +904,7 @@ const BCIns *lj_snap_restore(jit_State *J, void *exptr) L->top = frame + snap->nslots; break; } + J->nsnaprestore++; return pc; } diff --git a/src/lj_state.c b/src/lj_state.c index 632dd07..1d9c628 100644 --- a/src/lj_state.c +++ b/src/lj_state.c @@ -214,7 +214,7 @@ LUA_API lua_State *lua_newstate(lua_Alloc f, void *ud) g->gc.state = GCSpause; setgcref(g->gc.root, obj2gco(L)); setmref(g->gc.sweep, &g->gc.root); - g->gc.total = sizeof(GG_State); + g->gc.allocated = g->gc.total = sizeof(GG_State); g->gc.pause = LUAI_GCPAUSE; g->gc.stepmul = LUAI_GCMUL; lj_dispatch_init((GG_State *)L); diff --git a/src/lj_str.c b/src/lj_str.c index 24e90ca..8ff955e 100644 --- a/src/lj_str.c +++ b/src/lj_str.c @@ -222,6 +222,7 @@ GCstr *lj_str_new(lua_State *L, const char *str, size_t lenx) str_fastcmp(str, strdata(sx), len) == 0) { /* Resurrect if dead. Can only happen with fixstring() (keywords). */ if (isdead(g, o)) flipwhite(o); + g->strhash_hit++; return sx; /* Return existing string. */ } o = gcnext(o); @@ -234,6 +235,7 @@ GCstr *lj_str_new(lua_State *L, const char *str, size_t lenx) memcmp(str, strdata(sx), len) == 0) { /* Resurrect if dead. Can only happen with fixstring() (keywords). */ if (isdead(g, o)) flipwhite(o); + g->strhash_hit++; return sx; /* Return existing string. */ } o = gcnext(o); @@ -266,6 +268,7 @@ GCstr *lj_str_new(lua_State *L, const char *str, size_t lenx) if (sx->hash == fh && sx->len == len && str_fastcmp(str, strdata(sx), len) == 0) { /* Resurrect if dead. Can only happen with fixstring() (keywords). */ if (isdead(g, o)) flipwhite(o); + g->strhash_hit++; return sx; /* Return existing string. */ } o = gcnext(o); @@ -276,6 +279,7 @@ GCstr *lj_str_new(lua_State *L, const char *str, size_t lenx) if (sx->hash == fh && sx->len == len && memcmp(str, strdata(sx), len) == 0) { /* Resurrect if dead. Can only happen with fixstring() (keywords). */ if (isdead(g, o)) flipwhite(o); + g->strhash_hit++; return sx; /* Return existing string. */ } o = gcnext(o); @@ -293,6 +297,7 @@ GCstr *lj_str_new(lua_State *L, const char *str, size_t lenx) } } #endif + g->strhash_miss++; /* Nope, create a new string. */ s = lj_mem_newt(L, sizeof(GCstr)+len+1, GCstr); newwhite(g, s); diff --git a/src/lj_tab.c b/src/lj_tab.c index ff216f3..c5f358e 100644 --- a/src/lj_tab.c +++ b/src/lj_tab.c @@ -141,6 +141,7 @@ static GCtab *newtab(lua_State *L, uint32_t asize, uint32_t hbits) } if (hbits) newhpart(L, t, hbits); + G(L)->gc.tabnum++; return t; } @@ -240,6 +241,7 @@ void LJ_FASTCALL lj_tab_free(global_State *g, GCtab *t) lj_mem_free(g, t, sizetabcolo((uint32_t)t->colo & 0x7f)); else lj_mem_freet(g, t); + g->gc.tabnum--; } /* -- Table resizing ------------------------------------------------------ */ diff --git a/src/lj_trace.c b/src/lj_trace.c index d85b47f..9bcbce6 100644 --- a/src/lj_trace.c +++ b/src/lj_trace.c @@ -176,6 +176,7 @@ void LJ_FASTCALL lj_trace_free(global_State *g, GCtrace *T) lj_mem_free(g, T, ((sizeof(GCtrace)+7)&~7) + (T->nins-T->nk)*sizeof(IRIns) + T->nsnap*sizeof(SnapShot) + T->nsnapmap*sizeof(SnapEntry)); + J->tracenum--; } /* Re-enable compiling a prototype by unpatching any modified bytecode. */ @@ -538,8 +539,10 @@ static int trace_downrec(jit_State *J) /* Restart recording at the return instruction. */ lua_assert(J->pt != NULL); lua_assert(bc_isret(bc_op(*J->pc))); - if (bc_op(*J->pc) == BC_RETM) + if (bc_op(*J->pc) == BC_RETM) { + J->ntraceabort++; return 0; /* NYI: down-recursion with RETM. */ + } J->parent = 0; J->exitno = 0; J->state = LJ_TRACE_RECORD; @@ -616,6 +619,7 @@ static int trace_abort(jit_State *J) return trace_downrec(J); else if (e == LJ_TRERR_MCODEAL) lj_trace_flushall(L); + J->ntraceabort++; return 0; } diff --git a/src/lj_udata.c b/src/lj_udata.c index bd0321b..70c722a 100644 --- a/src/lj_udata.c +++ b/src/lj_udata.c @@ -24,11 +24,13 @@ GCudata *lj_udata_new(lua_State *L, MSize sz, GCtab *env) /* Chain to userdata list (after main thread). */ setgcrefr(ud->nextgc, mainthread(g)->nextgc); setgcref(mainthread(g)->nextgc, obj2gco(ud)); + g->gc.udatanum++; return ud; } void LJ_FASTCALL lj_udata_free(global_State *g, GCudata *ud) { + g->gc.udatanum--; lj_mem_free(g, ud, sizeudata(ud)); } -- 2.28.0