Skip to content

cleanup pico_stdlib_test. add actual check for __builtin bitops #821

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
May 10, 2022
Merged

cleanup pico_stdlib_test. add actual check for __builtin bitops #821

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
195 changes: 59 additions & 136 deletions test/pico_stdlib_test/pico_stdlib_test.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -8,11 +8,67 @@
#include <inttypes.h>
#include "pico/stdlib.h"
#include "pico/bit_ops.h"
#include <stdlib.h>

void test_builtin_bitops() {
int32_t x = 0;
for (uint32_t i = 0; i < 10000; i++) {
uint32_t vals32[] = {
i,
1u << (i & 31u),
i * 12355821u,
};
uint64_t vals64[] = {
i,
1ull << (i & 63u),
i * 12345678123125ull,
};
for(int j=0; j<count_of(vals32); j++) {
x += __builtin_popcount(vals32[j]);
x += __builtin_popcountl(vals32[j]);
x += (int32_t)__rev(vals32[j]);
#if !PICO_ON_DEVICE
// the following functions are undefined on host mode, but on RP2040 we return 32
if (vals32[j]) {
x += __builtin_clz(vals32[j]);
x += __builtin_ctz(vals32[j]);
} else {
x += 64;
}
#else
x += __builtin_clz(vals32[j]);
x += __builtin_ctz(vals32[j]);
// check l variants are the same
if (__builtin_clz(vals32[j]) != __builtin_clzl(vals32[j])) x += 17;
if (__builtin_ctz(vals32[j]) != __builtin_ctzl(vals32[j])) x += 23;
#endif
}
for(int j=0; j<count_of(vals64); j++) {
x += __builtin_popcountll(vals64[j]);
x += (int32_t)__revll(vals64[j]);
#if !PICO_ON_DEVICE
// the following functions are undefined on host mode, but on RP2040 we return 64
if (!vals64[j]) {
x += 128;
continue;
}
#endif
x += __builtin_clzll(vals64[j]);
x += __builtin_ctzll(vals64[j]);
}
}
printf("Count is %d\n", (int)x);
int32_t expected = 1475508680;
if (x != expected) {
printf("FAILED (expected count %d\n", (int) expected);
exit(1);
}
}

int main() {
setup_default_uart();

puts("Hellox, worlxxcd!");
puts("Hellox, world!");
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Hellox?

printf("Hello world %d\n", 2);
#if PICO_NO_HARDWARE
puts("This is native");
Expand All @@ -29,6 +85,8 @@ int main() {
(unsigned long long) __revll(xl));
}

test_builtin_bitops();

for (int i = 0; i < 8; i++) {
sleep_ms(500);
printf( "%" PRIu64 "\n", to_us_since_boot(get_absolute_time()));
Expand All @@ -42,138 +100,3 @@ int main() {
}
puts("DONE");
}

void test1() {
uint32_t x = 0;
for (int i = 0; i < 1000; i++) {
x += __builtin_popcount(i);
x += __builtin_popcountl(i);
x += __builtin_popcountll(i * 1234567ll);
x += __builtin_clz(i);
x += __builtin_clzl(i);
x += __builtin_clzll(i * 1234567ll);
x += __builtin_ctz(i);
x += __builtin_ctzl(i);
x += __builtin_ctzll(i * 1234567ll);
}
if (x > 12345677) {
puts("ok");
}
}

#if 0
struct event {

};

// something might be asyncrhonous.. it communicates the result via the event
void do_something(struct event *e, int a, unsigned int b, char *c) {
if (a == b) puts(c);
}

int32_t event_result_timeout_ms(struct event *e, int32_t timeout_ms);
int32_t event_result_timeout_us(struct event *e, int32_t timeout_us);
bool is_event_done(struct event *e);
// asserts if not done
int32_t event_result(struct event *e);
void event_set_callback(struct event *e, void (*callback)(struct event *e));
void init_multi_event(struct event *target, struct event **events, uint event_count);

#define timeout_ms_result(f, timeout) ({ \
struct event __event; \
struct event *event = &__event; \
(f); \
event_result_timeout_ms(event, timeout); \
})

#define blocking_result(f) timeout_ms_result(f, -1)
#define on_complete(f, cb) ({ \
static struct event __event; \
struct event *event = &__event; \
(f); \
event_set_callback(event, my_callback); \
})

void test2() {
// just playing with blocking syntax
struct event e;
do_something(&e, 1, 1, "Hello");
uint32_t result = event_result_timeout_ms(&e, -1);
}

void test3() {
uint32_t result = blocking_result(do_something(event, 1, 1, "Hello"));
}

void test4() {
struct event e;
do_something(&e, 1, 1, "Hello");
// this would poll (down to hardware if there is no asynchronous mechanism)
while (!is_event_done(&e)) {
puts("waiting");
}
int32_t result = event_result(&e);
}

void my_callback(struct event *event) {
puts("Its done");
int32_t result = event_result(event);
}

void test5() {
static struct event e;
do_something(&e, 1, 1, "Hello");
event_set_callback(&e, my_callback);
}

void test6() {
on_complete(do_something(event, 1, 1, "Hello"), my_callback);
}

static struct event e1;
static struct event e2;
static struct event *events[2] = {&e1, &e2};
static struct event multi;

void test7() {
init_multi_event(&multi,events, count_of(events));
do_something(&e1, 1, 1, "Hello");
do_something(&e2, 1, 3, "Hello");
// something like this
}

struct dimpl {
uint8_t type;
};

struct doodad {
struct dimpl *type;
uint32_t param;
};

struct dimpl indefinite_waiter = {
.type = 1
};

extern struct dimpl INDEFINITE_WAIT;

struct dimpl ms_waiter = {
.type = 1
};

struct doodad blocking_with_timeout_ms(uint32_t ms) {
struct doodad rc = {
.type = &ms_waiter,
.param = ms
};
return rc;
}

struct result {

};

struct result my_api_call(int arg, float x, struct doodad behavior) {

}
#endif