int main()
{
profiling_init();
chrono_profiler cprof;
profiling_register_backend(cprof, "chrono");
#ifdef HAVE_VTUNE
vtune_profiler vtprof;
profiling_register_backend(vtprof, "vtune");
#endif
#ifdef HAVE_LIKWID
likwid_profiler lwprof;
profiling_register_backend(lwprof, "likwid");
#endif
PARALLEL_REGION
{
profiling_init_parallel();
}
PARALLEL_REGION
{
profiling_start("print");
std::cout << "Hello dudes, I'm gonna take a nap for a sec.\n";
profiling_stop("print");
profiling_start("sleep");
system("sleep 1");
profiling_stop("sleep");
profiling_start("overhead");
profiling_stop("overhead");
}
profiling_backend("chrono").report();
return 0;
}
/* ARGSUSED */
int
os_profiling_start(perf_ctl_t *ctl, perf_task_t *task)
{
if (perf_profiling_started()) {
perf_status_set(PERF_STATUS_PROFILING_STARTED);
debug_print(NULL, 2, "profiling started yet\n");
return (0);
}
os_allstop();
proc_ll_clear(NULL);
if (profiling_start(ctl, (task_profiling_t *)(task)) != 0) {
exit_msg_put("Fail to setup perf (probably permission denied)!\n");
debug_print(NULL, 2, "os_profiling_start failed\n");
perf_status_set(PERF_STATUS_PROFILING_FAILED);
return (-1);
}
debug_print(NULL, 2, "os_profiling_start success\n");
perf_status_set(PERF_STATUS_PROFILING_STARTED);
return (0);
}
PROCESS_THREAD(test_process, ev, data)
{
static uint32_t time_start = 0;
static uint32_t time_stop = 0;
static uint32_t errors = 0;
static uint32_t collisions = 0;
uint32_t i = 0;
uint32_t test_data[10] = {251284450, 371537862, 425973621, 81975339, 170405567, 225666122, 421777121, 118094495, 410814580, 414999832};
PROCESS_BEGIN();
PROCESS_PAUSE();
printf("Init done, starting test using redudancy implementation %s\n", REDUNDANCE.name);
// Initialize the profiling
profiling_init();
profiling_start();
// Measure the current time
time_start = test_precise_timestamp();
// -----------------------------------
// Check if no bundles are stored
printf("Making sure list is empty\n");
for(i=0; i<0xFFFFF; i++) {
if( REDUNDANCE.check(i) ) {
errors ++;
printf("ERROR: %lu reported to be set but should be empty\n", i);
}
// Keep the watchdog happy
if( i % 10 == 0 ) {
watchdog_periodic();
}
if( i % 10000 == 0 ) {
printf("\t%lu...\n", i);
}
}
// -----------------------------------
// Store 10 bundles
printf("Storing 10 bundles...\n");
for(i=0; i<10; i++) {
REDUNDANCE.set(test_data[i]);
// Keep the watchdog happy
if( i % 5 == 0 ) {
watchdog_periodic();
}
}
// Keep the watchdog happy
watchdog_periodic();
// -----------------------------------
// Retrieve the 10 bundles
printf("Reading 10 bundles back...\n");
for(i=0; i<10; i++) {
if( !REDUNDANCE.check(test_data[i]) ) {
printf("ERROR: %lu should be set but is not\n", i);
errors++;
} else {
printf("\t%lu is fine\n", test_data[i]);
}
}
// Keep the watchdog happy
watchdog_periodic();
// -----------------------------------
// Check how many bundle ID are actually reported as set
printf("Counting collisions...\n");
for(i=0; i<0xFFFFF; i++) {
if( REDUNDANCE.check(i) ) {
printf("\tcollision at %lu\n", i);
collisions ++;
}
// Keep the watchdog happy
if( i % 10 == 0 ) {
watchdog_periodic();
}
if( i % 10000 == 0 ) {
printf("\t%lu...\n", i);
}
}
printf("We have %lu collisions\n", collisions);
// Keep the watchdog happy
watchdog_periodic();
// -----------------------------------
// Now set 1000 bundle IDs and check the last 10 of them
printf("Setting 1000 bundle IDs...\n");
for(i=0; i<1000; i++) {
REDUNDANCE.set(i);
// Keep the watchdog happy
if( i % 5 == 0 ) {
watchdog_periodic();
}
}
// Keep the watchdog happy
watchdog_periodic();
printf("Verifying IDs...\n");
for(i=990; i<1000; i++) {
if( !REDUNDANCE.check(i) ) {
printf("ERROR: %lu should be set but is not\n", i);
errors++;
}
// Keep the watchdog happy
if( i % 5 == 0 ) {
watchdog_periodic();
}
}
printf("Done\n");
// Measure the current time
time_stop = test_precise_timestamp();
watchdog_stop();
profiling_report("redundancy", 0);
TEST_REPORT("No of errors", errors, 1, "errors");
TEST_REPORT("Duration", time_stop-time_start, CLOCK_SECOND, "s");
TEST_REPORT("No of collisions", collisions, 1, "collisions");
if( errors > 0 ) {
TEST_FAIL("More than 1 error occurred");
} else {
TEST_PASS();
}
PROCESS_END();
}
PROCESS_THREAD(test_process, ev, data)
{
static int n;
static uint32_t i;
static int errors = 0;
static struct etimer timer;
static uint32_t time_start, time_stop;
PROCESS_BEGIN();
/* Initialize the flash before the storage comes along */
PRINTF("Intializing Flash...\n");
BUNDLE_STORAGE.format();
PROCESS_PAUSE();
profiling_init();
profiling_start();
// Wait again
etimer_set(&timer, CLOCK_SECOND);
PROCESS_WAIT_UNTIL(etimer_expired(&timer));
printf("Init done, starting test using %s storage\n", BUNDLE_STORAGE.name);
profiling_init();
profiling_start();
// Measure the current time
time_start = test_precise_timestamp();
PRINTF("Create and Verify bundles in sequence\n");
for(i=0; i<TEST_BUNDLES; i++) {
PROCESS_PAUSE();
if( my_create_bundle(i, &bundle_numbers[i], 3600) ) {
PRINTF("\tBundle %lu created successfully \n", i);
} else {
PRINTF("\tBundle %lu could not be created \n", i);
errors ++;
continue;
}
if( my_verify_bundle(bundle_numbers[i], i) ) {
PRINTF("\tBundle %lu read back successfully \n", i);
} else {
PRINTF("\tBundle %lu could not be read back and verified \n", i);
errors ++;
}
}
printf("Reinitialize storage\n");
/* Reinitialize the storage and see, if the bundles persist */
BUNDLE_STORAGE.init();
PRINTF("Verify and Delete bundles in sequence\n");
for(i=0; i<TEST_BUNDLES; i++) {
if( my_verify_bundle(bundle_numbers[i], i) ) {
PRINTF("\tBundle %lu read back successfully \n", i);
} else {
PRINTF("\tBundle %lu could not be read back and verified \n", i);
errors ++;
}
n = BUNDLE_STORAGE.del_bundle(bundle_numbers[i], REASON_DELIVERED);
if( n ) {
PRINTF("\tBundle %lu deleted successfully\n", i);
} else {
PRINTF("\tBundle %lu could not be deleted\n", i);
errors++;
}
}
time_stop = test_precise_timestamp();
watchdog_stop();
profiling_report("persistent-storage", 0);
TEST_REPORT("No of errors", errors, 1, "errors");
TEST_REPORT("Duration", time_stop-time_start, CLOCK_SECOND, "s");
if( errors > 0 ) {
TEST_FAIL("More than 1 error occured");
} else {
TEST_PASS();
}
PROCESS_END();
}
PROCESS_THREAD(test_process, ev, data)
{
static int n;
static int i;
static int errors = 0;
static struct etimer timer;
static uint32_t time_start, time_stop;
uint8_t buffer[128];
int bundle_length;
struct mmem * bundle_original = NULL;
struct mmem * bundle_restored = NULL;
struct mmem * bundle_spare = NULL;
uint32_t bundle_number;
uint32_t bundle_number_spare;
PROCESS_BEGIN();
PROCESS_PAUSE();
profiling_init();
profiling_start();
// Wait again
etimer_set(&timer, CLOCK_SECOND);
PROCESS_WAIT_UNTIL(etimer_expired(&timer));
/* Profile initialization separately */
profiling_stop();
watchdog_stop();
profiling_report("init", 0);
watchdog_start();
printf("Init done, starting test using %s storage\n", BUNDLE_STORAGE.name);
profiling_init();
profiling_start();
// Measure the current time
time_start = test_precise_timestamp();
for(i=0; i<=1; i++) {
struct mmem bla;
if( i > 0 ) {
mmem_alloc(&bla, 1);
}
printf("Serializing and deserializing bundle...\n");
if( my_create_bundle(0, &bundle_number, 3600) ) {
printf("\tBundle created successfully \n");
} else {
printf("\tBundle could not be created \n");
errors ++;
}
printf("Serializing and deserializing bundle...\n");
if( my_create_bundle(1, &bundle_number_spare, 3600) ) {
printf("\tSpare Bundle created successfully \n");
} else {
printf("\tSpare Bundle could not be created \n");
errors ++;
}
bundle_original = BUNDLE_STORAGE.read_bundle(bundle_number);
if( bundle_original == NULL ) {
printf("VERIFY: MMEM ptr is invalid\n");
errors ++;
}
bundle_spare = BUNDLE_STORAGE.read_bundle(bundle_number_spare);
if( bundle_spare == NULL ) {
printf("VERIFY: MMEM ptr is invalid\n");
errors ++;
}
// Fake timing information in the bundle to make verify successful
struct bundle_t * bundle_original_bundle = (struct bundle_t *) MMEM_PTR(bundle_original);
bundle_original_bundle->aeb_value_ms = 54;
bundle_original_bundle->rec_time = clock_time();
// Serialize the bundle
memset(buffer, 0, 128);
bundle_length = bundle_encode_bundle(bundle_original, buffer, 128);
if( bundle_length < 0 ) {
printf("SERIALIZE: fail\n");
errors ++;
}
n = my_static_compare(buffer, bundle_length);
if( n > 0 ) {
printf("COMPARE: fail\n");
errors += n;
}
// Deserialize it
bundle_restored = bundle_recover_bundle(buffer, bundle_length);
if( bundle_restored == NULL ) {
printf("DESERIALIZE: unable to recover\n");
errors ++;
}
n = my_compare_bundles(bundle_original, bundle_restored);
if( n == 0 ) {
printf("\tBundle serialized and deserialized successfully\n");
} else {
printf("COMPARE: differences\n");
errors ++;
}
// Dellocate memory
bundle_decrement(bundle_restored);
bundle_restored = NULL;
bundle_decrement(bundle_original);
bundle_original = NULL;
bundle_decrement(bundle_spare);
bundle_spare = NULL;
memset(buffer, 0, 128);
// Delete bundle from storage
n = BUNDLE_STORAGE.del_bundle(bundle_number, REASON_DELIVERED);
if( n ) {
printf("\tBundle deleted successfully\n");
} else {
printf("\tBundle could not be deleted\n");
errors++;
}
printf("Comparing static bundle...\n");
if( my_create_bundle(0, &bundle_number, 3600) ) {
printf("\tReference Bundle created successfully \n");
} else {
printf("\ttReference Bundle could not be created \n");
errors ++;
}
bundle_original = BUNDLE_STORAGE.read_bundle(bundle_number);
if( bundle_original == NULL ) {
printf("VERIFY: MMEM ptr is invalid\n");
errors ++;
}
// Deserialize it
bundle_restored = bundle_recover_bundle(static_compare_bundle, sizeof(static_compare_bundle));
if( bundle_restored == NULL ) {
printf("DESERIALIZE: unable to recover static bundle\n");
errors ++;
}
// Deserialize it one more time
bundle_spare = bundle_recover_bundle(static_compare_bundle, sizeof(static_compare_bundle));
if( bundle_spare == NULL ) {
printf("DESERIALIZE: unable to recover static bundle\n");
errors ++;
}
n = my_compare_bundles(bundle_original, bundle_restored);
if( n == 0 ) {
printf("\tStatic Bundle verified successfully\n");
} else {
printf("COMPARE: differences\n");
errors ++;
}
n = my_compare_bundles(bundle_original, bundle_spare);
if( n == 0 ) {
printf("\tStatic Bundle verified successfully\n");
} else {
printf("COMPARE: differences\n");
errors ++;
}
// Dellocate memory
bundle_decrement(bundle_restored);
bundle_restored = NULL;
bundle_decrement(bundle_original);
bundle_original = NULL;
bundle_decrement(bundle_spare);
bundle_spare = NULL;
}
time_stop = test_precise_timestamp();
watchdog_stop();
profiling_report("serializer", 0);
TEST_REPORT("No of errors", errors, 1, "errors");
TEST_REPORT("Duration", time_stop-time_start, CLOCK_SECOND, "s");
if( errors > 0 ) {
TEST_FAIL("More than 0 errors occured");
} else {
TEST_PASS();
}
PROCESS_END();
}
