Forum: Compiler & IDEs STM32: Arrays und Performance

/*************************************************************************

"Conway's Game of Life" benchmark for 8 bit and 32 bit data types.

The calculations start with a pseudo-random, but reproducible world. The

calculations are identical in every benchmark call with the same number

of generations.

resource requirements:

needs about 8 kB RAM for the "game of life" worlds at 32x32 cells.

external requirements:

needs the following get-time function:

int32_t Get_Time(void);

benchmark functions:

int32_t Gol_Benchmark_8(uint32_t num_generations);

int32_t Gol_Benchmark_32(uint32_t num_generations);

SIGNED_TEST:  if this define is enabled, signed integers are used.

input:        desired number of generations.

output:       difference between Get_Time() at start and end, in whatever

              unit the Get_Time() function is using. The initialization

              is not part of the benchmark.

side effects: the volatile global variable "prevent_compiler_opt" is set

              to the final state of the middle "game of life" cell. This

              keeps the compiler from optimizing the benchmark away.

limitations:  cell 0 is not updated, and the border wrapping is strange,

              but it doesn't matter for benchmarking.

*************************************************************************/

#include <stdint.h>

#define SIGNED_TEST

#ifdef SIGNED_TEST

    #define INT8 int8_t

    #define INT32 int32_t

#else

    #define INT8 uint8_t

    #define INT32 uint32_t

#endif

#define DEAD      0

#define ALIVE     1U

/*must be powers of 2*/

#define ROWS      32UL

#define COLS      32UL

#define WRAP_MASK (ROWS * COLS - 1UL)

extern int32_t Get_Time(void);

volatile INT32 prevent_compiler_opt;

/*reuse the worlds for the 8 bit test via pointer casting*/

static INT32 world_0[ROWS * COLS];

static INT32 world_1[ROWS * COLS];

static uint32_t rand_state;

static uint32_t Random(uint32_t max_val) {

    rand_state *= 1103515245UL;

    rand_state += 12345UL;

    return((rand_state >> 16U) % max_val);

}

static void Gol_Init_8(INT8 *world_8) {

    uint32_t cnt;

    rand_state = 42UL; /*pseudo-random, reproducible init*/

    for (cnt = 0; cnt < ROWS * COLS; cnt++)

        world_8[cnt] = (INT8) Random(ALIVE+1UL);

}

static void Gol_Init_32(INT32 *world_32) {

    uint32_t cnt;

    rand_state = 42UL; /*pseudo-random, reproducible init*/

    for (cnt = 0; cnt < ROWS * COLS; cnt++)

        world_32[cnt] = (INT32) Random(ALIVE+1UL);

}

static void Gol_Iteration_8(const INT8 *old_world, INT8 *new_world) {

    uint32_t base_cell;

    /*some simplifications here to avoid benchmarking the loop overhead

      or the wrapping.

      cell 0 is not updated, and the wrapping is strange, but it doesn't

      matter for benchmarking.*/

    for (base_cell = ROWS * COLS - 1UL; base_cell != 0; base_cell--) {

        INT32 cell_state, living_adjacents;

        /*counting from upper left adjacent, clockwise*/

        living_adjacents  = old_world[(base_cell - COLS - 1UL) & WRAP_MASK];

        living_adjacents += old_world[(base_cell - COLS      ) & WRAP_MASK];

        living_adjacents += old_world[(base_cell - COLS + 1UL) & WRAP_MASK];

        living_adjacents += old_world[(base_cell        + 1UL) & WRAP_MASK];

        living_adjacents += old_world[(base_cell + COLS + 1UL) & WRAP_MASK];

        living_adjacents += old_world[(base_cell + COLS      ) & WRAP_MASK];

        living_adjacents += old_world[(base_cell + COLS - 1UL) & WRAP_MASK];

        living_adjacents += old_world[(base_cell        - 1UL) & WRAP_MASK];

        cell_state = old_world[base_cell];

        if (cell_state == DEAD) {

            if (living_adjacents == 3) /*cell born*/

                new_world[base_cell] = ALIVE;

            else

                new_world[base_cell] = DEAD;

        } else { /*cell has been alive*/

            if ((living_adjacents == 2) || (living_adjacents == 3))

                new_world[base_cell] = ALIVE; /*cell survives*/

            else

                new_world[base_cell] = DEAD; /*cell dies*/

        }

    }

}

static void Gol_Iteration_32(const INT32 *old_world, INT32 *new_world) {

    uint32_t base_cell;

    /*some simplifications here to avoid benchmarking the loop overhead

      or the wrapping.

      cell 0 is not updated, and the wrapping is strange, but it doesn't

      matter for benchmarking.*/

    for (base_cell = ROWS * COLS - 1UL; base_cell != 0; base_cell--) {

        INT32 living_adjacents, cell_state;

        /*counting from upper left adjacent, clockwise*/

        living_adjacents  = old_world[(base_cell - COLS - 1UL) & WRAP_MASK];

        living_adjacents += old_world[(base_cell - COLS      ) & WRAP_MASK];

        living_adjacents += old_world[(base_cell - COLS + 1UL) & WRAP_MASK];

        living_adjacents += old_world[(base_cell        + 1UL) & WRAP_MASK];

        living_adjacents += old_world[(base_cell + COLS + 1UL) & WRAP_MASK];

        living_adjacents += old_world[(base_cell + COLS      ) & WRAP_MASK];

        living_adjacents += old_world[(base_cell + COLS - 1UL) & WRAP_MASK];

        living_adjacents += old_world[(base_cell        - 1UL) & WRAP_MASK];

        cell_state = old_world[base_cell];

        if (cell_state == DEAD) {

            if (living_adjacents == 3) /*cell born*/

                new_world[base_cell] = ALIVE;

            else

                new_world[base_cell] = DEAD;

        } else { /*cell has been alive*/

            if ((living_adjacents == 2) || (living_adjacents == 3))

                new_world[base_cell] = ALIVE; /*cell survives*/

            else

                new_world[base_cell] = DEAD; /*cell dies*/

        }

    }

}

/*the 8 bit benchmark API function*/

int32_t Gol_Benchmark_8(uint32_t num_generations) {

    INT8 *old_world, *new_world;

    int32_t start_time, end_time;

    uint32_t cnt;

    /*set up buffers*/

    old_world = (INT8 *) world_0;

    new_world = (INT8 *) world_1;

    /*init time does not count*/

    Gol_Init_8(old_world);

    start_time = Get_Time();

    for (cnt = num_generations; cnt != 0; cnt--) {

        INT8 *tmp_ptr;

        Gol_Iteration_8(old_world, new_world);

        /*switch buffers*/

        tmp_ptr = old_world;

        old_world = new_world;

        new_world = tmp_ptr;

    }

    end_time = Get_Time();

    prevent_compiler_opt = old_world[ROWS * COLS / 2UL];

    return(end_time - start_time);

}

/*the 32 bit benchmark API function*/

int32_t Gol_Benchmark_32(uint32_t num_generations) {

    INT32 *old_world, *new_world;

    int32_t start_time, end_time;

    uint32_t cnt;

    /*set up buffers*/

    old_world = world_0;

    new_world = world_1;

    /*init time does not count*/

    Gol_Init_32(old_world);

    start_time = Get_Time();

    for (cnt = num_generations; cnt != 0; cnt--) {

        INT32 *tmp_ptr;

        Gol_Iteration_32(old_world, new_world);

        /*switch buffers*/

        tmp_ptr = old_world;

        old_world = new_world;

        new_world = tmp_ptr;

    }

    end_time = Get_Time();

    prevent_compiler_opt = old_world[ROWS * COLS / 2UL];

    return(end_time - start_time);

}