int main( void ) {
ALLEGRO_DISPLAY *display;
ALLEGRO_KEYBOARD_STATE key_state;
Point stars[3][NUM_STARS/3];
float speeds[3] = { 0.0001f, 0.05f, 0.15f };
ALLEGRO_COLOR colors[3];
long start, now, elapsed, frame_count;
int total_frames = 0;
double program_start;
double length;
int layer, star;
if (!al_init()) {
abort_app("Could not init Allegro.\n");
return 1;
}
al_install_keyboard();
display = al_create_display(WIDTH, HEIGHT);
if (!display) {
abort_app("Could not create display.\n");
return 1;
}
colors[0] = al_map_rgba(255, 100, 255, 128);
colors[1] = al_map_rgba(255, 100, 100, 255);
colors[2] = al_map_rgba(100, 100, 255, 255);
for (layer = 0; layer < 3; layer++) {
for (star = 0; star < NUM_STARS/3; star++) {
Point *p = &stars[layer][star];
p->x = rand() % WIDTH;
p->y = rand() % HEIGHT;
}
}
start = al_get_time() * 1000;
now = start;
elapsed = 0;
frame_count = 0;
program_start = al_get_time();
while (1) {
if (frame_count < (1000/TARGET_FPS)) {
frame_count += elapsed;
}
else {
int X, Y;
frame_count -= (1000/TARGET_FPS);
al_clear_to_color(al_map_rgb(0, 0, 0));
for (star = 0; star < NUM_STARS/3; star++) {
Point *p = &stars[0][star];
al_draw_pixel(p->x, p->y, colors[0]);
}
al_lock_bitmap(al_get_backbuffer(display), ALLEGRO_PIXEL_FORMAT_ANY, 0);
for (layer = 1; layer < 3; layer++) {
for (star = 0; star < NUM_STARS/3; star++) {
Point *p = &stars[layer][star];
// put_pixel ignores blending
al_put_pixel(p->x, p->y, colors[layer]);
}
}
/* Check that dots appear at the window extremes. */
X = WIDTH - 1;
Y = HEIGHT - 1;
al_put_pixel(0, 0, al_map_rgb_f(1, 1, 1));
al_put_pixel(X, 0, al_map_rgb_f(1, 1, 1));
al_put_pixel(0, Y, al_map_rgb_f(1, 1, 1));
al_put_pixel(X, Y, al_map_rgb_f(1, 1, 1));
al_unlock_bitmap(al_get_backbuffer(display));
al_flip_display();
total_frames++;
}
now = al_get_time() * 1000;
elapsed = now - start;
start = now;
for (layer = 0; layer < 3; layer++) {
for (star = 0; star < NUM_STARS/3; star++) {
Point *p = &stars[layer][star];
p->y -= speeds[layer] * elapsed;
if (p->y < 0) {
p->x = rand() % WIDTH;
p->y = HEIGHT;
}
}
}
al_rest(0.001);
al_get_keyboard_state(&key_state);
if (al_key_down(&key_state, ALLEGRO_KEY_ESCAPE))
break;
}
length = al_get_time() - program_start;
if (length != 0) {
printf("%d FPS\n", (int)(total_frames / length));
}
al_destroy_display(display);
return 0;
}
int
main(int argc, char *argv[])
{
int i;
shmem_init();
rank = shmem_my_pe();
world_size = shmem_n_pes();
/* root handles arguments and bcasts answers */
if (0 == rank) {
int ch;
while (start_err != 1 &&
(ch = getopt(argc, argv, "p:i:m:s:c:n:oh")) != -1) {
switch (ch) {
case 'p':
npeers = atoi(optarg);
break;
case 'i':
niters = atoi(optarg);
break;
case 'm':
nmsgs = atoi(optarg);
break;
case 's':
nbytes = atoi(optarg);
break;
case 'c':
cache_size = atoi(optarg) / sizeof(int);
break;
case 'n':
ppn = atoi(optarg);
break;
case 'o':
machine_output = 1;
break;
case 'h':
case '?':
default:
start_err = 1;
usage();
}
}
/* sanity check */
if (start_err != 1) {
#if 0
if (world_size < 3) {
fprintf(stderr, "Error: At least three processes are required\n");
start_err = 1;
} else
#endif
if (world_size <= npeers) {
fprintf(stderr, "Error: job size (%d) <= number of peers (%d)\n",
world_size, npeers);
start_err = 77;
} else if (ppn < 1) {
fprintf(stderr, "Error: must specify process per node (-n #)\n");
start_err = 77;
} else if (world_size / ppn <= npeers) {
fprintf(stderr, "Error: node count <= number of peers\n");
start_err = 77;
}
}
}
for (i = 0; i < SHMEM_BCAST_SYNC_SIZE; i++)
bcast_pSync[i] = SHMEM_SYNC_VALUE;
for (i = 0; i < SHMEM_BARRIER_SYNC_SIZE; i++)
barrier_pSync[i] = SHMEM_SYNC_VALUE;
for (i = 0; i < SHMEM_REDUCE_SYNC_SIZE; i++)
reduce_pSync[i] = SHMEM_SYNC_VALUE;
for (i = 0; i < SHMEM_REDUCE_MIN_WRKDATA_SIZE; i++)
reduce_pWrk[i] = SHMEM_SYNC_VALUE;
shmem_barrier_all();
/* broadcast results */
printf("%d: psync: 0x%lu\n", rank, (unsigned long) bcast_pSync);
shmem_broadcast32(&start_err, &start_err, 1, 0, 0, 0, world_size, bcast_pSync);
if (0 != start_err) {
exit(start_err);
}
shmem_barrier_all();
shmem_broadcast32(&npeers, &npeers, 1, 0, 0, 0, world_size, bcast_pSync);
shmem_barrier_all();
shmem_broadcast32(&niters, &niters, 1, 0, 0, 0, world_size, bcast_pSync);
shmem_barrier_all();
shmem_broadcast32(&nmsgs, &nmsgs, 1, 0, 0, 0, world_size, bcast_pSync);
shmem_barrier_all();
shmem_broadcast32(&nbytes, &nbytes, 1, 0, 0, 0, world_size, bcast_pSync);
shmem_barrier_all();
shmem_broadcast32(&cache_size, &cache_size, 1, 0, 0, 0, world_size, bcast_pSync);
shmem_barrier_all();
shmem_broadcast32(&ppn, &ppn, 1, 0, 0, 0, world_size, bcast_pSync);
shmem_barrier_all();
if (0 == rank) {
if (!machine_output) {
printf("job size: %d\n", world_size);
printf("npeers: %d\n", npeers);
printf("niters: %d\n", niters);
printf("nmsgs: %d\n", nmsgs);
printf("nbytes: %d\n", nbytes);
printf("cache size: %d\n", cache_size * (int)sizeof(int));
printf("ppn: %d\n", ppn);
} else {
printf("%d %d %d %d %d %d %d ",
world_size, npeers, niters, nmsgs, nbytes,
cache_size * (int)sizeof(int), ppn);
}
}
/* allocate buffers */
send_peers = malloc(sizeof(int) * npeers);
if (NULL == send_peers) abort_app("malloc");
recv_peers = malloc(sizeof(int) * npeers);
if (NULL == recv_peers) abort_app("malloc");
cache_buf = malloc(sizeof(int) * cache_size);
if (NULL == cache_buf) abort_app("malloc");
send_buf = malloc(npeers * nmsgs * nbytes);
if (NULL == send_buf) abort_app("malloc");
memset(send_buf, 1, npeers * nmsgs * nbytes);
recv_buf = shmem_malloc(npeers * nmsgs * nbytes);
if (NULL == recv_buf) abort_app("malloc");
memset(recv_buf, 0, npeers * nmsgs * nbytes);
/* calculate peers */
for (i = 0 ; i < npeers ; ++i) {
if (i < npeers / 2) {
send_peers[i] = (rank + world_size + ((i - npeers / 2) * ppn)) % world_size;
} else {
send_peers[i] = (rank + world_size + ((i - npeers / 2 + 1) * ppn)) % world_size;
}
}
if (npeers % 2 == 0) {
/* even */
for (i = 0 ; i < npeers ; ++i) {
if (i < npeers / 2) {
recv_peers[i] = (rank + world_size + ((i - npeers / 2) *ppn)) % world_size;
} else {
recv_peers[i] = (rank + world_size + ((i - npeers / 2 + 1) * ppn)) % world_size;
}
}
} else {
/* odd */
for (i = 0 ; i < npeers ; ++i) {
if (i < npeers / 2 + 1) {
recv_peers[i] = (rank + world_size + ((i - npeers / 2 - 1) * ppn)) % world_size;
} else {
recv_peers[i] = (rank + world_size + ((i - npeers / 2) * ppn)) % world_size;
}
}
}
/* BWB: FIX ME: trash the free lists / malloc here */
/* sync, although tests will do this on their own (in theory) */
shmem_barrier_all();
/* run tests */
test_one_way();
test_same_direction();
test_prepost();
test_allstart();
if (rank == 0 && machine_output) printf("\n");
/* done */
shmem_finalize();
return 0;
}
