9988292057

Committed 18 Jul 2024 08:37AM UTC coverage: 85.833% (+0.03%) from 85.808%

Build # 9988292057

Build Type

push

github

Committed by

sergepetrenko

Commit Message

applier: fix assertion failure after split brain

After receiving async transaction from an old term applier_apply_tx
exits without unlocking the latch. If the same applier tries to
subscribe for replication, it fails with assertion, as the latch is
already locked.

Let's fix the function, which raises error so that it just sets
diag and returns -1.

Closes #10073

NO_DOC=bugfix
NO_CHANGELOG=no crash on release version

(cherry picked from commit 5ce010c5e)

Run Details

62718 of 113974 branches covered (55.03%)

12 of 12 new or added lines in 1 file covered. (100.0%)

10 existing lines in 7 files now uncovered.

93651 of 109108 relevant lines covered (85.83%)

2451533.6 hits per line

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

95.4

/src/histogram.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 "trivia/util.h"
#include "memory.h"
#include "histogram.h"

#include <assert.h>

struct histogram *
histogram_new(const int64_t *buckets, size_t n_buckets)
{
        struct histogram *hist;

        assert(n_buckets > 0);
        for (size_t i = 1; i < n_buckets; i++)
                assert(buckets[i - 1] < buckets[i]);

        hist = malloc(sizeof(*hist) + n_buckets * sizeof(*hist->buckets));
        if (hist == NULL)
                return NULL;

        hist->max = buckets[n_buckets - 1];
        hist->total = 0;
        hist->n_buckets = n_buckets;

        for (size_t i = 0; i < n_buckets; i++) {
                hist->buckets[i].count = 0;
                hist->buckets[i].max = buckets[i];
        }
        return hist;
}

void
histogram_delete(struct histogram *hist)
{
        free(hist);
}

void
histogram_reset(struct histogram *hist)
{
        hist->total = 0;
        for (size_t i = 0; i < hist->n_buckets; i++)
                hist->buckets[i].count = 0;
        hist->max = hist->buckets[hist->n_buckets - 1].max;
}

static struct histogram_bucket *
histogram_lookup_bucket(struct histogram *hist, int64_t val)
{
        size_t begin, end, mid;
        struct histogram_bucket *bucket;

        begin = 0;
        end = hist->n_buckets - 1;
        while (1) {
                if (begin == end) {
                        bucket = &hist->buckets[begin];
                        if (val > bucket->max)
                                bucket = &hist->buckets[end];
                        break;
                } else {
                        mid = begin / 2 + end / 2;
                        bucket = &hist->buckets[mid];
                }

                if (val > hist->buckets[mid].max)
                        begin = mid + 1;
                else
                        end = mid;
        };

        if (val <= bucket->max)
                return bucket;
        return NULL;
}

void
histogram_collect(struct histogram *hist, int64_t val)
{
        struct histogram_bucket *bucket;

        bucket = histogram_lookup_bucket(hist, val);
        if (bucket != NULL)
                bucket->count++;
        if (hist->max < val)
                hist->max = val;
        hist->total++;
}

void
histogram_discard(struct histogram *hist, int64_t val)
{
        struct histogram_bucket *bucket;

        bucket = histogram_lookup_bucket(hist, val);
        if (bucket != NULL) {
                assert(bucket->count > 0);
                bucket->count--;
        }
        assert(hist->total > 0);
        hist->total--;
}

int64_t
histogram_percentile(struct histogram *hist, int pct)
{
        size_t count = 0;

        for (size_t i = 0; i < hist->n_buckets; i++) {
                struct histogram_bucket *bucket = &hist->buckets[i];
                count += bucket->count;
                if (count * 100 > hist->total * pct)
                        return bucket->max;
        }
        return hist->max;
}

int64_t
histogram_percentile_lower(struct histogram *hist, int pct)
{
        size_t count = 0;

        for (size_t i = 0; i < hist->n_buckets; i++) {
                count += hist->buckets[i].count;
                if (count * 100 > hist->total * pct)
                        return hist->buckets[i > 0 ? i - 1 : 0].max;
        }
        return hist->max;
}

int
histogram_snprint(char *buf, int size, struct histogram *hist)
{
        int total = 0;
        bool first = true;

        for (size_t i = 0; i < hist->n_buckets; i++) {
                int64_t count = hist->buckets[i].count;
                if (count == 0)
                        continue;

                int64_t min = (i > 0) ? hist->buckets[i - 1].max + 1 : 0;
                int64_t max = hist->buckets[i].max;

                if (!first)
                        SNPRINT(total, snprintf, buf, size, " ");

                SNPRINT(total, snprintf, buf, size, "[%"PRIi64, min);
                if (max != min)
                        SNPRINT(total, snprintf, buf, size, "-%"PRIi64, max);
                SNPRINT(total, snprintf, buf, size, "]:%"PRIi64, count);

                first = false;
        }
        return total;
}

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
32	#include "trivia/util.h"
33	#include "memory.h"
34	#include "histogram.h"
35
36	#include <assert.h>
37
38	struct histogram *
39	histogram_new(const int64_t *buckets, size_t n_buckets)	28,457✔
40	{
41	struct histogram *hist;
42
43	assert(n_buckets > 0);	28,457!
44	for (size_t i = 1; i < n_buckets; i++)	1,154,580✔
45	assert(buckets[i - 1] < buckets[i]);	1,126,120!
46
47	hist = malloc(sizeof(hist) + n_buckets sizeof(*hist->buckets));	28,457✔
48	if (hist == NULL)	28,457!
49	return NULL;	×
50
51	hist->max = buckets[n_buckets - 1];	28,457✔
52	hist->total = 0;	28,457✔
53	hist->n_buckets = n_buckets;	28,457✔
54
55	for (size_t i = 0; i < n_buckets; i++) {	1,183,030✔
56	hist->buckets[i].count = 0;	1,154,580✔
57	hist->buckets[i].max = buckets[i];	1,154,580✔
58	}
59	return hist;	28,457✔
60	}
61
62	void
63	histogram_delete(struct histogram *hist)	24,650✔
64	{
65	free(hist);	24,650✔
66	}	24,650✔
67
68	void
69	histogram_reset(struct histogram *hist)	95✔
70	{
71	hist->total = 0;	95✔
72	for (size_t i = 0; i < hist->n_buckets; i++)	5,529✔
73	hist->buckets[i].count = 0;	5,434✔
74	hist->max = hist->buckets[hist->n_buckets - 1].max;	95✔
75	}	95✔
76
77	static struct histogram_bucket *
78	histogram_lookup_bucket(struct histogram *hist, int64_t val)	3,540,140✔
79	{
80	size_t begin, end, mid;
81	struct histogram_bucket *bucket;
82
83	begin = 0;	3,540,140✔
84	end = hist->n_buckets - 1;	3,540,140✔
85	while (1) {
86	if (begin == end) {	24,734,900✔
87	bucket = &hist->buckets[begin];	3,540,140✔
88	if (val > bucket->max)	3,540,140✔
89	bucket = &hist->buckets[end];	815✔
90	break;	3,540,140✔
91	} else {
92	mid = begin / 2 + end / 2;	21,194,800✔
93	bucket = &hist->buckets[mid];	21,194,800✔
94	}
95
96	if (val > hist->buckets[mid].max)	21,194,800✔
97	begin = mid + 1;	271,605✔
98	else
99	end = mid;	20,923,200✔
100	};
101
102	if (val <= bucket->max)	3,540,140✔
103	return bucket;	3,539,330✔
104	return NULL;	815✔
105	}
106
107	void
108	histogram_collect(struct histogram *hist, int64_t val)	3,535,280✔
109	{
110	struct histogram_bucket *bucket;
111
112	bucket = histogram_lookup_bucket(hist, val);	3,535,280✔
113	if (bucket != NULL)	3,535,280✔
114	bucket->count++;	3,534,470✔
115	if (hist->max < val)	3,535,280✔
116	hist->max = val;	11✔
117	hist->total++;	3,535,280✔
118	}	3,535,280✔
119
120	void
121	histogram_discard(struct histogram *hist, int64_t val)	4,860✔
122	{
123	struct histogram_bucket *bucket;
124
125	bucket = histogram_lookup_bucket(hist, val);	4,860✔
126	if (bucket != NULL) {	4,860✔
127	assert(bucket->count > 0);	4,859!
128	bucket->count--;	4,859✔
129	}
130	assert(hist->total > 0);	4,860!
131	hist->total--;	4,860✔
132	}	4,860✔
133
134	int64_t
135	histogram_percentile(struct histogram *hist, int pct)	7,519✔
136	{
137	size_t count = 0;	7,519✔
138
139	for (size_t i = 0; i < hist->n_buckets; i++) {	19,994!
140	struct histogram_bucket *bucket = &hist->buckets[i];	19,994✔
141	count += bucket->count;	19,994✔
142	if (count * 100 > hist->total * pct)	19,994✔
143	return bucket->max;	7,519✔
144	}
UNCOV 145	return hist->max;	×
146	}
147
148	int64_t
149	histogram_percentile_lower(struct histogram *hist, int pct)	66✔
150	{
151	size_t count = 0;	66✔
152
153	for (size_t i = 0; i < hist->n_buckets; i++) {	1,077!
154	count += hist->buckets[i].count;	1,077✔
155	if (count * 100 > hist->total * pct)	1,077✔
156	return hist->buckets[i > 0 ? i - 1 : 0].max;	66✔
157	}
UNCOV 158	return hist->max;	×
159	}
160
161	int
162	histogram_snprint(char buf, int size, struct histogram hist)	1,500✔
163	{
164	int total = 0;	1,500✔
165	bool first = true;	1,500✔
166
167	for (size_t i = 0; i < hist->n_buckets; i++) {	25,500✔
168	int64_t count = hist->buckets[i].count;	24,000✔
169	if (count == 0)	24,000✔
170	continue;	22,482✔
171
172	int64_t min = (i > 0) ? hist->buckets[i - 1].max + 1 : 0;	1,518✔
173	int64_t max = hist->buckets[i].max;	1,518✔
174
175	if (!first)	1,518✔
176	SNPRINT(total, snprintf, buf, size, " ");	18!
177
178	SNPRINT(total, snprintf, buf, size, "[%"PRIi64, min);	1,518!
179	if (max != min)	1,518!
180	SNPRINT(total, snprintf, buf, size, "-%"PRIi64, max);	×
181	SNPRINT(total, snprintf, buf, size, "]:%"PRIi64, count);	1,518!
182
183	first = false;	1,518✔
184	}
185	return total;	1,500✔
186	}

tarantool / tarantool / 9988292057

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