Skip to content

Commit 4cd7813

Browse files
author
David Saada
committed
Improve the efficiency of BufferedBlockDevice
1 parent 0404701 commit 4cd7813

File tree

3 files changed

+246
-149
lines changed

3 files changed

+246
-149
lines changed

‎features/storage/TESTS/blockdevice/buffered_block_device/main.cpp

Lines changed: 136 additions & 88 deletions
Original file line numberDiff line numberDiff line change
@@ -24,105 +24,153 @@
2424
using namespace utest::v1;
2525

2626
static const bd_size_t heap_erase_size = 512;
27-
static const bd_size_t heap_prog_size = heap_erase_size;
28-
static const bd_size_t heap_read_size = 256;
2927
static const bd_size_t num_blocks = 4;
3028

29+
typedef struct {
30+
bd_size_t read_size;
31+
bd_size_t prog_size;
32+
} sizes_t;
33+
34+
static const int num_tests = 4;
35+
36+
sizes_t sizes[num_tests] = {
37+
{1, 1},
38+
{1, 128},
39+
{4, 256},
40+
{256, 512}
41+
};
42+
3143
void functionality_test()
3244
{
33-
uint8_t *dummy = new (std::nothrow) uint8_t[num_blocks * heap_erase_size + heap_prog_size];
34-
TEST_SKIP_UNLESS_MESSAGE(dummy, "Not enough memory for test");
35-
delete[] dummy;
45+
for (int i = 0; i < num_tests; i++) {
46+
bd_size_t heap_read_size = sizes[i].read_size;
47+
bd_size_t heap_prog_size = sizes[i].prog_size;
3648

37-
HeapBlockDevice heap_bd(num_blocks * heap_erase_size, heap_read_size, heap_prog_size, heap_erase_size);
38-
BufferedBlockDevice bd(&heap_bd);
49+
printf("Testing read size of %lld, prog size of %lld\n", heap_read_size, heap_prog_size);
3950

40-
int err = bd.init();
41-
TEST_ASSERT_EQUAL(0, err);
51+
uint8_t *dummy = new (std::nothrow) uint8_t[num_blocks * heap_erase_size + heap_prog_size + heap_read_size];
52+
TEST_SKIP_UNLESS_MESSAGE(dummy, "Not enough memory for test");
53+
delete[] dummy;
4254

43-
uint8_t *read_buf, *write_buf;
44-
read_buf = new (std::nothrow) uint8_t[heap_prog_size];
45-
TEST_SKIP_UNLESS_MESSAGE(read_buf, "Not enough memory for test");
46-
write_buf = new (std::nothrow) uint8_t[heap_prog_size];
47-
TEST_SKIP_UNLESS_MESSAGE(write_buf, "Not enough memory for test");
55+
uint8_t *read_buf, *write_buf;
56+
read_buf = new (std::nothrow) uint8_t[heap_erase_size];
57+
TEST_SKIP_UNLESS_MESSAGE(read_buf, "Not enough memory for test");
58+
write_buf = new (std::nothrow) uint8_t[heap_erase_size];
59+
TEST_SKIP_UNLESS_MESSAGE(write_buf, "Not enough memory for test");
4860

49-
TEST_ASSERT_EQUAL(1, bd.get_read_size());
50-
TEST_ASSERT_EQUAL(1, bd.get_program_size());
51-
TEST_ASSERT_EQUAL(heap_erase_size, bd.get_erase_size());
61+
HeapBlockDevice *heap_bd = new HeapBlockDevice(num_blocks * heap_erase_size, heap_read_size, heap_prog_size, heap_erase_size);
62+
BufferedBlockDevice *bd = new BufferedBlockDevice(heap_bd);
5263

53-
for (bd_size_t i = 0; i < num_blocks; i++) {
54-
memset(write_buf, i, heap_prog_size);
55-
err = heap_bd.program(write_buf, i * heap_prog_size, heap_prog_size);
64+
int err = bd->init();
5665
TEST_ASSERT_EQUAL(0, err);
57-
}
5866

59-
err = bd.read(read_buf, heap_prog_size + heap_prog_size / 2, 1);
60-
TEST_ASSERT_EQUAL(0, err);
61-
TEST_ASSERT_EQUAL(1, read_buf[0]);
62-
63-
err = bd.read(read_buf, 2 * heap_prog_size + heap_prog_size / 2, 4);
64-
TEST_ASSERT_EQUAL(0, err);
65-
memset(write_buf, 2, 4);
66-
TEST_ASSERT_EQUAL_UINT8_ARRAY(write_buf, read_buf, 4);
67-
68-
memset(write_buf, 1, heap_prog_size);
69-
memset(write_buf + 64, 0x5A, 8);
70-
memset(write_buf + 72, 0xA5, 8);
71-
err = bd.program(write_buf + 64, heap_prog_size + 64, 8);
72-
TEST_ASSERT_EQUAL(0, err);
73-
err = bd.program(write_buf + 72, heap_prog_size + 72, 8);
74-
TEST_ASSERT_EQUAL(0, err);
75-
err = bd.read(read_buf, heap_prog_size, heap_prog_size);
76-
TEST_ASSERT_EQUAL(0, err);
77-
TEST_ASSERT_EQUAL_UINT8_ARRAY(write_buf, read_buf, heap_prog_size);
78-
memset(write_buf, 1, heap_prog_size);
79-
// Underlying BD should not be updated before sync
80-
err = heap_bd.read(read_buf, heap_prog_size, heap_prog_size);
81-
TEST_ASSERT_EQUAL(0, err);
82-
TEST_ASSERT_EQUAL_UINT8_ARRAY(write_buf, read_buf, heap_prog_size);
83-
err = bd.sync();
84-
TEST_ASSERT_EQUAL(0, err);
85-
memset(write_buf + 64, 0x5A, 8);
86-
memset(write_buf + 72, 0xA5, 8);
87-
// Should be updated now
88-
err = bd.read(read_buf, heap_prog_size, heap_prog_size);
89-
TEST_ASSERT_EQUAL(0, err);
90-
TEST_ASSERT_EQUAL_UINT8_ARRAY(write_buf, read_buf, heap_prog_size);
91-
err = heap_bd.read(read_buf, heap_prog_size, heap_prog_size);
92-
TEST_ASSERT_EQUAL(0, err);
93-
TEST_ASSERT_EQUAL_UINT8_ARRAY(write_buf, read_buf, heap_prog_size);
94-
95-
memset(write_buf, 0xAA, 16);
96-
memset(write_buf + 16, 0xBB, 16);
97-
err = bd.program(write_buf, 3 * heap_prog_size - 16, 32);
98-
TEST_ASSERT_EQUAL(0, err);
99-
// First block should sync, but second still shouldn't
100-
memset(write_buf, 2, heap_prog_size - 16);
101-
memset(write_buf + heap_prog_size - 16, 0xAA, 16);
102-
err = heap_bd.read(read_buf, 2 * heap_prog_size, heap_prog_size);
103-
TEST_ASSERT_EQUAL(0, err);
104-
TEST_ASSERT_EQUAL_UINT8_ARRAY(write_buf, read_buf, heap_prog_size);
105-
memset(write_buf, 3, heap_prog_size);
106-
err = heap_bd.read(read_buf, 3 * heap_prog_size, heap_prog_size);
107-
TEST_ASSERT_EQUAL(0, err);
108-
TEST_ASSERT_EQUAL_UINT8_ARRAY(write_buf, read_buf, heap_prog_size);
109-
memset(write_buf, 0xBB, 16);
110-
err = bd.read(read_buf, 3 * heap_prog_size, heap_prog_size);
111-
TEST_ASSERT_EQUAL(0, err);
112-
TEST_ASSERT_EQUAL_UINT8_ARRAY(write_buf, read_buf, heap_prog_size);
113-
// Moving to another block should automatically sync
114-
err = bd.read(read_buf, 15, 1);
115-
TEST_ASSERT_EQUAL(0, err);
116-
TEST_ASSERT_EQUAL(0, read_buf[0]);
117-
err = heap_bd.read(read_buf, 3 * heap_prog_size, heap_prog_size);
118-
TEST_ASSERT_EQUAL(0, err);
119-
TEST_ASSERT_EQUAL_UINT8_ARRAY(write_buf, read_buf, heap_prog_size);
120-
err = bd.read(read_buf, 3 * heap_prog_size, heap_prog_size);
121-
TEST_ASSERT_EQUAL(0, err);
122-
TEST_ASSERT_EQUAL_UINT8_ARRAY(write_buf, read_buf, heap_prog_size);
123-
124-
delete[] read_buf;
125-
delete[] write_buf;
67+
TEST_ASSERT_EQUAL(1, bd->get_read_size());
68+
TEST_ASSERT_EQUAL(1, bd->get_program_size());
69+
TEST_ASSERT_EQUAL(heap_erase_size, bd->get_erase_size());
70+
71+
for (bd_size_t i = 0; i < num_blocks; i++) {
72+
memset(write_buf, i, heap_erase_size);
73+
err = heap_bd->program(write_buf, i * heap_erase_size, heap_erase_size);
74+
TEST_ASSERT_EQUAL(0, err);
75+
}
76+
77+
err = bd->read(read_buf, heap_erase_size + heap_erase_size / 2, 1);
78+
TEST_ASSERT_EQUAL(0, err);
79+
TEST_ASSERT_EQUAL(1, read_buf[0]);
80+
81+
err = bd->read(read_buf, 2 * heap_erase_size + heap_erase_size / 2, 4);
82+
TEST_ASSERT_EQUAL(0, err);
83+
memset(write_buf, 2, 4);
84+
TEST_ASSERT_EQUAL_UINT8_ARRAY(write_buf, read_buf, 4);
85+
86+
memset(write_buf, 1, heap_erase_size);
87+
memset(write_buf + 64, 0x5A, 8);
88+
memset(write_buf + 72, 0xA5, 8);
89+
err = bd->program(write_buf + 64, heap_erase_size + 64, 8);
90+
TEST_ASSERT_EQUAL(0, err);
91+
err = bd->program(write_buf + 72, heap_erase_size + 72, 8);
92+
TEST_ASSERT_EQUAL(0, err);
93+
err = bd->read(read_buf, heap_erase_size, heap_erase_size);
94+
TEST_ASSERT_EQUAL(0, err);
95+
TEST_ASSERT_EQUAL_UINT8_ARRAY(write_buf, read_buf, heap_erase_size);
96+
memset(write_buf, 1, heap_erase_size);
97+
// Underlying BD should not be updated before sync
98+
err = heap_bd->read(read_buf, heap_erase_size, heap_erase_size);
99+
TEST_ASSERT_EQUAL(0, err);
100+
if (heap_prog_size > 1) {
101+
TEST_ASSERT_EQUAL_UINT8_ARRAY(write_buf, read_buf, heap_erase_size);
102+
}
103+
err = bd->sync();
104+
TEST_ASSERT_EQUAL(0, err);
105+
memset(write_buf + 64, 0x5A, 8);
106+
memset(write_buf + 72, 0xA5, 8);
107+
// Should be updated now
108+
err = bd->read(read_buf, heap_erase_size, heap_erase_size);
109+
TEST_ASSERT_EQUAL(0, err);
110+
TEST_ASSERT_EQUAL_UINT8_ARRAY(write_buf, read_buf, heap_erase_size);
111+
err = heap_bd->read(read_buf, heap_erase_size, heap_erase_size);
112+
TEST_ASSERT_EQUAL(0, err);
113+
TEST_ASSERT_EQUAL_UINT8_ARRAY(write_buf, read_buf, heap_erase_size);
114+
115+
memset(write_buf, 0xAA, 16);
116+
memset(write_buf + 16, 0xBB, 16);
117+
err = bd->program(write_buf, 3 * heap_erase_size - 16, 32);
118+
TEST_ASSERT_EQUAL(0, err);
119+
// First block should sync, but second still shouldn't
120+
memset(write_buf, 2, heap_erase_size - 16);
121+
memset(write_buf + heap_erase_size - 16, 0xAA, 16);
122+
err = heap_bd->read(read_buf, 2 * heap_erase_size, heap_erase_size);
123+
TEST_ASSERT_EQUAL(0, err);
124+
TEST_ASSERT_EQUAL_UINT8_ARRAY(write_buf, read_buf, heap_erase_size);
125+
memset(write_buf, 3, heap_erase_size);
126+
err = heap_bd->read(read_buf, 3 * heap_erase_size, heap_erase_size);
127+
TEST_ASSERT_EQUAL(0, err);
128+
if (heap_prog_size > 1) {
129+
TEST_ASSERT_EQUAL_UINT8_ARRAY(write_buf, read_buf, heap_erase_size);
130+
}
131+
memset(write_buf, 0xBB, 16);
132+
err = bd->read(read_buf, 3 * heap_erase_size, heap_erase_size);
133+
TEST_ASSERT_EQUAL(0, err);
134+
TEST_ASSERT_EQUAL_UINT8_ARRAY(write_buf, read_buf, heap_erase_size);
135+
// Writing to another block should automatically sync
136+
err = bd->program(write_buf, 15, 1);
137+
TEST_ASSERT_EQUAL(0, err);
138+
err = heap_bd->read(read_buf, 3 * heap_erase_size, heap_erase_size);
139+
TEST_ASSERT_EQUAL(0, err);
140+
TEST_ASSERT_EQUAL_UINT8_ARRAY(write_buf, read_buf, heap_erase_size);
141+
err = bd->read(read_buf, 3 * heap_erase_size, heap_erase_size);
142+
TEST_ASSERT_EQUAL(0, err);
143+
TEST_ASSERT_EQUAL_UINT8_ARRAY(write_buf, read_buf, heap_erase_size);
144+
145+
// Unaligned reads and writes
146+
memset(write_buf, 2, 41);
147+
memset(write_buf + 41, 0x39, 21);
148+
err = bd->program(write_buf + 41, 2 * heap_erase_size + 41, 21);
149+
TEST_ASSERT_EQUAL(0, err);
150+
err = heap_bd->read(read_buf, 2 * heap_erase_size, heap_erase_size);
151+
TEST_ASSERT_EQUAL(0, err);
152+
if (heap_prog_size > 1) {
153+
TEST_ASSERT_EQUAL_UINT8_ARRAY(write_buf, read_buf, 41);
154+
TEST_ASSERT_EQUAL_UINT8_ARRAY(write_buf, read_buf + 41, 21);
155+
}
156+
err = bd->read(read_buf, 2 * heap_erase_size + 4, 41 + 21 - 4);
157+
TEST_ASSERT_EQUAL(0, err);
158+
TEST_ASSERT_EQUAL_UINT8_ARRAY(write_buf + 4, read_buf, 41 + 21 - 4);
159+
bd->sync();
160+
err = heap_bd->read(read_buf, 2 * heap_erase_size, heap_erase_size);
161+
TEST_ASSERT_EQUAL(0, err);
162+
TEST_ASSERT_EQUAL_UINT8_ARRAY(write_buf, read_buf, 41 + 21);
163+
err = bd->read(read_buf, 2 * heap_erase_size + 10, 41 + 21 - 10);
164+
TEST_ASSERT_EQUAL(0, err);
165+
TEST_ASSERT_EQUAL_UINT8_ARRAY(write_buf + 10, read_buf, 41 + 21 - 10);
166+
167+
bd->deinit();
168+
169+
delete[] read_buf;
170+
delete[] write_buf;
171+
delete bd;
172+
delete heap_bd;
173+
}
126174
}
127175

128176
// Test setup

0 commit comments

Comments
 (0)