1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
|
/*
Copyright (c) 2021 Blosc Development Team <blosc@blosc.org>
https://blosc.org
License: BSD 3-Clause (see LICENSE.txt)
See LICENSE.txt for details about copyright and rights to use.
*/
#include <stdio.h>
#include "test_common.h"
#define CHUNKSIZE (200 * 1000)
#define NTHREADS (2)
/* Global vars */
int tests_run = 0;
typedef struct {
int nchunks;
int64_t start;
int64_t stop;
char* urlpath;
bool contiguous;
bool shorter_last_chunk;
} test_data;
test_data tdata;
typedef struct {
int nchunks;
int64_t start;
int64_t stop;
bool shorter_last_chunk;
} test_ndata;
test_ndata tndata[] = {
{10, 0, 10 * CHUNKSIZE, false}, //whole schunk
{5, 3, 200, false}, //piece of 1 block
{33, 5, 679, false}, // blocks of same chunk
{12, 129 * 100, 134 * 100 * 3, false}, // blocks of different chunks
{3, 200 * 100, CHUNKSIZE * 3, false}, // 2 chunks
{3, 200 * 100 + 17, CHUNKSIZE * 3 + 23, true}, // last chunk shorter
};
typedef struct {
bool contiguous;
char *urlpath;
} test_storage;
test_storage tstorage[] = {
{false, NULL}, // memory - schunk
{true, NULL}, // memory - cframe
{true, "test_set_slice_buffer.b2frame"}, // disk - cframe
{false, "test_set_slice_buffer.b2frame"}, // disk - sframe
};
static char* test_set_slice_buffer(void) {
static int32_t data[CHUNKSIZE];
int32_t *data_;
int32_t isize = CHUNKSIZE * sizeof(int32_t);
int rc;
blosc2_cparams cparams = BLOSC2_CPARAMS_DEFAULTS;
blosc2_dparams dparams = BLOSC2_DPARAMS_DEFAULTS;
blosc2_schunk* schunk;
/* Initialize the Blosc compressor */
blosc2_init();
/* Create a super-chunk container */
blosc2_remove_urlpath(tdata.urlpath);
cparams.typesize = sizeof(int32_t);
cparams.clevel = 5;
cparams.nthreads = NTHREADS;
dparams.nthreads = NTHREADS;
blosc2_storage storage = {.cparams=&cparams, .dparams=&dparams,
.urlpath=tdata.urlpath, .contiguous=tdata.contiguous};
schunk = blosc2_schunk_new(&storage);
// Feed it with data
if (!tdata.shorter_last_chunk) {
for (int nchunk = 0; nchunk < tdata.nchunks; nchunk++) {
for (int i = 0; i < CHUNKSIZE; i++) {
data[i] = i + nchunk * CHUNKSIZE;
}
int64_t nchunks_ = blosc2_schunk_append_buffer(schunk, data, isize);
mu_assert("ERROR: bad append in frame", nchunks_ > 0);
}
}
else {
data_ = malloc(sizeof(int32_t) * tdata.stop);
for (int i = 0; i < tdata.stop; i++) {
data_[i] = i;
}
for (int nchunk = 0; nchunk < tdata.nchunks; nchunk++) {
int64_t nchunks_ = blosc2_schunk_append_buffer(schunk, data_ + nchunk * CHUNKSIZE, isize);
mu_assert("ERROR: bad append in frame", nchunks_ > 0);
}
int64_t nchunks_ = blosc2_schunk_append_buffer(schunk, data_ + tdata.nchunks * CHUNKSIZE,
(tdata.stop % CHUNKSIZE) * sizeof(int32_t));
mu_assert("ERROR: bad append in frame", nchunks_ > 0);
free(data_);
}
// Set slice
int32_t *buffer = malloc((tdata.stop - tdata.start) * schunk->typesize);
for (int i = 0; i < (tdata.stop - tdata.start); ++i) {
buffer[i] = i + tdata.nchunks * CHUNKSIZE;
}
rc = blosc2_schunk_set_slice_buffer(schunk, tdata.start, tdata.stop, buffer);
mu_assert("ERROR: cannot set slice correctly.", rc >= 0);
int32_t *res = malloc((tdata.stop - tdata.start) * schunk->typesize);
// Check that the data has been updated correctly
rc = blosc2_schunk_get_slice_buffer(schunk, tdata.start, tdata.stop, res);
mu_assert("ERROR: cannot get slice correctly.", rc >= 0);
for (int64_t i = 0; i < (tdata.stop - tdata.start); ++i) {
mu_assert("ERROR: bad roundtrip",buffer[i] == res[i]);
}
/* Free resources */
blosc2_schunk_free(schunk);
blosc2_remove_urlpath(tdata.urlpath);
/* Destroy the Blosc environment */
blosc2_destroy();
free(buffer);
free(res);
return EXIT_SUCCESS;
}
static char *all_tests(void) {
for (int i = 0; i < (int) ARRAY_SIZE(tstorage); ++i) {
for (int j = 0; j < (int) ARRAY_SIZE(tndata); ++j) {
tdata.contiguous = tstorage[i].contiguous;
tdata.urlpath = tstorage[i].urlpath;
tdata.nchunks = tndata[j].nchunks;
tdata.start = tndata[j].start;
tdata.stop = tndata[j].stop;
tdata.shorter_last_chunk = tndata[j].shorter_last_chunk;
mu_run_test(test_set_slice_buffer);
}
}
return EXIT_SUCCESS;
}
int main(void) {
char *result;
install_blosc_callback_test(); /* optionally install callback test */
blosc2_init();
/* Run all the suite */
result = all_tests();
if (result != EXIT_SUCCESS) {
printf(" (%s)\n", result);
}
else {
printf(" ALL TESTS PASSED");
}
printf("\tTests run: %d\n", tests_run);
blosc2_destroy();
return result != EXIT_SUCCESS;
}
|
