12478858925

Committed 24 Dec 2024 07:59AM UTC coverage: 87.359% (-0.03%) from 87.392%

Build # 12478858925

Build Type

push

github

Committed by

Buristan

Commit Message

ci: add paths filter to perf_micro workflow

The workflow `perf_micro` is heavy and takes about 20 minutes.
Running benchmarks on unrelated changes is useless, so the patch
limits the list of files that will trigger a run.

NO_CHANGELOG=performance
NO_DOC=performance
NO_TEST=performance

(cherry picked from commit 7db102c78)

Run Details

69657 of 123524 branches covered (56.39%)

102613 of 117461 relevant lines covered (87.36%)

2936086.31 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

90.51

/src/box/engine.c

/*
 * Copyright 2010-2016, Tarantool AUTHORS, please see AUTHORS file.
 *
 * Redistribution and use in source and binary forms, with or
 * without modification, are permitted provided that the following
 * conditions are met:
 *
 * 1. Redistributions of source code must retain the above
 *    copyright notice, this list of conditions and the
 *    following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above
 *    copyright notice, this list of conditions and the following
 *    disclaimer in the documentation and/or other materials
 *    provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY <COPYRIGHT HOLDER> ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
 * <COPYRIGHT HOLDER> OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
 * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */
#include "engine.h"

#include <stdbool.h>
#include <stddef.h>
#include <string.h>

#include "errinj.h"
#include "fiber.h"
#include "small/rlist.h"

RLIST_HEAD(engines);

enum recovery_state recovery_state = RECOVERY_NOT_STARTED;

/** Register engine instance. */
void engine_register(struct engine *engine)
{
        static int n_engines;
        rlist_add_tail_entry(&engines, engine, link);
        engine->id = n_engines++;
}

/** Find engine by name. */
struct engine *
engine_by_name(const char *name)
{
        struct engine *e;
        engine_foreach(e) {
                if (strcmp(e->name, name) == 0)
                        return e;
        }
        return NULL;
}

void
engine_shutdown(void)
{
        struct engine *engine, *tmp;
        rlist_foreach_entry_safe(engine, &engines, link, tmp) {
                engine->vtab->shutdown(engine);
        }
}

void
engine_free(void)
{
        struct engine *engine, *tmp;
        rlist_foreach_entry_safe(engine, &engines, link, tmp) {
                engine->vtab->free(engine);
        }
}

void
engine_switch_to_ro(void)
{
        struct engine *engine;
        engine_foreach(engine)
                engine->vtab->switch_to_ro(engine);
}

int
engine_bootstrap(void)
{
        recovery_state = INITIAL_RECOVERY;
        struct engine *engine;
        engine_foreach(engine) {
                if (engine->vtab->bootstrap(engine) != 0)
                        return -1;
        }
        recovery_state = FINISHED_RECOVERY;
        return 0;
}

int
engine_begin_initial_recovery(const struct vclock *recovery_vclock)
{
        recovery_state = INITIAL_RECOVERY;
        struct engine *engine;
        engine_foreach(engine) {
                if (engine->vtab->begin_initial_recovery(engine,
                                        recovery_vclock) != 0)
                        return -1;
        }
        return 0;
}

int
engine_begin_final_recovery(void)
{
        recovery_state = FINAL_RECOVERY;
        struct engine *engine;
        engine_foreach(engine) {
                if (engine->vtab->begin_final_recovery(engine) != 0)
                        return -1;
        }
        return 0;
}

int
engine_begin_hot_standby(void)
{
        struct engine *engine;
        engine_foreach(engine) {
                if (engine->vtab->begin_hot_standby(engine) != 0)
                        return -1;
        }
        return 0;
}

int
engine_end_recovery(void)
{
        recovery_state = FINISHED_RECOVERY;
        /*
         * For all new spaces created after recovery is complete,
         * when the primary key is added, enable all keys.
         */
        struct engine *engine;
        engine_foreach(engine) {
                if (engine->vtab->end_recovery(engine) != 0)
                        return -1;
        }
        return 0;
}

int
engine_begin_checkpoint(bool is_scheduled)
{
        struct engine *engine;
        engine_foreach(engine) {
                if (engine->vtab->begin_checkpoint(engine, is_scheduled) < 0)
                        return -1;
        }
        return 0;
}

int
engine_commit_checkpoint(const struct vclock *vclock)
{
        struct engine *engine;
        engine_foreach(engine) {
                if (engine->vtab->wait_checkpoint(engine, vclock) < 0)
                        return -1;
        }
        engine_foreach(engine) {
                engine->vtab->commit_checkpoint(engine, vclock);
        }
        return 0;
}

void
engine_abort_checkpoint(void)
{
        struct engine *engine;
        engine_foreach(engine)
                engine->vtab->abort_checkpoint(engine);
}

void
engine_collect_garbage(const struct vclock *vclock)
{
        struct engine *engine;
        engine_foreach(engine)
                engine->vtab->collect_garbage(engine, vclock);
}

int
engine_backup(const struct vclock *vclock, engine_backup_cb cb, void *cb_arg)
{
        struct engine *engine;
        engine_foreach(engine) {
                if (engine->vtab->backup(engine, vclock, cb, cb_arg) < 0)
                        return -1;
        }
        return 0;
}

int
engine_prepare_join(struct engine_join_ctx *ctx)
{
        ctx->data = xcalloc(MAX_ENGINE_COUNT, sizeof(void *));
        struct engine *engine;
        engine_foreach(engine) {
                if (engine->vtab->prepare_join(engine, ctx) != 0)
                        goto fail;
        }
        return 0;
fail:
        engine_complete_join(ctx);
        return -1;
}

int
engine_join(struct engine_join_ctx *ctx, struct xstream *stream)
{
        ERROR_INJECT_YIELD(ERRINJ_ENGINE_JOIN_DELAY);

        struct engine *engine;
        engine_foreach(engine) {
                if (engine->vtab->join(engine, ctx, stream) != 0)
                        return -1;
        }
        return 0;
}

void
engine_complete_join(struct engine_join_ctx *ctx)
{
        struct engine *engine;
        engine_foreach(engine) {
                engine->vtab->complete_join(engine, ctx);
        }
        free(ctx->data);
}

void
engine_memory_stat(struct engine_memory_stat *stat)
{
        memset(stat, 0, sizeof(*stat));
        struct engine *engine;
        engine_foreach(engine)
                engine->vtab->memory_stat(engine, stat);
}

void
engine_reset_stat(void)
{
        struct engine *engine;
        engine_foreach(engine)
                engine->vtab->reset_stat(engine);
}

/* {{{ Virtual method stubs */

struct engine_read_view *
generic_engine_create_read_view(struct engine *engine,
                                const struct read_view_opts *opts)
{
        (void)engine;
        (void)opts;
        unreachable();
        return NULL;
}

int
generic_engine_prepare_join(struct engine *engine, struct engine_join_ctx *ctx)
{
        ctx->data[engine->id] = NULL;
        return 0;
}

int
generic_engine_join(struct engine *engine, struct engine_join_ctx *ctx,
                    struct xstream *stream)
{
        (void)engine;
        (void)ctx;
        (void)stream;
        return 0;
}

void
generic_engine_complete_join(struct engine *engine, struct engine_join_ctx *ctx)
{
        (void)engine;
        (void)ctx;
}

int
generic_engine_begin(struct engine *engine, struct txn *txn)
{
        (void)engine;
        (void)txn;
        return 0;
}

int
generic_engine_begin_statement(struct engine *engine, struct txn *txn)
{
        (void)engine;
        (void)txn;
        return 0;
}

int
generic_engine_prepare(struct engine *engine, struct txn *txn)
{
        (void)engine;
        (void)txn;
        return 0;
}

void
generic_engine_commit(struct engine *engine, struct txn *txn)
{
        (void)engine;
        (void)txn;
}

void
generic_engine_rollback_statement(struct engine *engine, struct txn *txn,
                                  struct txn_stmt *stmt)
{
        (void)engine;
        (void)txn;
        (void)stmt;
}

void
generic_engine_rollback(struct engine *engine, struct txn *txn)
{
        (void)engine;
        (void)txn;
}

void
generic_engine_switch_to_ro(struct engine *engine)
{
        (void)engine;
}

int
generic_engine_bootstrap(struct engine *engine)
{
        (void)engine;
        return 0;
}

int
generic_engine_begin_initial_recovery(struct engine *engine,
                                      const struct vclock *vclock)
{
        (void)engine;
        (void)vclock;
        return 0;
}

int
generic_engine_begin_final_recovery(struct engine *engine)
{
        (void)engine;
        return 0;
}

int
generic_engine_begin_hot_standby(struct engine *engine)
{
        (void)engine;
        return 0;
}

int
generic_engine_end_recovery(struct engine *engine)
{
        (void)engine;
        return 0;
}

int
generic_engine_begin_checkpoint(struct engine *engine, bool is_scheduled)
{
        (void)engine;
        (void)is_scheduled;
        return 0;
}

int
generic_engine_wait_checkpoint(struct engine *engine,
                               const struct vclock *vclock)
{
        (void)engine;
        (void)vclock;
        return 0;
}

void
generic_engine_commit_checkpoint(struct engine *engine,
                                 const struct vclock *vclock)
{
        (void)engine;
        (void)vclock;
}

void
generic_engine_abort_checkpoint(struct engine *engine)
{
        (void)engine;
}

void
generic_engine_collect_garbage(struct engine *engine,
                               const struct vclock *vclock)
{
        (void)engine;
        (void)vclock;
}

int
generic_engine_backup(struct engine *engine, const struct vclock *vclock,
                      engine_backup_cb cb, void *cb_arg)
{
        (void)engine;
        (void)vclock;
        (void)cb;
        (void)cb_arg;
        return 0;
}

void
generic_engine_memory_stat(struct engine *engine,
                           struct engine_memory_stat *stat)
{
        (void)engine;
        (void)stat;
}

void
generic_engine_reset_stat(struct engine *engine)
{
        (void)engine;
}

int
generic_engine_check_space_def(struct space_def *def)
{
        (void)def;
        return 0;
}

void
generic_engine_shutdown(struct engine *engine)
{
        (void)engine;
}

/* }}} */

1	/*
2	* Copyright 2010-2016, Tarantool AUTHORS, please see AUTHORS file.
3	*
4	* Redistribution and use in source and binary forms, with or
5	* without modification, are permitted provided that the following
6	* conditions are met:
7	*
8	* 1. Redistributions of source code must retain the above
9	* copyright notice, this list of conditions and the
10	* following disclaimer.
11	*
12	* 2. Redistributions in binary form must reproduce the above
13	* copyright notice, this list of conditions and the following
14	* disclaimer in the documentation and/or other materials
15	* provided with the distribution.
16	*
17	* THIS SOFTWARE IS PROVIDED BY <COPYRIGHT HOLDER> ``AS IS'' AND
18	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
19	* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
20	* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
21	* <COPYRIGHT HOLDER> OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
22	* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
24	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
25	* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
26	* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
28	* THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29	* SUCH DAMAGE.
30	*/
31	#include "engine.h"
32
33	#include <stdbool.h>
34	#include <stddef.h>
35	#include <string.h>
36
37	#include "errinj.h"
38	#include "fiber.h"
39	#include "small/rlist.h"
40
41	RLIST_HEAD(engines);
42
43	enum recovery_state recovery_state = RECOVERY_NOT_STARTED;
44
45	/** Register engine instance. */
46	void engine_register(struct engine *engine)	22,375✔
47	{
48	static int n_engines;
49	rlist_add_tail_entry(&engines, engine, link);	22,375✔
50	engine->id = n_engines++;	22,375✔
51	}	22,375✔
52
53	/** Find engine by name. */
54	struct engine *
55	engine_by_name(const char *name)	1,080,720✔
56	{
57	struct engine *e;
58	engine_foreach(e) {	2,104,680✔
59	if (strcmp(e->name, name) == 0)	1,592,610✔
60	return e;	1,080,640✔
61	}
62	return NULL;	85✔
63	}
64
65	void
66	engine_shutdown(void)	4,337✔
67	{
68	struct engine engine, tmp;
69	rlist_foreach_entry_safe(engine, &engines, link, tmp) {	47,707!
70	engine->vtab->shutdown(engine);	21,685✔
71	}
72	}	4,337✔
73
74	void
75	engine_free(void)	4,336✔
76	{
77	struct engine engine, tmp;
78	rlist_foreach_entry_safe(engine, &engines, link, tmp) {	47,696!
79	engine->vtab->free(engine);	21,680✔
80	}
81	}	4,336✔
82
83	void
84	engine_switch_to_ro(void)	2,583✔
85	{
86	struct engine *engine;
87	engine_foreach(engine)	28,413✔
88	engine->vtab->switch_to_ro(engine);	12,915✔
89	}	2,583✔
90
91	int
92	engine_bootstrap(void)	2,880✔
93	{
94	recovery_state = INITIAL_RECOVERY;	2,880✔
95	struct engine *engine;
96	engine_foreach(engine) {	31,654✔
97	if (engine->vtab->bootstrap(engine) != 0)	14,390✔
98	return -1;	3✔
99	}
100	recovery_state = FINISHED_RECOVERY;	2,877✔
101	return 0;	2,877✔
102	}
103
104	int
105	engine_begin_initial_recovery(const struct vclock *recovery_vclock)	1,568✔
106	{
107	recovery_state = INITIAL_RECOVERY;	1,568✔
108	struct engine *engine;
109	engine_foreach(engine) {	17,248✔
110	if (engine->vtab->begin_initial_recovery(engine,	7,840!
111	recovery_vclock) != 0)
112	return -1;	×
113	}
114	return 0;	1,568✔
115	}
116
117	int
118	engine_begin_final_recovery(void)	1,550✔
119	{
120	recovery_state = FINAL_RECOVERY;	1,550✔
121	struct engine *engine;
122	engine_foreach(engine) {	17,050✔
123	if (engine->vtab->begin_final_recovery(engine) != 0)	7,750!
124	return -1;	×
125	}
126	return 0;	1,550✔
127	}
128
129	int
130	engine_begin_hot_standby(void)	4✔
131	{
132	struct engine *engine;
133	engine_foreach(engine) {	36✔
134	if (engine->vtab->begin_hot_standby(engine) != 0)	17✔
135	return -1;	1✔
136	}
137	return 0;	3✔
138	}
139
140	int
141	engine_end_recovery(void)	1,540✔
142	{
143	recovery_state = FINISHED_RECOVERY;	1,540✔
144	/*
145	* For all new spaces created after recovery is complete,
146	* when the primary key is added, enable all keys.
147	*/
148	struct engine *engine;
149	engine_foreach(engine) {	16,930✔
150	if (engine->vtab->end_recovery(engine) != 0)	7,696✔
151	return -1;	1✔
152	}
153	return 0;	1,539✔
154	}
155
156	int
157	engine_begin_checkpoint(bool is_scheduled)	4,931✔
158	{
159	struct engine *engine;
160	engine_foreach(engine) {	54,231✔
161	if (engine->vtab->begin_checkpoint(engine, is_scheduled) < 0)	24,651✔
162	return -1;	1✔
163	}
164	return 0;	4,930✔
165	}
166
167	int
168	engine_commit_checkpoint(const struct vclock *vclock)	4,924✔
169	{
170	struct engine *engine;
171	engine_foreach(engine) {	53,936✔
172	if (engine->vtab->wait_checkpoint(engine, vclock) < 0)	24,532✔
173	return -1;	26✔
174	}
175	engine_foreach(engine) {	53,868✔
176	engine->vtab->commit_checkpoint(engine, vclock);	24,486✔
177	}
178	return 0;	4,897✔
179	}
180
181	void
182	engine_abort_checkpoint(void)	33✔
183	{
184	struct engine *engine;
185	engine_foreach(engine)	363✔
186	engine->vtab->abort_checkpoint(engine);	165✔
187	}	33✔
188
189	void
190	engine_collect_garbage(const struct vclock *vclock)	860✔
191	{
192	struct engine *engine;
193	engine_foreach(engine)	9,460✔
194	engine->vtab->collect_garbage(engine, vclock);	4,300✔
195	}	860✔
196
197	int
198	engine_backup(const struct vclock vclock, engine_backup_cb cb, void cb_arg)	11✔
199	{
200	struct engine *engine;
201	engine_foreach(engine) {	121✔
202	if (engine->vtab->backup(engine, vclock, cb, cb_arg) < 0)	55!
203	return -1;	×
204	}
205	return 0;	11✔
206	}
207
208	int
209	engine_prepare_join(struct engine_join_ctx *ctx)	752✔
210	{
211	ctx->data = xcalloc(MAX_ENGINE_COUNT, sizeof(void *));	752!
212	struct engine *engine;
213	engine_foreach(engine) {	8,272✔
214	if (engine->vtab->prepare_join(engine, ctx) != 0)	3,760!
215	goto fail;	×
216	}
217	return 0;	752✔
218	fail:	×
219	engine_complete_join(ctx);	×
220	return -1;	×
221	}
222
223	int
224	engine_join(struct engine_join_ctx ctx, struct xstream stream)	752✔
225	{
226	ERROR_INJECT_YIELD(ERRINJ_ENGINE_JOIN_DELAY);	1,517!
227
228	struct engine *engine;
229	engine_foreach(engine) {	8,234✔
230	if (engine->vtab->join(engine, ctx, stream) != 0)	3,745✔
231	return -1;	4✔
232	}
233	return 0;	748✔
234	}
235
236	void
237	engine_complete_join(struct engine_join_ctx *ctx)	752✔
238	{
239	struct engine *engine;
240	engine_foreach(engine) {	8,272✔
241	engine->vtab->complete_join(engine, ctx);	3,760✔
242	}
243	free(ctx->data);	752✔
244	}	752✔
245
246	void
247	engine_memory_stat(struct engine_memory_stat *stat)	72✔
248	{
249	memset(stat, 0, sizeof(*stat));	72✔
250	struct engine *engine;
251	engine_foreach(engine)	792✔
252	engine->vtab->memory_stat(engine, stat);	360✔
253	}	72✔
254
255	void
256	engine_reset_stat(void)	28✔
257	{
258	struct engine *engine;
259	engine_foreach(engine)	308✔
260	engine->vtab->reset_stat(engine);	140✔
261	}	28✔
262
263	/* {{{ Virtual method stubs */
264
265	struct engine_read_view *
266	generic_engine_create_read_view(struct engine *engine,	×
267	const struct read_view_opts *opts)
268	{
269	(void)engine;
270	(void)opts;
271	unreachable();	×
272	return NULL;
273	}
274
275	int
276	generic_engine_prepare_join(struct engine engine, struct engine_join_ctx ctx)	2,256✔
277	{
278	ctx->data[engine->id] = NULL;	2,256✔
279	return 0;	2,256✔
280	}
281
282	int
283	generic_engine_join(struct engine engine, struct engine_join_ctx ctx,	2,244✔
284	struct xstream *stream)
285	{
286	(void)engine;
287	(void)ctx;
288	(void)stream;
289	return 0;	2,244✔
290	}
291
292	void
293	generic_engine_complete_join(struct engine engine, struct engine_join_ctx ctx)	2,256✔
294	{
295	(void)engine;
296	(void)ctx;
297	}	2,256✔
298
299	int
300	generic_engine_begin(struct engine engine, struct txn txn)	×
301	{
302	(void)engine;
303	(void)txn;
304	return 0;	×
305	}
306
307	int
308	generic_engine_begin_statement(struct engine engine, struct txn txn)	14,300,000✔
309	{
310	(void)engine;
311	(void)txn;
312	return 0;	14,300,000✔
313	}
314
315	int
316	generic_engine_prepare(struct engine engine, struct txn txn)	×
317	{
318	(void)engine;
319	(void)txn;
320	return 0;	×
321	}
322
323	void
324	generic_engine_commit(struct engine engine, struct txn txn)	×
325	{
326	(void)engine;
327	(void)txn;
328	}	×
329
330	void
331	generic_engine_rollback_statement(struct engine engine, struct txn txn,	37✔
332	struct txn_stmt *stmt)
333	{
334	(void)engine;
335	(void)txn;
336	(void)stmt;
337	}	37✔
338
339	void
340	generic_engine_rollback(struct engine engine, struct txn txn)	31,189✔
341	{
342	(void)engine;
343	(void)txn;
344	}	31,189✔
345
346	void
347	generic_engine_switch_to_ro(struct engine *engine)	10,332✔
348	{
349	(void)engine;
350	}	10,332✔
351
352	int
353	generic_engine_bootstrap(struct engine *engine)	8,631✔
354	{
355	(void)engine;
356	return 0;	8,631✔
357	}
358
359	int
360	generic_engine_begin_initial_recovery(struct engine *engine,	4,704✔
361	const struct vclock *vclock)
362	{
363	(void)engine;
364	(void)vclock;
365	return 0;	4,704✔
366	}
367
368	int
369	generic_engine_begin_final_recovery(struct engine *engine)	4,650✔
370	{
371	(void)engine;
372	return 0;	4,650✔
373	}
374
375	int
376	generic_engine_begin_hot_standby(struct engine *engine)	9✔
377	{
378	(void)engine;
379	return 0;	9✔
380	}
381
382	int
383	generic_engine_end_recovery(struct engine *engine)	4,617✔
384	{
385	(void)engine;
386	return 0;	4,617✔
387	}
388
389	int
390	generic_engine_begin_checkpoint(struct engine *engine, bool is_scheduled)	14,790✔
391	{
392	(void)engine;
393	(void)is_scheduled;
394	return 0;	14,790✔
395	}
396
397	int
398	generic_engine_wait_checkpoint(struct engine *engine,	14,694✔
399	const struct vclock *vclock)
400	{
401	(void)engine;
402	(void)vclock;
403	return 0;	14,694✔
404	}
405
406	void
407	generic_engine_commit_checkpoint(struct engine *engine,	14,691✔
408	const struct vclock *vclock)
409	{
410	(void)engine;
411	(void)vclock;
412	}	14,691✔
413
414	void
415	generic_engine_abort_checkpoint(struct engine *engine)	99✔
416	{
417	(void)engine;
418	}	99✔
419
420	void
421	generic_engine_collect_garbage(struct engine *engine,	2,580✔
422	const struct vclock *vclock)
423	{
424	(void)engine;
425	(void)vclock;
426	}	2,580✔
427
428	int
429	generic_engine_backup(struct engine engine, const struct vclock vclock,	33✔
430	engine_backup_cb cb, void *cb_arg)
431	{
432	(void)engine;
433	(void)vclock;
434	(void)cb;
435	(void)cb_arg;
436	return 0;	33✔
437	}
438
439	void
440	generic_engine_memory_stat(struct engine *engine,	216✔
441	struct engine_memory_stat *stat)
442	{
443	(void)engine;
444	(void)stat;
445	}	216✔
446
447	void
448	generic_engine_reset_stat(struct engine *engine)	112✔
449	{
450	(void)engine;
451	}	112✔
452
453	int
454	generic_engine_check_space_def(struct space_def *def)	199,349✔
455	{
456	(void)def;
457	return 0;	199,349✔
458	}
459
460	void
461	generic_engine_shutdown(struct engine *engine)	13,011✔
462	{
463	(void)engine;
464	}	13,011✔
465
466	/* }}} */

tarantool / tarantool / 12478858925

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous