12275347388

Committed 11 Dec 2024 11:23AM UTC coverage: 87.276%. Remained the same

Build # 12275347388

Build Type

push

github

Committed by

sergepetrenko

Commit Message

relay: fix sending raft requests with GROUP_DEFAULT id

Commit 7aac790ef3e28 ("relay: send raft requests with GROUP_DEFAULT id")
tried to send all raft rows with GROUP_DEFAULT id. However, relay didn't
know the version_id of the instance during initial JOIN, so raft state
was sent with GROUP_LOCAL id. The test didn't properly work.

This commit fixes relay by setting proper version_id during initial JOIN.
The test is also fully rewritten.

Follows up #10727

NO_DOC=bugfix
NO_CHANGELOG=<already present>

(cherry picked from commit a15c54c77)

Run Details

68606 of 121844 branches covered (56.31%)

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

263 existing lines in 14 files now uncovered.

101204 of 115958 relevant lines covered (87.28%)

2690835.47 hits per line

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

79.14

/src/box/tuple_bloom.c

/*
 * Copyright 2010-2018, 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 "tuple_bloom.h"

#include <assert.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <msgpuck.h>
#include "diag.h"
#include "errcode.h"
#include "key_def.h"
#include "tuple.h"
#include "salad/bloom.h"
#include "trivia/util.h"
#include <PMurHash.h>

enum { HASH_SEED = 13U };

struct tuple_bloom_builder *
tuple_bloom_builder_new(uint32_t part_count)
{
        size_t size = sizeof(struct tuple_bloom_builder) +
                part_count * sizeof(struct tuple_hash_array);
        struct tuple_bloom_builder *builder = malloc(size);
        if (builder == NULL) {
                diag_set(OutOfMemory, size, "malloc", "tuple bloom builder");
                return NULL;
        }
        memset(builder, 0, size);
        builder->part_count = part_count;
        return builder;
}

void
tuple_bloom_builder_delete(struct tuple_bloom_builder *builder)
{
        for (uint32_t i = 0; i < builder->part_count; i++)
                free(builder->parts[i].values);
        free(builder);
}

/**
 * Add a tuple hash to a hash array unless it's already there.
 * Reallocate the array if necessary.
 */
static int
tuple_hash_array_add(struct tuple_hash_array *hash_arr, uint32_t hash)
{
        if (hash_arr->count > 0 &&
            hash_arr->values[hash_arr->count - 1] == hash) {
                /*
                 * This part is already in the bloom, proceed
                 * to the next one. Note, this check only works
                 * if tuples are added in the order defined by
                 * the key definition.
                 */
                return 0;
        }
        if (hash_arr->count >= hash_arr->capacity) {
                uint32_t capacity = MAX(hash_arr->capacity * 2, 1024U);
                uint32_t *values = realloc(hash_arr->values,
                                           capacity * sizeof(*values));
                if (values == NULL) {
                        diag_set(OutOfMemory, capacity * sizeof(*values),
                                 "malloc", "tuple hash array");
                        return -1;
                }
                hash_arr->capacity = capacity;
                hash_arr->values = values;
        }
        hash_arr->values[hash_arr->count++] = hash;
        return 0;
}

int
tuple_bloom_builder_add(struct tuple_bloom_builder *builder,
                        struct tuple *tuple, struct key_def *key_def,
                        int multikey_idx)
{
        assert(builder->part_count == key_def->part_count);
        assert(!key_def->is_multikey || multikey_idx != MULTIKEY_NONE);

        uint32_t h = HASH_SEED;
        uint32_t carry = 0;
        uint32_t total_size = 0;

        for (uint32_t i = 0; i < key_def->part_count; i++) {
                total_size += tuple_hash_key_part(&h, &carry, tuple,
                                                  &key_def->parts[i],
                                                  multikey_idx);
                uint32_t hash = PMurHash32_Result(h, carry, total_size);
                if (tuple_hash_array_add(&builder->parts[i], hash) != 0)
                        return -1;
        }
        return 0;
}

int
tuple_bloom_builder_add_key(struct tuple_bloom_builder *builder,
                            const char *key, uint32_t part_count,
                            struct key_def *key_def)
{
        (void)part_count;
        assert(part_count >= key_def->part_count);
        assert(builder->part_count == key_def->part_count);

        uint32_t h = HASH_SEED;
        uint32_t carry = 0;
        uint32_t total_size = 0;

        for (uint32_t i = 0; i < key_def->part_count; i++) {
                total_size += tuple_hash_field(&h, &carry, &key,
                                               key_def->parts[i].type,
                                               key_def->parts[i].coll);
                uint32_t hash = PMurHash32_Result(h, carry, total_size);
                if (tuple_hash_array_add(&builder->parts[i], hash) != 0)
                        return -1;
        }
        return 0;
}

struct tuple_bloom *
tuple_bloom_new(struct tuple_bloom_builder *builder, double fpr)
{
        uint32_t part_count = builder->part_count;
        size_t size = sizeof(struct tuple_bloom) +
                        part_count * sizeof(struct bloom);
        struct tuple_bloom *bloom = malloc(size);
        if (bloom == NULL) {
                diag_set(OutOfMemory, size, "malloc", "tuple bloom");
                return NULL;
        }

        bloom->is_legacy = false;
        bloom->part_count = 0;

        for (uint32_t i = 0; i < part_count; i++) {
                struct tuple_hash_array *hash_arr = &builder->parts[i];
                uint32_t count = hash_arr->count;
                /*
                 * When we check if a key is stored in a bloom
                 * filter, we check all its sub keys as well,
                 * which reduces the resulting false positive
                 * rate. Take this into account and adjust fpr
                 * accordingly when constructing a bloom filter
                 * for keys of a higher rank.
                 */
                double part_fpr = fpr;
                for (uint32_t j = 0; j < i; j++)
                        part_fpr /= bloom_fpr(&bloom->parts[j], count);
                part_fpr = MIN(part_fpr, 0.5);
                if (bloom_create(&bloom->parts[i], count, part_fpr) != 0) {
                        diag_set(OutOfMemory, 0, "bloom_create",
                                 "tuple bloom part");
                        tuple_bloom_delete(bloom);
                        return NULL;
                }
                bloom->part_count++;
                for (uint32_t k = 0; k < count; k++)
                        bloom_add(&bloom->parts[i], hash_arr->values[k]);
        }
        return bloom;
}

void
tuple_bloom_delete(struct tuple_bloom *bloom)
{
        for (uint32_t i = 0; i < bloom->part_count; i++)
                bloom_destroy(&bloom->parts[i]);
        free(bloom);
}

bool
tuple_bloom_maybe_has(const struct tuple_bloom *bloom, struct tuple *tuple,
                      struct key_def *key_def, int multikey_idx)
{
        assert(!key_def->is_multikey || multikey_idx != MULTIKEY_NONE);

        if (bloom->is_legacy) {
                return bloom_maybe_has(&bloom->parts[0],
                                       tuple_hash(tuple, key_def));
        }

        assert(bloom->part_count == key_def->part_count);

        uint32_t h = HASH_SEED;
        uint32_t carry = 0;
        uint32_t total_size = 0;

        for (uint32_t i = 0; i < key_def->part_count; i++) {
                total_size += tuple_hash_key_part(&h, &carry, tuple,
                                                  &key_def->parts[i],
                                                  multikey_idx);
                uint32_t hash = PMurHash32_Result(h, carry, total_size);
                if (!bloom_maybe_has(&bloom->parts[i], hash))
                        return false;
        }
        return true;
}

bool
tuple_bloom_maybe_has_key(const struct tuple_bloom *bloom,
                          const char *key, uint32_t part_count,
                          struct key_def *key_def)
{
        if (bloom->is_legacy) {
                if (part_count < key_def->part_count)
                        return true;
                return bloom_maybe_has(&bloom->parts[0],
                                       key_hash(key, key_def));
        }

        assert(part_count <= key_def->part_count);
        assert(bloom->part_count == key_def->part_count);

        uint32_t h = HASH_SEED;
        uint32_t carry = 0;
        uint32_t total_size = 0;

        for (uint32_t i = 0; i < part_count; i++) {
                total_size += tuple_hash_field(&h, &carry, &key,
                                               key_def->parts[i].type,
                                               key_def->parts[i].coll);
                uint32_t hash = PMurHash32_Result(h, carry, total_size);
                if (!bloom_maybe_has(&bloom->parts[i], hash))
                        return false;
        }
        return true;
}

static size_t
tuple_bloom_sizeof_part(const struct bloom *part)
{
        size_t size = 0;
        size += mp_sizeof_array(3);
        size += mp_sizeof_uint(part->table_size);
        size += mp_sizeof_uint(part->hash_count);
        size += mp_sizeof_bin(bloom_store_size(part));
        return size;
}

static char *
tuple_bloom_encode_part(const struct bloom *part, char *buf)
{
        buf = mp_encode_array(buf, 3);
        buf = mp_encode_uint(buf, part->table_size);
        buf = mp_encode_uint(buf, part->hash_count);
        buf = mp_encode_binl(buf, bloom_store_size(part));
        buf = bloom_store(part, buf);
        return buf;
}

static int
tuple_bloom_decode_part(struct bloom *part, const char **data)
{
        memset(part, 0, sizeof(*part));
        if (mp_decode_array(data) != 3)
                unreachable();
        part->table_size = mp_decode_uint(data);
        part->hash_count = mp_decode_uint(data);
        size_t store_size = mp_decode_binl(data);
        assert(store_size == bloom_store_size(part));
        if (bloom_load_table(part, *data) != 0) {
                diag_set(OutOfMemory, store_size, "bloom_load_table",
                         "tuple bloom part");
                return -1;
        }
        *data += store_size;
        return 0;
}

size_t
tuple_bloom_size(const struct tuple_bloom *bloom)
{
        size_t size = 0;
        size += mp_sizeof_array(bloom->part_count);
        for (uint32_t i = 0; i < bloom->part_count; i++)
                size += tuple_bloom_sizeof_part(&bloom->parts[i]);
        return size;
}

char *
tuple_bloom_encode(const struct tuple_bloom *bloom, char *buf)
{
        buf = mp_encode_array(buf, bloom->part_count);
        for (uint32_t i = 0; i < bloom->part_count; i++)
                buf = tuple_bloom_encode_part(&bloom->parts[i], buf);
        return buf;
}

struct tuple_bloom *
tuple_bloom_decode(const char **data)
{
        uint32_t part_count = mp_decode_array(data);
        struct tuple_bloom *bloom = malloc(sizeof(*bloom) +
                        part_count * sizeof(*bloom->parts));
        if (bloom == NULL) {
                diag_set(OutOfMemory, sizeof(*bloom) +
                         part_count * sizeof(*bloom->parts),
                         "malloc", "tuple bloom");
                return NULL;
        }

        bloom->is_legacy = false;
        bloom->part_count = 0;

        for (uint32_t i = 0; i < part_count; i++) {
                if (tuple_bloom_decode_part(&bloom->parts[i], data) != 0) {
                        tuple_bloom_delete(bloom);
                        return NULL;
                }
                bloom->part_count++;
        }
        return bloom;
}

struct tuple_bloom *
tuple_bloom_decode_legacy(const char **data)
{
        struct tuple_bloom *bloom = malloc(sizeof(*bloom) +
                                           sizeof(*bloom->parts));
        if (bloom == NULL) {
                diag_set(OutOfMemory, sizeof(*bloom) + sizeof(*bloom->parts),
                         "malloc", "tuple bloom");
                return NULL;
        }

        bloom->is_legacy = true;
        bloom->part_count = 1;

        if (mp_decode_array(data) != 4)
                unreachable();
        if (mp_decode_uint(data) != 0) /* version */
                unreachable();

        bloom->parts[0].table_size = mp_decode_uint(data);
        bloom->parts[0].hash_count = mp_decode_uint(data);

        size_t store_size = mp_decode_binl(data);
        assert(store_size == bloom_store_size(&bloom->parts[0]));
        if (bloom_load_table(&bloom->parts[0], *data) != 0) {
                diag_set(OutOfMemory, store_size, "bloom_load_table",
                         "tuple bloom part");
                free(bloom);
                return NULL;
        }
        *data += store_size;
        return bloom;
}

1	/*
2	* Copyright 2010-2018, 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 "tuple_bloom.h"
32
33	#include <assert.h>
34	#include <stdbool.h>
35	#include <stddef.h>
36	#include <stdint.h>
37	#include <stdlib.h>
38	#include <string.h>
39	#include <msgpuck.h>
40	#include "diag.h"
41	#include "errcode.h"
42	#include "key_def.h"
43	#include "tuple.h"
44	#include "salad/bloom.h"
45	#include "trivia/util.h"
46	#include <PMurHash.h>
47
48	enum { HASH_SEED = 13U };
49
50	struct tuple_bloom_builder *
51	tuple_bloom_builder_new(uint32_t part_count)	2,871✔
52	{
53	size_t size = sizeof(struct tuple_bloom_builder) +	2,871✔
54	part_count * sizeof(struct tuple_hash_array);	2,871✔
55	struct tuple_bloom_builder *builder = malloc(size);	2,871✔
56	if (builder == NULL) {	2,871!
57	diag_set(OutOfMemory, size, "malloc", "tuple bloom builder");	×
58	return NULL;	×
59	}
60	memset(builder, 0, size);	2,871✔
61	builder->part_count = part_count;	2,871✔
62	return builder;	2,871✔
63	}
64
65	void
66	tuple_bloom_builder_delete(struct tuple_bloom_builder *builder)	2,874✔
67	{
68	for (uint32_t i = 0; i < builder->part_count; i++)	6,455✔
69	free(builder->parts[i].values);	3,581✔
70	free(builder);	2,874✔
71	}	2,874✔
72
73	/**
74	* Add a tuple hash to a hash array unless it's already there.
75	* Reallocate the array if necessary.
76	*/
77	static int
78	tuple_hash_array_add(struct tuple_hash_array *hash_arr, uint32_t hash)	5,909,670✔
79	{
80	if (hash_arr->count > 0 &&	5,909,670!
81	hash_arr->values[hash_arr->count - 1] == hash) {	5,915,640✔
82	/*
83	* This part is already in the bloom, proceed
84	* to the next one. Note, this check only works
85	* if tuples are added in the order defined by
86	* the key definition.
87	*/
88	return 0;	2,335,250✔
89	}
90	if (hash_arr->count >= hash_arr->capacity) {	3,574,420✔
91	uint32_t capacity = MAX(hash_arr->capacity * 2, 1024U);	4,481✔
92	uint32_t *values = realloc(hash_arr->values,	4,481✔
93	capacity * sizeof(*values));
94	if (values == NULL) {	4,481!
95	diag_set(OutOfMemory, capacity * sizeof(*values),	×
96	"malloc", "tuple hash array");
97	return -1;	×
98	}
99	hash_arr->capacity = capacity;	4,481✔
100	hash_arr->values = values;	4,481✔
101	}
102	hash_arr->values[hash_arr->count++] = hash;	3,574,420✔
103	return 0;	3,574,420✔
104	}
105
106	int
107	tuple_bloom_builder_add(struct tuple_bloom_builder *builder,	1,393,150✔
108	struct tuple tuple, struct key_def key_def,
109	int multikey_idx)
110	{
111	assert(builder->part_count == key_def->part_count);	1,393,150!
112	assert(!key_def->is_multikey \|\| multikey_idx != MULTIKEY_NONE);	1,393,150!
113
114	uint32_t h = HASH_SEED;	1,393,150✔
115	uint32_t carry = 0;	1,393,150✔
116	uint32_t total_size = 0;	1,393,150✔
117
118	for (uint32_t i = 0; i < key_def->part_count; i++) {	3,506,590✔
119	total_size += tuple_hash_key_part(&h, &carry, tuple,	2,113,440!
120	&key_def->parts[i],
121	multikey_idx);
122	uint32_t hash = PMurHash32_Result(h, carry, total_size);	2,113,440!
123	if (tuple_hash_array_add(&builder->parts[i], hash) != 0)	2,113,450!
124	return -1;	1,393,150✔
125	}
126	return 0;	1,393,150✔
127	}
128
129	int
130	tuple_bloom_builder_add_key(struct tuple_bloom_builder *builder,	1,971,550✔
131	const char *key, uint32_t part_count,
132	struct key_def *key_def)
133	{
134	(void)part_count;
135	assert(part_count >= key_def->part_count);	1,971,550!
136	assert(builder->part_count == key_def->part_count);	1,971,550!
137
138	uint32_t h = HASH_SEED;	1,971,550✔
139	uint32_t carry = 0;	1,971,550✔
140	uint32_t total_size = 0;	1,971,550✔
141
142	for (uint32_t i = 0; i < key_def->part_count; i++) {	5,781,770✔
143	total_size += tuple_hash_field(&h, &carry, &key,	3,808,980!
144	key_def->parts[i].type,
145	key_def->parts[i].coll);
146	uint32_t hash = PMurHash32_Result(h, carry, total_size);	3,811,070!
147	if (tuple_hash_array_add(&builder->parts[i], hash) != 0)	3,811,340!
148	return -1;	1,972,790✔
149	}
150	return 0;	1,972,790✔
151	}
152
153	struct tuple_bloom *
154	tuple_bloom_new(struct tuple_bloom_builder *builder, double fpr)	2,754✔
155	{
156	uint32_t part_count = builder->part_count;	2,754✔
157	size_t size = sizeof(struct tuple_bloom) +	2,754✔
158	part_count * sizeof(struct bloom);	2,754✔
159	struct tuple_bloom *bloom = malloc(size);	2,754✔
160	if (bloom == NULL) {	2,754!
161	diag_set(OutOfMemory, size, "malloc", "tuple bloom");	×
162	return NULL;	×
163	}
164
165	bloom->is_legacy = false;	2,754✔
166	bloom->part_count = 0;	2,754✔
167
168	for (uint32_t i = 0; i < part_count; i++) {	6,048✔
169	struct tuple_hash_array *hash_arr = &builder->parts[i];	3,445✔
170	uint32_t count = hash_arr->count;	3,445✔
171	/*
172	* When we check if a key is stored in a bloom
173	* filter, we check all its sub keys as well,
174	* which reduces the resulting false positive
175	* rate. Take this into account and adjust fpr
176	* accordingly when constructing a bloom filter
177	* for keys of a higher rank.
178	*/
179	double part_fpr = fpr;	3,445✔
180	for (uint32_t j = 0; j < i; j++)	11,579✔
181	part_fpr /= bloom_fpr(&bloom->parts[j], count);	8,134✔
182	part_fpr = MIN(part_fpr, 0.5);	3,445✔
183	if (bloom_create(&bloom->parts[i], count, part_fpr) != 0) {	3,445!
UNCOV 184	diag_set(OutOfMemory, 0, "bloom_create",	×
185	"tuple bloom part");
186	tuple_bloom_delete(bloom);	×
187	return NULL;	×
188	}
189	bloom->part_count++;	3,444✔
190	for (uint32_t k = 0; k < count; k++)	3,507,010✔
191	bloom_add(&bloom->parts[i], hash_arr->values[k]);	3,503,720✔
192	}
193	return bloom;	2,603✔
194	}
195
196	void
197	tuple_bloom_delete(struct tuple_bloom *bloom)	2,244✔
198	{
199	for (uint32_t i = 0; i < bloom->part_count; i++)	4,973✔
200	bloom_destroy(&bloom->parts[i]);	2,729✔
201	free(bloom);	2,244✔
202	}	2,244✔
203
204	bool
205	tuple_bloom_maybe_has(const struct tuple_bloom bloom, struct tuple tuple,	193,395✔
206	struct key_def *key_def, int multikey_idx)
207	{
208	assert(!key_def->is_multikey \|\| multikey_idx != MULTIKEY_NONE);	193,395!
209
210	if (bloom->is_legacy) {	193,395!
211	return bloom_maybe_has(&bloom->parts[0],	193,395!
212	tuple_hash(tuple, key_def));
213	}
214
215	assert(bloom->part_count == key_def->part_count);	193,395!
216
217	uint32_t h = HASH_SEED;	193,395✔
218	uint32_t carry = 0;	193,395✔
219	uint32_t total_size = 0;	193,395✔
220
221	for (uint32_t i = 0; i < key_def->part_count; i++) {	201,483✔
222	total_size += tuple_hash_key_part(&h, &carry, tuple,	193,395!
223	&key_def->parts[i],
224	multikey_idx);
225	uint32_t hash = PMurHash32_Result(h, carry, total_size);	193,395!
226	if (!bloom_maybe_has(&bloom->parts[i], hash))	193,395!
227	return false;	185,307✔
228	}
229	return true;	8,088✔
230	}
231
232	bool
233	tuple_bloom_maybe_has_key(const struct tuple_bloom *bloom,	423,121✔
234	const char *key, uint32_t part_count,
235	struct key_def *key_def)
236	{
237	if (bloom->is_legacy) {	423,121!
238	if (part_count < key_def->part_count)	×
239	return true;	423,121✔
240	return bloom_maybe_has(&bloom->parts[0],	×
241	key_hash(key, key_def));
242	}
243
244	assert(part_count <= key_def->part_count);	423,121!
245	assert(bloom->part_count == key_def->part_count);	423,121!
246
247	uint32_t h = HASH_SEED;	423,121✔
248	uint32_t carry = 0;	423,121✔
249	uint32_t total_size = 0;	423,121✔
250
251	for (uint32_t i = 0; i < part_count; i++) {	774,659✔
252	total_size += tuple_hash_field(&h, &carry, &key,	438,257!
253	key_def->parts[i].type,
254	key_def->parts[i].coll);
255	uint32_t hash = PMurHash32_Result(h, carry, total_size);	438,257!
256	if (!bloom_maybe_has(&bloom->parts[i], hash))	438,257!
257	return false;	86,719✔
258	}
259	return true;	336,402✔
260	}
261
262	static size_t
263	tuple_bloom_sizeof_part(const struct bloom *part)	9,880✔
264	{
265	size_t size = 0;	9,880✔
266	size += mp_sizeof_array(3);	9,880✔
267	size += mp_sizeof_uint(part->table_size);	9,880✔
268	size += mp_sizeof_uint(part->hash_count);	9,881✔
269	size += mp_sizeof_bin(bloom_store_size(part));	9,881✔
270	return size;	9,880✔
271	}
272
273	static char *
274	tuple_bloom_encode_part(const struct bloom part, char buf)	3,445✔
275	{
276	buf = mp_encode_array(buf, 3);	3,445✔
277	buf = mp_encode_uint(buf, part->table_size);	3,445✔
278	buf = mp_encode_uint(buf, part->hash_count);	3,445✔
279	buf = mp_encode_binl(buf, bloom_store_size(part));	3,445✔
280	buf = bloom_store(part, buf);	3,445✔
281	return buf;	3,445✔
282	}
283
284	static int
285	tuple_bloom_decode_part(struct bloom part, const char *data)	294✔
286	{
287	memset(part, 0, sizeof(*part));	294✔
288	if (mp_decode_array(data) != 3)	294!
289	unreachable();	×
290	part->table_size = mp_decode_uint(data);	294✔
291	part->hash_count = mp_decode_uint(data);	294✔
292	size_t store_size = mp_decode_binl(data);	294✔
293	assert(store_size == bloom_store_size(part));	294!
294	if (bloom_load_table(part, *data) != 0) {	294!
295	diag_set(OutOfMemory, store_size, "bloom_load_table",	×
296	"tuple bloom part");
297	return -1;	×
298	}
299	*data += store_size;	294✔
300	return 0;	294✔
301	}
302
303	size_t
304	tuple_bloom_size(const struct tuple_bloom *bloom)	7,955✔
305	{
306	size_t size = 0;	7,955✔
307	size += mp_sizeof_array(bloom->part_count);	7,955✔
308	for (uint32_t i = 0; i < bloom->part_count; i++)	17,836✔
309	size += tuple_bloom_sizeof_part(&bloom->parts[i]);	9,881✔
310	return size;	7,955✔
311	}
312
313	char *
314	tuple_bloom_encode(const struct tuple_bloom bloom, char buf)	2,756✔
315	{
316	buf = mp_encode_array(buf, bloom->part_count);	2,756✔
317	for (uint32_t i = 0; i < bloom->part_count; i++)	6,201✔
318	buf = tuple_bloom_encode_part(&bloom->parts[i], buf);	3,445✔
319	return buf;	2,756✔
320	}
321
322	struct tuple_bloom *
323	tuple_bloom_decode(const char **data)	232✔
324	{
325	uint32_t part_count = mp_decode_array(data);	232✔
326	struct tuple_bloom bloom = malloc(sizeof(bloom) +	232✔
327	part_count * sizeof(*bloom->parts));	232✔
328	if (bloom == NULL) {	232!
329	diag_set(OutOfMemory, sizeof(*bloom) +	×
330	part_count * sizeof(*bloom->parts),
331	"malloc", "tuple bloom");
332	return NULL;	×
333	}
334
335	bloom->is_legacy = false;	232✔
336	bloom->part_count = 0;	232✔
337
338	for (uint32_t i = 0; i < part_count; i++) {	526✔
339	if (tuple_bloom_decode_part(&bloom->parts[i], data) != 0) {	294!
340	tuple_bloom_delete(bloom);	×
341	return NULL;	×
342	}
343	bloom->part_count++;	294✔
344	}
345	return bloom;	232✔
346	}
347
348	struct tuple_bloom *
349	tuple_bloom_decode_legacy(const char **data)	×
350	{
351	struct tuple_bloom bloom = malloc(sizeof(bloom) +	×
352	sizeof(*bloom->parts));
353	if (bloom == NULL) {	×
354	diag_set(OutOfMemory, sizeof(bloom) + sizeof(bloom->parts),	×
355	"malloc", "tuple bloom");
356	return NULL;	×
357	}
358
359	bloom->is_legacy = true;	×
360	bloom->part_count = 1;	×
361
362	if (mp_decode_array(data) != 4)	×
363	unreachable();	×
364	if (mp_decode_uint(data) != 0) /* version */	×
365	unreachable();	×
366
367	bloom->parts[0].table_size = mp_decode_uint(data);	×
368	bloom->parts[0].hash_count = mp_decode_uint(data);	×
369
370	size_t store_size = mp_decode_binl(data);	×
371	assert(store_size == bloom_store_size(&bloom->parts[0]));	×
372	if (bloom_load_table(&bloom->parts[0], *data) != 0) {	×
373	diag_set(OutOfMemory, store_size, "bloom_load_table",	×
374	"tuple bloom part");
375	free(bloom);	×
376	return NULL;	×
377	}
378	*data += store_size;	×
379	return bloom;	×
380	}

tarantool / tarantool / 12275347388

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