Skip to content

Commit 282c9a5

Browse files
pre-commit-ci-lite[bot]pre-commit-ci-lite[bot]
authored
ci(pre-commit): Apply automatic fixes
1 parent 09fd160 commit 282c9a5

File tree

4 files changed

+276
-302
lines changed

4 files changed

+276
-302
lines changed

‎tests/performance/psramspeed/psramspeed.ino

+126-143
Original file line numberDiff line numberDiff line change
@@ -22,30 +22,39 @@
2222
#define START_SIZE 65536
2323

2424
// Max size to be copied. Must be bigger than 32 and it will be floored to the nearest power of 2
25-
#define MAX_TEST_SIZE 512 * 1024 // 512KB
25+
#define MAX_TEST_SIZE 512 * 1024 // 512KB
2626

2727
// Implementation macros
2828

2929
#if defined(UINTPTR_MAX) && UINTPTR_MAX > 0xFFFFFFFF
30-
# define MEM_UNIT uint64_t
31-
# define ALIGN_MASK 0x7
30+
#define MEM_UNIT uint64_t
31+
#define ALIGN_MASK 0x7
3232
#else
33-
# define MEM_UNIT uint32_t
34-
# define ALIGN_MASK 0x3
33+
#define MEM_UNIT uint32_t
34+
#define ALIGN_MASK 0x3
3535
#endif
3636

37-
#define COPY32 *d32 = *s32; d32++; s32++;
38-
#define COPY8 *d8 = *s8; d8++; s8++;
39-
#define SET32(x) *d32 = x; d32++;
40-
#define SET8(x) *d8 = x; d8++;
37+
#define COPY32 \
38+
*d32 = *s32; \
39+
d32++; \
40+
s32++;
41+
#define COPY8 \
42+
*d8 = *s8; \
43+
d8++; \
44+
s8++;
45+
#define SET32(x) \
46+
*d32 = x; \
47+
d32++;
48+
#define SET8(x) \
49+
*d8 = x; \
50+
d8++;
4151
#define REPEAT8(expr) expr expr expr expr expr expr expr expr
4252

4353
/* Functions */
4454

45-
static void *mock_memcpy(void *dst, const void *src, size_t len)
46-
{
47-
uint8_t *d8 = (uint8_t *) dst;
48-
const uint8_t *s8 = (uint8_t *) src;
55+
static void *mock_memcpy(void *dst, const void *src, size_t len) {
56+
uint8_t *d8 = (uint8_t *)dst;
57+
const uint8_t *s8 = (uint8_t *)src;
4958

5059
uintptr_t d_align = (uintptr_t)d8 & ALIGN_MASK;
5160
uintptr_t s_align = (uintptr_t)s8 & ALIGN_MASK;
@@ -54,213 +63,188 @@ static void *mock_memcpy(void *dst, const void *src, size_t len)
5463

5564
/* Byte copy for unaligned memories */
5665

57-
if (s_align != d_align)
58-
{
59-
while (len > 32)
60-
{
61-
REPEAT8(COPY8);
62-
REPEAT8(COPY8);
63-
REPEAT8(COPY8);
64-
REPEAT8(COPY8);
65-
len -= 32;
66-
}
67-
68-
while (len)
69-
{
70-
COPY8;
71-
len--;
72-
}
73-
74-
return dst;
66+
if (s_align != d_align) {
67+
while (len > 32) {
68+
REPEAT8(COPY8);
69+
REPEAT8(COPY8);
70+
REPEAT8(COPY8);
71+
REPEAT8(COPY8);
72+
len -= 32;
73+
}
74+
75+
while (len) {
76+
COPY8;
77+
len--;
7578
}
7679

80+
return dst;
81+
}
82+
7783
/* Make the memories aligned */
7884

79-
if (d_align)
80-
{
81-
d_align = ALIGN_MASK + 1 - d_align;
82-
while (d_align && len)
83-
{
84-
COPY8;
85-
d_align--;
86-
len--;
87-
}
85+
if (d_align) {
86+
d_align = ALIGN_MASK + 1 - d_align;
87+
while (d_align && len) {
88+
COPY8;
89+
d_align--;
90+
len--;
8891
}
92+
}
8993

9094
d32 = (uint32_t *)d8;
9195
s32 = (uint32_t *)s8;
92-
while (len > 32)
93-
{
94-
REPEAT8(COPY32);
95-
len -= 32;
96-
}
96+
while (len > 32) {
97+
REPEAT8(COPY32);
98+
len -= 32;
99+
}
97100

98-
while (len > 4)
99-
{
100-
COPY32;
101-
len -= 4;
102-
}
101+
while (len > 4) {
102+
COPY32;
103+
len -= 4;
104+
}
103105

104106
d8 = (uint8_t *)d32;
105107
s8 = (const uint8_t *)s32;
106-
while (len)
107-
{
108-
COPY8;
109-
len--;
110-
}
108+
while (len) {
109+
COPY8;
110+
len--;
111+
}
111112

112113
return dst;
113114
}
114115

115-
static void mock_memset(void *dst, uint8_t v, size_t len)
116-
{
116+
static void mock_memset(void *dst, uint8_t v, size_t len) {
117117
uint8_t *d8 = (uint8_t *)dst;
118-
uintptr_t d_align = (uintptr_t) d8 & ALIGN_MASK;
118+
uintptr_t d_align = (uintptr_t)d8 & ALIGN_MASK;
119119
uint32_t v32;
120120
uint32_t *d32;
121121

122122
/* Make the address aligned */
123123

124-
if (d_align)
125-
{
126-
d_align = ALIGN_MASK + 1 - d_align;
127-
while (d_align && len)
128-
{
129-
SET8(v);
130-
len--;
131-
d_align--;
132-
}
124+
if (d_align) {
125+
d_align = ALIGN_MASK + 1 - d_align;
126+
while (d_align && len) {
127+
SET8(v);
128+
len--;
129+
d_align--;
133130
}
131+
}
134132

135-
v32 = (uint32_t)v + ((uint32_t)v << 8)
136-
+ ((uint32_t)v << 16) + ((uint32_t)v << 24);
133+
v32 = (uint32_t)v + ((uint32_t)v << 8) + ((uint32_t)v << 16) + ((uint32_t)v << 24);
137134

138135
d32 = (uint32_t *)d8;
139136

140-
while (len > 32)
141-
{
142-
REPEAT8(SET32(v32));
143-
len -= 32;
144-
}
137+
while (len > 32) {
138+
REPEAT8(SET32(v32));
139+
len -= 32;
140+
}
145141

146-
while (len > 4)
147-
{
148-
SET32(v32);
149-
len -= 4;
150-
}
142+
while (len > 4) {
143+
SET32(v32);
144+
len -= 4;
145+
}
151146

152147
d8 = (uint8_t *)d32;
153-
while (len)
154-
{
155-
SET8(v);
156-
len--;
157-
}
148+
while (len) {
149+
SET8(v);
150+
len--;
151+
}
158152
}
159153

160-
static void print_rate(const char *name, uint64_t bytes, uint32_t cost_time)
161-
{
154+
static void print_rate(const char *name, uint64_t bytes, uint32_t cost_time) {
162155
uint32_t rate;
163-
if (cost_time == 0)
164-
{
165-
Serial.println("Error: Too little time taken, please increase N_COPIES");
166-
return;
167-
}
156+
if (cost_time == 0) {
157+
Serial.println("Error: Too little time taken, please increase N_COPIES");
158+
return;
159+
}
168160

169161
rate = bytes * 1000 / cost_time / 1024;
170162
Serial.printf("%s Rate = %" PRIu32 " KB/s Time: %" PRIu32 " ms\n", name, rate, cost_time);
171163
}
172164

173-
static void memcpy_speed_test(void *dest, const void *src, size_t size, uint32_t repeat_cnt)
174-
{
165+
static void memcpy_speed_test(void *dest, const void *src, size_t size, uint32_t repeat_cnt) {
175166
uint32_t start_time;
176167
uint32_t cost_time_system;
177168
uint32_t cost_time_mock;
178169
uint32_t cnt;
179170
uint32_t step;
180171
uint64_t total_size;
181172

182-
for (step = START_SIZE; step <= size; step <<= 1)
183-
{
184-
total_size = (uint64_t)step * (uint64_t)repeat_cnt;
173+
for (step = START_SIZE; step <= size; step <<= 1) {
174+
total_size = (uint64_t)step * (uint64_t)repeat_cnt;
185175

186-
Serial.printf("Memcpy %" PRIu32 " Bytes test\n", step);
176+
Serial.printf("Memcpy %" PRIu32 " Bytes test\n", step);
187177

188-
start_time = millis();
178+
start_time = millis();
189179

190-
for (cnt = 0; cnt < repeat_cnt; cnt++)
191-
{
192-
memcpy(dest, src, step);
193-
}
180+
for (cnt = 0; cnt < repeat_cnt; cnt++) {
181+
memcpy(dest, src, step);
182+
}
194183

195-
cost_time_system = millis() - start_time;
184+
cost_time_system = millis() - start_time;
196185

197-
start_time = millis();
186+
start_time = millis();
198187

199-
for (cnt = 0; cnt < repeat_cnt; cnt++)
200-
{
201-
mock_memcpy(dest, src, step);
202-
}
188+
for (cnt = 0; cnt < repeat_cnt; cnt++) {
189+
mock_memcpy(dest, src, step);
190+
}
203191

204-
cost_time_mock = millis() - start_time;
192+
cost_time_mock = millis() - start_time;
205193

206-
print_rate("System memcpy():", total_size, cost_time_system);
207-
print_rate("Mock memcpy():", total_size, cost_time_mock);
208-
}
194+
print_rate("System memcpy():", total_size, cost_time_system);
195+
print_rate("Mock memcpy():", total_size, cost_time_mock);
196+
}
209197
}
210198

211-
static void memset_speed_test(void *dest, uint8_t value, size_t size, uint32_t repeat_num)
212-
{
199+
static void memset_speed_test(void *dest, uint8_t value, size_t size, uint32_t repeat_num) {
213200
uint32_t start_time;
214201
uint32_t cost_time_system;
215202
uint32_t cost_time_mock;
216203
uint32_t cnt;
217204
uint32_t step;
218205
uint64_t total_size;
219206

220-
for (step = START_SIZE; step <= size; step <<= 1)
221-
{
222-
total_size = (uint64_t)step * (uint64_t)repeat_num;
207+
for (step = START_SIZE; step <= size; step <<= 1) {
208+
total_size = (uint64_t)step * (uint64_t)repeat_num;
223209

224-
Serial.printf("Memset %" PRIu32 " Bytes test\n", step);
210+
Serial.printf("Memset %" PRIu32 " Bytes test\n", step);
225211

226-
start_time = millis();
212+
start_time = millis();
227213

228-
for (cnt = 0; cnt < repeat_num; cnt++)
229-
{
230-
memset(dest, value, step);
231-
}
214+
for (cnt = 0; cnt < repeat_num; cnt++) {
215+
memset(dest, value, step);
216+
}
232217

233-
cost_time_system = millis() - start_time;
218+
cost_time_system = millis() - start_time;
234219

235-
start_time = millis();
220+
start_time = millis();
236221

237-
for (cnt = 0; cnt < repeat_num; cnt++)
238-
{
239-
mock_memset(dest, value, step);
240-
}
222+
for (cnt = 0; cnt < repeat_num; cnt++) {
223+
mock_memset(dest, value, step);
224+
}
241225

242-
cost_time_mock = millis() - start_time;
226+
cost_time_mock = millis() - start_time;
243227

244-
print_rate("System memset():", total_size, cost_time_system);
245-
print_rate("Mock memset():", total_size, cost_time_mock);
246-
}
228+
print_rate("System memset():", total_size, cost_time_system);
229+
print_rate("Mock memset():", total_size, cost_time_mock);
230+
}
247231
}
248232

249233
/* Main */
250234

251-
void setup()
252-
{
235+
void setup() {
253236
Serial.begin(115200);
254-
while (!Serial) delay(10);
237+
while (!Serial) {
238+
delay(10);
239+
}
255240

256241
void *dest = ps_malloc(MAX_TEST_SIZE);
257242
const void *src = ps_malloc(MAX_TEST_SIZE);
258243

259-
if (!dest || !src)
260-
{
261-
Serial.println("Memory allocation failed");
262-
return;
263-
}
244+
if (!dest || !src) {
245+
Serial.println("Memory allocation failed");
246+
return;
247+
}
264248

265249
log_d("Starting PSRAM speed test");
266250
Serial.printf("Runs: %d\n", N_RUNS);
@@ -277,7 +261,6 @@ void setup()
277261
log_d("PSRAM speed test done");
278262
}
279263

280-
void loop()
281-
{
264+
void loop() {
282265
vTaskDelete(NULL);
283266
}

0 commit comments

Comments
 (0)