/home/travis/build/MoarVM/MoarVM/src/spesh/stats.h

Source
/* Statistics are stored per static frame. This data structure is only ever
 * read/written by the specializer thread. */
struct MVMSpeshStats {
    /* Statistics on a per-callsite basis. */
    MVMSpeshStatsByCallsite *by_callsite;

    /* Map of MVM_SPESH_LOG_STATIC entries for this routine. Held at the top
     * level as they represent static resolutions, so no need to duplicate
     * this information across callsites. */
    MVMSpeshStatsStatic *static_values;

    /* The number of entries in by_callsite. */
    MVMuint32 num_by_callsite;

    /* The number of entries in static_values. */
    MVMuint32 num_static_values;

    /* Total calls across all callsites. */
    MVMuint32 hits;

    /* Total OSR hits across all callsites. */
    MVMuint32 osr_hits;

    /* The latest version of the statistics when this was updated. Used to
     * help decide when to throw out data that is no longer evolving, to
     * reduce memory use. */
    MVMuint32 last_update;
};

/* Statistics by callsite. */
struct MVMSpeshStatsByCallsite {
    /* The callsite, or NULL for the case of no interned callsite. */
    MVMCallsite *cs;

    /* Statistics aggregated by parameter type information. */
    MVMSpeshStatsByType *by_type;

    /* The number of entries in by_type. Zero if cs == NULL. */
    MVMuint32 num_by_type;

    /* Total calls to this callsite. */
    MVMuint32 hits;

    /* Total OSR hits for this callsite. */
    MVMuint32 osr_hits;

    /* The maximum callstack depth we observed this at. */
    MVMuint32 max_depth;
};

/* Statistics by type. */
struct MVMSpeshStatsByType {
    /* Argument type information. Length of this is determined by the callsite
     * of the specialization. */
    MVMSpeshStatsType *arg_types;

    /* Total calls with this callsite/type combination. */
    MVMuint32 hits;

    /* Total OSR hits for this callsite/type combination. */
    MVMuint32 osr_hits;

    /* Logged type and logged value counts, by bytecode offset. */
    MVMSpeshStatsByOffset *by_offset;

    /* Number of stats by offset we have. */
    MVMuint32 num_by_offset;

    /* The maximum callstack depth we observed this at. */
    MVMuint32 max_depth;
};

/* Type statistics. */
struct MVMSpeshStatsType {
    /* The type logged. */
    MVMObject *type;

    /* If applicable, and if the type is a container type, the type of the
     * value logged inside of it. */
    MVMObject *decont_type;

    /* Whether the type and decont type were concrete. */
    MVMuint8 type_concrete;
    MVMuint8 decont_type_concrete;

    /* If there is a container type, whether it must be rw. */
    MVMuint8 rw_cont;
};

/* Statistics by bytecode offset. */
struct MVMSpeshStatsByOffset {
    /* The bytecode offset these types/values were recorded at. */
    MVMuint32 bytecode_offset;

    /* Number of types recorded, with counts. */
    MVMuint32 num_types;
    MVMSpeshStatsTypeCount *types;

    /* Number of invocation targets recorded, with counts. */
    MVMSpeshStatsInvokeCount *invokes;
    MVMuint32 num_invokes;

    /* Number of type tuples recorded, with counts. (Type tuples are actually
     * recorded by the callee, and then also accumulated at the callsite of
     * the caller.) */
    MVMuint32 num_type_tuples;
    MVMSpeshStatsTypeTupleCount *type_tuples;

    /* Number of times spesh plugin guard indexes were recorded. */
    MVMSpeshStatsPluginGuardCount *plugin_guards;
    MVMuint32 num_plugin_guards;
};

/* Counts of a given type that has shown up at a bytecode offset. */
struct MVMSpeshStatsTypeCount {
    /* The type and its concreteness. */
    MVMObject *type;
    MVMuint8 type_concrete;

    /* The number of times we've seen it. */
    MVMuint32 count;
};

/* Counts of a given static frame that was invoked at a bytecode offset. */
struct MVMSpeshStatsInvokeCount {
    /* The static frame. */
    MVMStaticFrame *sf;

    /* The number of times the caller frame was also the outer frame. */
    MVMuint32 caller_is_outer_count;

    /* The number of times it was resolved from a multi-dispatch. */
    MVMuint32 was_multi_count;

    /* The number of times we've seen it. */
    MVMuint32 count;
};

/* Counts of a given type tuple has shown up at the callsite at a bytecode
 * offset. */
struct MVMSpeshStatsTypeTupleCount {
    /* The callsite. */
    MVMCallsite *cs;

    /* The type tuple. */
    MVMSpeshStatsType *arg_types;

    /* The number of times we've seen it. */
    MVMuint32 count;
};

/* Counts of a given spesh plugin guard index. */
struct MVMSpeshStatsPluginGuardCount {
    /* The guard index that the plugin resolved to. */
    MVMuint32 guard_index;

    /* The number of times we've seen it. */
    MVMuint32 count;
};

/* Static values table entry. */
struct MVMSpeshStatsStatic {
    /* The value. */
    MVMObject *value;

    /* The bytecode offset it was recorded at. */
    MVMint32 bytecode_offset;
};

/* The maximum number of spesh stats updates before we consider a frame's
 * stats out of date and throw them out. */
#define MVM_SPESH_STATS_MAX_AGE 10

/* Logs are linear recordings marked with frame correlation IDs. We need to
 * simulate the call stack as part of the analysis. This is the model for the
 * stack simulation. */
struct MVMSpeshSimStack {
    /* Array of frames. */
    MVMSpeshSimStackFrame *frames;

    /* Current frame index and allocated space. */
    MVMuint32 used;
    MVMuint32 limit;

    /* Current stack depth. */
    MVMuint32 depth;
};

/* This is the model of a frame on the simulated stack. */
struct MVMSpeshSimStackFrame {
    /* The static frame. */
    MVMStaticFrame *sf;

    /* Spesh stats for the stack frame. */
    MVMSpeshStats *ss;

    /* Correlation ID. */
    MVMuint32 cid;

    /* Callsite stats index (not pointer in case of realloc). */
    MVMuint32 callsite_idx;

    /* Type stats index (not pointer in case of realloc); -1 if not yet set.
     * This is resolved once using arg_types, and then remembered, so we can
     * correlate the statistics across spesh log buffers. */
    MVMint32 type_idx;

    /* Argument types logged. Sized by number of callsite flags. */
    MVMSpeshStatsType *arg_types;

    /* Spesh log entries for types and values, for later processing. */
    MVMSpeshLogEntry **offset_logs;
    MVMuint32 offset_logs_used;
    MVMuint32 offset_logs_limit;

    /* Type tuples observed at a given callsite offset, for later
     * processing. */
    MVMSpeshSimCallType *call_type_info;
    MVMuint32 call_type_info_used;
    MVMuint32 call_type_info_limit;

    /* Number of times we crossed an OSR point. */
    MVMuint32 osr_hits;

    /* The last bytecode offset and static frame seen in an invoke recording;
     * used for producing callsite type stats based on callee type tuples. */
    MVMuint32 last_invoke_offset;
    MVMStaticFrame *last_invoke_sf;
};

/* We associate recoded type tuples in callees with their caller's callsites.
 * This is kept as a flat view, and then folded in when the caller's sim
 * frame (see next) is popped. */
struct MVMSpeshSimCallType {
    MVMuint32 bytecode_offset;
    MVMCallsite *cs;
    MVMSpeshStatsType *arg_types;
};

void MVM_spesh_stats_update(MVMThreadContext *tc, MVMSpeshLog *sl, MVMObject *sf_updated);
void MVM_spesh_stats_cleanup(MVMThreadContext *tc, MVMObject *check_frames);
void MVM_spesh_stats_gc_mark(MVMThreadContext *tc, MVMSpeshStats *ss, MVMGCWorklist *worklist);
void MVM_spesh_stats_gc_describe(MVMThreadContext *tc, MVMHeapSnapshotState *snapshot, MVMSpeshStats *ss);
void MVM_spesh_stats_destroy(MVMThreadContext *tc, MVMSpeshStats *ss);
void MVM_spesh_sim_stack_gc_mark(MVMThreadContext *tc, MVMSpeshSimStack *sims,
    MVMGCWorklist *worklist);
void MVM_spesh_sim_stack_gc_describe(MVMThreadContext *tc, MVMHeapSnapshotState *ss, MVMSpeshSimStack *sims);
void MVM_spesh_sim_stack_destroy(MVMThreadContext *tc, MVMSpeshSimStack *sims);

Coverage Report

Created: 2018-07-03 15:31

Line	Count	Source
1		/* Statistics are stored per static frame. This data structure is only ever
2		* read/written by the specializer thread. */
3		struct MVMSpeshStats {
4		/* Statistics on a per-callsite basis. */
5		MVMSpeshStatsByCallsite *by_callsite;
6
7		/* Map of MVM_SPESH_LOG_STATIC entries for this routine. Held at the top
8		* level as they represent static resolutions, so no need to duplicate
9		* this information across callsites. */
10		MVMSpeshStatsStatic *static_values;
11
12		/* The number of entries in by_callsite. */
13		MVMuint32 num_by_callsite;
14
15		/* The number of entries in static_values. */
16		MVMuint32 num_static_values;
17
18		/* Total calls across all callsites. */
19		MVMuint32 hits;
20
21		/* Total OSR hits across all callsites. */
22		MVMuint32 osr_hits;
23
24		/* The latest version of the statistics when this was updated. Used to
25		* help decide when to throw out data that is no longer evolving, to
26		* reduce memory use. */
27		MVMuint32 last_update;
28		};
29
30		/* Statistics by callsite. */
31		struct MVMSpeshStatsByCallsite {
32		/* The callsite, or NULL for the case of no interned callsite. */
33		MVMCallsite *cs;
34
35		/* Statistics aggregated by parameter type information. */
36		MVMSpeshStatsByType *by_type;
37
38		/* The number of entries in by_type. Zero if cs == NULL. */
39		MVMuint32 num_by_type;
40
41		/* Total calls to this callsite. */
42		MVMuint32 hits;
43
44		/* Total OSR hits for this callsite. */
45		MVMuint32 osr_hits;
46
47		/* The maximum callstack depth we observed this at. */
48		MVMuint32 max_depth;
49		};
50
51		/* Statistics by type. */
52		struct MVMSpeshStatsByType {
53		/* Argument type information. Length of this is determined by the callsite
54		* of the specialization. */
55		MVMSpeshStatsType *arg_types;
56
57		/* Total calls with this callsite/type combination. */
58		MVMuint32 hits;
59
60		/* Total OSR hits for this callsite/type combination. */
61		MVMuint32 osr_hits;
62
63		/* Logged type and logged value counts, by bytecode offset. */
64		MVMSpeshStatsByOffset *by_offset;
65
66		/* Number of stats by offset we have. */
67		MVMuint32 num_by_offset;
68
69		/* The maximum callstack depth we observed this at. */
70		MVMuint32 max_depth;
71		};
72
73		/* Type statistics. */
74		struct MVMSpeshStatsType {
75		/* The type logged. */
76		MVMObject *type;
77
78		/* If applicable, and if the type is a container type, the type of the
79		* value logged inside of it. */
80		MVMObject *decont_type;
81
82		/* Whether the type and decont type were concrete. */
83		MVMuint8 type_concrete;
84		MVMuint8 decont_type_concrete;
85
86		/* If there is a container type, whether it must be rw. */
87		MVMuint8 rw_cont;
88		};
89
90		/* Statistics by bytecode offset. */
91		struct MVMSpeshStatsByOffset {
92		/* The bytecode offset these types/values were recorded at. */
93		MVMuint32 bytecode_offset;
94
95		/* Number of types recorded, with counts. */
96		MVMuint32 num_types;
97		MVMSpeshStatsTypeCount *types;
98
99		/* Number of invocation targets recorded, with counts. */
100		MVMSpeshStatsInvokeCount *invokes;
101		MVMuint32 num_invokes;
102
103		/* Number of type tuples recorded, with counts. (Type tuples are actually
104		* recorded by the callee, and then also accumulated at the callsite of
105		* the caller.) */
106		MVMuint32 num_type_tuples;
107		MVMSpeshStatsTypeTupleCount *type_tuples;
108
109		/* Number of times spesh plugin guard indexes were recorded. */
110		MVMSpeshStatsPluginGuardCount *plugin_guards;
111		MVMuint32 num_plugin_guards;
112		};
113
114		/* Counts of a given type that has shown up at a bytecode offset. */
115		struct MVMSpeshStatsTypeCount {
116		/* The type and its concreteness. */
117		MVMObject *type;
118		MVMuint8 type_concrete;
119
120		/* The number of times we've seen it. */
121		MVMuint32 count;
122		};
123
124		/* Counts of a given static frame that was invoked at a bytecode offset. */
125		struct MVMSpeshStatsInvokeCount {
126		/* The static frame. */
127		MVMStaticFrame *sf;
128
129		/* The number of times the caller frame was also the outer frame. */
130		MVMuint32 caller_is_outer_count;
131
132		/* The number of times it was resolved from a multi-dispatch. */
133		MVMuint32 was_multi_count;
134
135		/* The number of times we've seen it. */
136		MVMuint32 count;
137		};
138
139		/* Counts of a given type tuple has shown up at the callsite at a bytecode
140		* offset. */
141		struct MVMSpeshStatsTypeTupleCount {
142		/* The callsite. */
143		MVMCallsite *cs;
144
145		/* The type tuple. */
146		MVMSpeshStatsType *arg_types;
147
148		/* The number of times we've seen it. */
149		MVMuint32 count;
150		};
151
152		/* Counts of a given spesh plugin guard index. */
153		struct MVMSpeshStatsPluginGuardCount {
154		/* The guard index that the plugin resolved to. */
155		MVMuint32 guard_index;
156
157		/* The number of times we've seen it. */
158		MVMuint32 count;
159		};
160
161		/* Static values table entry. */
162		struct MVMSpeshStatsStatic {
163		/* The value. */
164		MVMObject *value;
165
166		/* The bytecode offset it was recorded at. */
167		MVMint32 bytecode_offset;
168		};
169
170		/* The maximum number of spesh stats updates before we consider a frame's
171		* stats out of date and throw them out. */
172	1.75M	#define MVM_SPESH_STATS_MAX_AGE 10
173
174		/* Logs are linear recordings marked with frame correlation IDs. We need to
175		* simulate the call stack as part of the analysis. This is the model for the
176		* stack simulation. */
177		struct MVMSpeshSimStack {
178		/* Array of frames. */
179		MVMSpeshSimStackFrame *frames;
180
181		/* Current frame index and allocated space. */
182		MVMuint32 used;
183		MVMuint32 limit;
184
185		/* Current stack depth. */
186		MVMuint32 depth;
187		};
188
189		/* This is the model of a frame on the simulated stack. */
190		struct MVMSpeshSimStackFrame {
191		/* The static frame. */
192		MVMStaticFrame *sf;
193
194		/* Spesh stats for the stack frame. */
195		MVMSpeshStats *ss;
196
197		/* Correlation ID. */
198		MVMuint32 cid;
199
200		/* Callsite stats index (not pointer in case of realloc). */
201		MVMuint32 callsite_idx;
202
203		/* Type stats index (not pointer in case of realloc); -1 if not yet set.
204		* This is resolved once using arg_types, and then remembered, so we can
205		* correlate the statistics across spesh log buffers. */
206		MVMint32 type_idx;
207
208		/* Argument types logged. Sized by number of callsite flags. */
209		MVMSpeshStatsType *arg_types;
210
211		/* Spesh log entries for types and values, for later processing. */
212		MVMSpeshLogEntry **offset_logs;
213		MVMuint32 offset_logs_used;
214		MVMuint32 offset_logs_limit;
215
216		/* Type tuples observed at a given callsite offset, for later
217		* processing. */
218		MVMSpeshSimCallType *call_type_info;
219		MVMuint32 call_type_info_used;
220		MVMuint32 call_type_info_limit;
221
222		/* Number of times we crossed an OSR point. */
223		MVMuint32 osr_hits;
224
225		/* The last bytecode offset and static frame seen in an invoke recording;
226		* used for producing callsite type stats based on callee type tuples. */
227		MVMuint32 last_invoke_offset;
228		MVMStaticFrame *last_invoke_sf;
229		};
230
231		/* We associate recoded type tuples in callees with their caller's callsites.
232		* This is kept as a flat view, and then folded in when the caller's sim
233		* frame (see next) is popped. */
234		struct MVMSpeshSimCallType {
235		MVMuint32 bytecode_offset;
236		MVMCallsite *cs;
237		MVMSpeshStatsType *arg_types;
238		};
239
240		void MVM_spesh_stats_update(MVMThreadContext tc, MVMSpeshLog sl, MVMObject *sf_updated);
241		void MVM_spesh_stats_cleanup(MVMThreadContext tc, MVMObject check_frames);
242		void MVM_spesh_stats_gc_mark(MVMThreadContext tc, MVMSpeshStats ss, MVMGCWorklist *worklist);
243		void MVM_spesh_stats_gc_describe(MVMThreadContext tc, MVMHeapSnapshotState snapshot, MVMSpeshStats *ss);
244		void MVM_spesh_stats_destroy(MVMThreadContext tc, MVMSpeshStats ss);
245		void MVM_spesh_sim_stack_gc_mark(MVMThreadContext tc, MVMSpeshSimStack sims,
246		MVMGCWorklist *worklist);
247		void MVM_spesh_sim_stack_gc_describe(MVMThreadContext tc, MVMHeapSnapshotState ss, MVMSpeshSimStack *sims);
248		void MVM_spesh_sim_stack_destroy(MVMThreadContext tc, MVMSpeshSimStack sims);