int main( int argc, char **argv )
{
if( find_option( argc, argv, "-h" ) >= 0 )
{
printf( "Options:\n" );
printf( "-h to see this help\n" );
printf( "-n <int> to set the number of particles\n" );
printf( "-o <filename> to specify the output file name\n" );
return 0;
}
int n = read_int( argc, argv, "-n", 1000 );
char *savename = read_string( argc, argv, "-o", NULL );
FILE *fsave = savename ? fopen( savename, "w" ) : NULL;
particle_t *particles = (particle_t*) malloc( n * sizeof(particle_t) );
set_size( n );
init_particles( n, particles );
//
// simulate a number of time steps
//
double simulation_time = read_timer( );
run_simulation(particles, n, fsave);
simulation_time = read_timer( ) - simulation_time;
printf( "n = %d, simulation time = %g seconds\n", n, simulation_time );
free( particles );
if( fsave )
fclose( fsave );
return 0;
}
int main(int argc, char *argv[]) {
int N = VECTOR_LENGTH;
int num_tasks = 4;
double elapsed; /* for timing */
if (argc < 3) {
fprintf(stderr, "Usage: sum [<N(%d)>] [<#tasks(%d)>]\n", N,num_tasks);
fprintf(stderr, "\t Example: ./sum %d %d\n", N,num_tasks);
} else {
N = atoi(argv[1]);
num_tasks = atoi(argv[2]);
}
REAL *A = (REAL*)malloc(sizeof(REAL)*N);
srand48((1 << 12));
init(A, N);
/* example run */
elapsed = read_timer();
REAL result = sum(N, A);
elapsed = (read_timer() - elapsed);
/* more runs */
/* you should add the call to each function and time the execution */
printf("======================================================================================================\n");
printf("\tSum %d numbers with %d tasks\n", N, num_tasks);
printf("------------------------------------------------------------------------------------------------------\n");
printf("Performance:\t\tRuntime (ms)\t MFLOPS \n");
printf("------------------------------------------------------------------------------------------------------\n");
printf("Sum:\t\t\t%4f\t%4f\n", elapsed * 1.0e3, 2*N / (1.0e6 * elapsed));
free(A);
return 0;
}
/* read command line, initialize, and create threads */
int main(int argc, char *argv[]) {
int i, j;
long l; /* use long in case of a 64-bit system */
pthread_attr_t attr;
pthread_t workerid[MAXWORKERS];
/* set global thread attributes */
pthread_attr_init(&attr);
pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);
/* initialize mutex and condition variable */
pthread_mutex_init(&updatelock, NULL);
pthread_mutex_init(&baglock, NULL);
pthread_cond_init(&finished, NULL);
final_num_workers = 0;
final_min = 1000;
current_row = 0;
/* read command line args if any */
size = (argc > 1)? atoi(argv[1]) : MAXSIZE;
numWorkers = (argc > 2)? atoi(argv[2]) : MAXWORKERS;
if (size > MAXSIZE) size = MAXSIZE;
if (numWorkers > MAXWORKERS) numWorkers = MAXWORKERS;
/* initialize random seed */
srand ( time(NULL) );
/* initialize the matrix */
for (i = 0; i < size; i++) {
for (j = 0; j < size; j++) {
matrix[i][j] = rand()%99;
}
}
/* print the matrix */
#ifdef DEBUG
for (i = 0; i < size; i++) {
printf("[ ");
for (j = 0; j < size; j++) {
printf(" %d", matrix[i][j]);
}
printf(" ]\n");
}
#endif
/* do the parallel work: create the workers */
start_time = read_timer();
for (l = 0; l < numWorkers; l++)
pthread_create(&workerid[l], &attr, Worker, (void *) l);
pthread_cond_wait(&finished, &updatelock);
end_time = read_timer();
print_result();
pthread_exit(NULL);
}
int main(int argc, char **argv) {
std::string interleaving;
if (argc > 1) {
interleaving = argv[1];
} else {
interleaving = "";
}
for( int n = 1000; n <= 10000000; n *= 10 ) {
std::vector<Point*> S;
for( int i = 0; i < n; i++ ) {
S.push_back( new Point );
S.back()->index = i;
S.back()->x = drand48();
S.back()->y = drand48();
}
double stime = read_timer();
DelaunayProblem *problem = new DelaunayProblem(&S, 0, n);
Framework::solve(problem, interleaving);
printf("%d time %f\n", n, read_timer()-stime);
delete problem;
}
}
//
// benchmarking program
//
int main( int argc, char **argv )
{
if( find_option( argc, argv, "-h" ) >= 0 )
{
printf( "Options:\n" );
printf( "-h to see this help\n" );
printf( "-n <int> to set the number of particles\n" );
printf( "-o <filename> to specify the output file name\n" );
return 0;
}
int n = read_int( argc, argv, "-n", 1000 );
char *savename = read_string( argc, argv, "-o", NULL );
FILE *fsave = savename ? fopen( savename, "w" ) : NULL;
particle_t *particles = (particle_t*) malloc( n * sizeof(particle_t) );
set_size( n );
init_particles( n, particles );
//
// simulate a number of time steps
//
double simulation_time = read_timer( );
for( int step = 0; step < NSTEPS; step++ )
{
//
// compute forces
//
for( int i = 0; i < n; i++ )
{
particles[i].ax = particles[i].ay = 0;
for (int j = 0; j < n; j++ )
apply_force( particles[i], particles[j] );
}
//
// move particles
//
for( int i = 0; i < n; i++ )
move( particles[i] );
//
// save if necessary
//
if( fsave && (step%SAVEFREQ) == 0 )
save( fsave, n, particles );
}
simulation_time = read_timer( ) - simulation_time;
printf( "n = %d, simulation time = %g seconds\n", n, simulation_time );
free( particles );
if( fsave )
fclose( fsave );
return 0;
}
// For benchmark purposes, makes a clean copy of array to sort
// before calling sequential quicksort
void do_seq_quicksort() {
int *arr_cpy = malloc(sizeof (array));
memcpy(arr_cpy, array, sizeof (array));
double start = read_timer();
sequential_quicksort(arr_cpy, 0, size);
double end = read_timer();
printf("Sequential quicksort time: %f\n", (end - start));
free(arr_cpy);
}
void __udelay(unsigned long usec)
{
unsigned long long target;
read_timer();
target = timer.ticks + usecs_to_ticks(usec);
while (timer.ticks < target)
read_timer();
}
int main( int argc, char **argv ) {
initCommunication( &argc, &argv );
// make up a simple test
int size = read_int( argc, argv, "-s", 8 );
int r = read_int( argc, argv, "-r", 2 );
int P;
MPI_Comm_size( MPI_COMM_WORLD, &P );
initSizes( P, r, size );
if( getRank() == 0 ) {
if( P > (1<<r) )
printf("Need more recursive steps for this many processors\n");
if( P > (size/(1<<r))*(size/(1<<r)+1)/2)
printf("Need a bigger matrix/fewer recursive steps for this many processors\n");
printf("-s %d -r %d -n %d\n", size, r, P);
}
int sizeSq = getSizeSq(r,P);
int sizeTri = getSizeTri(r,P);
double *X = (double*) malloc( sizeSq*sizeof(double) );
srand48(getRank());
fill(X,sizeSq);
double *A = (double*) malloc( sizeTri*sizeof(double) );
if( getRank() == 0 )
printf("Generating a symmetric positive definite test matrix\n");
initTimers();
MPI_Barrier( MPI_COMM_WORLD );
double st2 = read_timer();
syrk( A, X, size, P, r, 0. );
MPI_Barrier( MPI_COMM_WORLD );
double et2 = read_timer();
if( getRank() == 0 )
printf("Generation time: %f\n", et2-st2);
initTimers();
free(X);
for( int i = 0; i < sizeTri; i++ )
A[i] = -A[i];
if( getRank() == 0 )
printf("Starting benchmark\n");
MPI_Barrier( MPI_COMM_WORLD );
double startTime = read_timer();
chol( A, size, P, r );
MPI_Barrier( MPI_COMM_WORLD );
double endTime = read_timer();
if( getRank() == 0 )
printf("Time: %f Gflop/s %f\n", endTime-startTime, size*1.*size*size/3./(endTime-startTime)/1.e9);
free(A);
printCounters(size);
MPI_Finalize();
}
/* delay x useconds */
void __udelay(unsigned long usec)
{
long tmo = USEC_TO_COUNT(usec);
ulong now, last = read_timer();
while (tmo > 0) {
now = read_timer();
if (now > last) /* normal (non rollover) */
tmo -= now - last;
else /* rollover */
tmo -= TIMER_LOAD_VAL - last + now;
last = now;
}
}
/*
* Reset the timer
*/
void reset_timer_count(void)
{
/* capure current decrementer value time */
gd->lastinc = read_timer();
/* start "advancing" time stamp from 0 */
gd->tbl = 0;
}
int dotcpwatch (int argc, char** argv, void *p)
{
if(argc < 2)
{
tprintf ("TCP Watch Dog timer %d/%d seconds\n",
read_timer (&TcpWatchTimer)/1000,
dur_timer(&TcpWatchTimer)/1000);
return 0;
}
stop_timer (&TcpWatchTimer); /* in case it's already running */
/* what to call on timeout */
TcpWatchTimer.func = (void (*)(void*))dowatchtick;
TcpWatchTimer.arg = NULLCHAR; /* dummy value */
/* set timer duration */
set_timer (&TcpWatchTimer, (uint32)atoi (argv[1])*1000);
start_timer (&TcpWatchTimer); /* and fire it up */
return 0;
}
// Starts multithreaded quicksort
void do_parallel_quicksort() {
range array_range = {0, size - 1};
/* set global thread attributes */
pthread_t worker;
pthread_attr_init(&attr);
pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);
double start = read_timer();
pthread_create(&worker, &attr, quicksort, (void *) &array_range);
pthread_attr_destroy(&attr);
pthread_join(worker, NULL);
double end = read_timer();
printf("Time: %f\n", (end - start));
}
static void write_intr(void)
{
struct request *req = hd_req;
int i;
int retries = 100000;
do {
i = (unsigned) inb_p(HD_STATUS);
if (i & BUSY_STAT)
continue;
if (!OK_STATUS(i))
break;
if ((blk_rq_sectors(req) <= 1) || (i & DRQ_STAT))
goto ok_to_write;
} while (--retries > 0);
dump_status("write_intr", i);
bad_rw_intr();
hd_request();
return;
ok_to_write:
if (hd_end_request(0, 512)) {
SET_HANDLER(&write_intr);
outsw(HD_DATA, req->buffer, 256);
return;
}
#if (HD_DELAY > 0)
last_req = read_timer();
#endif
hd_request();
}
/* Each worker sums the values in one strip of the matrix.
After a barrier, worker(0) computes and prints the total */
void *Worker(void *arg) {
long myid = (long) arg;
int total, i, j, first, last;
#ifdef DEBUG
printf("worker %d (pthread id %d) has started\n", myid, pthread_self());
#endif
/* determine first and last rows of my strip */
first = myid*stripSize;
last = (myid == numWorkers - 1) ? (size - 1) : (first + stripSize - 1);
/* sum values in my strip */
total = 0;
for (i = first; i <= last; i++)
for (j = 0; j < size; j++)
total += matrix[i][j];
sums[myid] = total;
Barrier();
if (myid == 0) {
total = 0;
for (i = 0; i < numWorkers; i++)
total += sums[i];
/* get end time */
end_time = read_timer();
/* print results */
printf("The total is %d\n", total);
printf("The execution time is %g sec\n", end_time - start_time);
}
}
void reset_timer_masked(void)
{
/* reset time */
gd->lastinc = read_timer();
gd->timer_reset_value = 0;
}
static void hd_out(struct hd_i_struct *disk,
unsigned int nsect,
unsigned int sect,
unsigned int head,
unsigned int cyl,
unsigned int cmd,
void (*intr_addr)(void))
{
unsigned short port;
#if (HD_DELAY > 0)
while (read_timer() - last_req < HD_DELAY)
/* nothing */;
#endif
if (reset)
return;
if (!controller_ready(disk->unit, head)) {
reset = 1;
return;
}
SET_HANDLER(intr_addr);
outb_p(disk->ctl,HD_CMD);
port=HD_DATA;
outb_p(disk->wpcom>>2,++port);
outb_p(nsect,++port);
outb_p(sect,++port);
outb_p(cyl,++port);
outb_p(cyl>>8,++port);
outb_p(0xA0|(disk->unit<<4)|head,++port);
outb_p(cmd,++port);
}
/*
* init the Timer
*/
int timer_init(void)
{
struct panthapb_registers *apb1clkres =
(struct panthapb_registers *) PANTHEON_APBC_BASE;
struct panthtmr_registers *panthtimers =
(struct panthtmr_registers *) PANTHEON_TIMER_BASE;
/* Enable Timer clock at 3.25 MHZ */
writel(APBC_APBCLK | APBC_FNCLK | APBC_FNCLKSEL(3), &apb1clkres->timers);
/* load value into timer */
writel(0x0, &panthtimers->clk_ctrl);
/* Use Timer 0 Match Resiger 0 */
writel(TIMER_LOAD_VAL, &panthtimers->match[MATCH_CMP(0)]);
/* Preload value is 0 */
writel(0x0, &panthtimers->preload[TIMER]);
/* Enable match comparator 0 for Timer 0 */
writel(0x1, &panthtimers->preload_ctrl[TIMER]);
/* Enable timer 0 */
writel(0x1, &panthtimers->cer);
/* init the gd->tbu and gd->tbl value */
gd->tbl = read_timer();
gd->tbu = 0;
return 0;
}
test_loop_speed_inversetransform(void)
{
struct weston_matrix m;
struct inverse_matrix inv;
struct weston_vector v = { { 0.5, 0.5, 0.5, 1.0 } };
unsigned long count = 0;
double t;
printf("\nRunning 3 s test on inverse_transform()...\n");
weston_matrix_init(&m);
matrix_invert(inv.LU, inv.perm, &m);
running = 1;
alarm(3);
reset_timer();
while (running) {
inverse_transform(inv.LU, inv.perm, v.f);
count++;
}
t = read_timer();
printf("%lu iterations in %f seconds, avg. %.1f ns/iter.\n",
count, t, 1e9 * t / count);
}
static void recal_intr(void)
{
check_status();
#if (HD_DELAY > 0)
last_req = read_timer();
#endif
hd_request();
}
int32
next_timer_event(void)
{
if (Timers)
return read_timer(Timers);
else
return 0x7fffffff;
}
/*
* Reset the timer
*/
void reset_timer(void)
{
/* capture current decrementer value time */
gd->lastinc = read_timer() /
(CONFIG_TIMER_CLOCK_KHZ * 1000 / CONFIG_SYS_HZ);
/* start "advancing" time stamp from 0 */
gd->tbl = 0;
}
int main(int argc, char *argv[])
{
int n;
REAL *y_omp, *y_ompacc, *x;
REAL a = 123.456;
#pragma omp target device(mpi:all) begin
n = VEC_LEN;
y_omp = (REAL *) malloc(n * sizeof(REAL));
y_ompacc = (REAL *) malloc(n * sizeof(REAL));
x = (REAL *) malloc(n * sizeof(REAL));
#pragma omp target device(mpi:all) end
#pragma omp target device(mpi:master) begin
srand48(1<<12);
init(x, n);
init(y_ompacc, n);
memcpy(y_ompacc, y_omp, n*sizeof(REAL));
#pragma omp target device(mpi:master) end
int num_threads;
// #pragma omp parallel shared (num_threads)
{
if (omp_get_thread_num() == 0)
num_threads = omp_get_num_threads();
}
/* CPU threading version*/
double omp_time = read_timer();
axpy_omp(x, y_omp, n, a);
omp_time = read_timer() - omp_time;
/* openmp acc version */
double ompacc_time = read_timer();
axpy_ompacc(x, y_ompacc, n, a);
ompacc_time = read_timer() - ompacc_time;
printf("axpy(%d): checksum: %g; time(s):\tOMP(%d threads)\tOMPACC\n", n, check(y_omp, y_ompacc, n),num_threads);
printf("\t\t\t\t\t\t%4f\t%4f\n", omp_time, ompacc_time);
free(y_omp);
free(y_ompacc);
free(x);
return 0;
}
int main(int argc, char *argv[]) {
int N = VECTOR_LENGTH;
int num_threads = 4; /* 4 is default number of threads */
if (argc < 2) {
fprintf(stderr, "Usage: axpy <n> [<#threads(%d)>] (n should be dividable by #threads)\n", num_threads);
exit(1);
}
N = atoi(argv[1]);
if (argc > 2) num_threads = atoi(argv[2]);
omp_set_num_threads(num_threads);
REAL a = 123.456;
REAL *Y_base = malloc(sizeof(REAL)*N);
REAL *Y_parallel = malloc(sizeof(REAL)*N);
REAL *X = malloc(sizeof(REAL)* N);
srand48((1 << 12));
init(X, N);
init(Y_base, N);
memcpy(Y_parallel, Y_base, N * sizeof(REAL));
int i;
int num_runs = 10;
double elapsed_omp_parallel_for = read_timer();
for (i=0; i<num_runs; i++) axpy_omp_parallel_for(N, Y_parallel, X, a);
elapsed_omp_parallel_for = (read_timer() - elapsed_omp_parallel_for)/num_runs;
/* you should add the call to each function and time the execution */
printf("======================================================================================================\n");
printf("\tAXPY: Y[N] = Y[N] + a*X[N], N=%d, %d threads for dist\n", N, num_threads);
printf("------------------------------------------------------------------------------------------------------\n");
printf("Performance:\t\t\tRuntime (ms)\t MFLOPS \t\tError (compared to base)\n");
printf("------------------------------------------------------------------------------------------------------\n");
printf("axpy_omp_parallel_for:\t\t%4f\t%4f \t\t%g\n", elapsed_omp_parallel_for * 1.0e3, (2.0 * N) / (1.0e6 * elapsed_omp_parallel_for), check(Y_base,Y_parallel, N));
free(Y_base);
free(Y_parallel);
free(X);
return 0;
}
void cmd_add(int socket)
{
char line[MAX_LINE];
Book *book = book_load_file(BOOK_PATH);
Timer *timer, *new_timer;
int i;
FILE *fp;
new_timer = read_timer(socket);
if(new_timer == NULL)
{
book_free(book);
return;
}
fp = fopen(BOOK_PATH, "w");
fwrite(book_xml_header, 1, sizeof(book_xml_header)-1,fp);
printf("%s", book_xml_header);
fwrite(book_xml_timerlist_start, 1, sizeof(book_xml_timerlist_start)-1,fp);
printf("%s", book_xml_timerlist_start);
for(i=0,timer=book->timers;i<book->n_timers;i++,timer++)
{
sprintf(line," <Timer fname=\"%s\" startMjd=\"%d\" nextMjd=\"%d\" start=\"%d\" duration=\"%d\" repeat=\"%d\" play=\"%d\" lock=\"%d\" onId=\"%d\" tsId=\"%d\" svcId=\"%d\" />\n",
timer->filename, timer->startmjd, timer->nextmjd, timer->start, timer->duration,
timer->repeat, timer->play, timer->lock, timer->onid, timer->tsid, timer->svcid);
fwrite(line, 1, strlen(line),fp);
printf("%s",line);
}
timer = new_timer;
sprintf(line," <Timer fname=\"%s\" startMjd=\"%d\" nextMjd=\"%d\" start=\"%d\" duration=\"%d\" repeat=\"%d\" play=\"%d\" lock=\"%d\" onId=\"%d\" tsId=\"%d\" svcId=\"%d\" />\n",
timer->filename, timer->startmjd, timer->nextmjd, timer->start, timer->duration,
timer->repeat, timer->play, timer->lock, timer->onid, timer->tsid, timer->svcid);
fwrite(line, 1, strlen(line),fp);
printf("%s",line);
free(new_timer->filename);
free(new_timer);
fwrite(book_xml_timerlist_end, 1, sizeof(book_xml_timerlist_end)-1,fp);
printf("%s", book_xml_timerlist_end);
fwrite(book_xml_footer, 1, sizeof(book_xml_footer)-1, fp);
printf("%s", book_xml_footer);
fclose(fp);
book_free(book);
return;
}
int main () {
struct timeval tv;
struct timezone tz;
struct tm*tm;
tm = localtime(&tv.tv_sec);
gettimeofday(&tv, &tz);
//srand(tv.tv_usec * tv.tv_sec);
v_o = 4; v_th = sqrt(.2);
//Lx = 40; Ly = 20;
Lx = 40; Ly = 20;
dx = 1; dy = 1; delta2 = dx*dx;
imax = Lx - 1; jmax = Ly;
nmax = imax*jmax;
//ppc = 1200;
ppc = 200;
LeftBC = 0; RightBC = -10;
pcn = 1/(double)ppc;
Npart = Lx*Ly*ppc;
pi = 4*atan(1);
nt = .5;
dt = nt/(v_o*(1 + erf(v_th/v_o)));
//finaltime = 50;
finaltime = 10;
omega = 1;
initial_conditions();
seconds = read_timer();
inject_node_move();
elapsed = read_timer() - seconds;
outputs();
FILE *file1;
file1 = fopen("Sys_Cond.txt", "w");
fprintf(file1, "%d\t%d\t%d\t%d\t%d",Lx,Ly,dx,dy,finaltime);
fclose(file1);
printf("Elapsed time (serial): %f seconds\n", elapsed);
return EXIT_SUCCESS;
}
/*
* Get the number of ticks (in CONFIG_SYS_HZ resolution)
*/
unsigned long long get_ticks(void)
{
unsigned long long sys_ticks;
read_timer();
sys_ticks = timer.ticks * CONFIG_SYS_HZ;
do_div(sys_ticks, TIMER_FREQ);
return sys_ticks;
}
int main(){
printf("Dense Linear Algebra Tests.\n") ;
int i;
int numTests = 2;
char *pass = (char *) malloc(numTests * sizeof(char));
char allPass = 1;
double startTime, endTime;
startTime = read_timer();
pass[0] = checkLU() ;
pass[1] = checkQR() ;
endTime = read_timer();
printf("Total time for all tests = %f seconds.\n\n", endTime - startTime);
// Check whether all tests passed.
for(i=0; i<numTests; i++){
if(pass[i]){
printf("Test %d passed.\n", i) ;
allPass &= 1;
}
else{
fprintf(stderr, "Test %d failed.\n", i) ;
allPass = 0;
}
}
if( allPass )
printf("\nAll tests passed.\n\n") ;
else
fprintf(stderr, "\nTests failed!\n") ;
free(pass) ;
return allPass;
}
void udelay(unsigned usec)
{
u32 curr_tick, last_tick;
s32 ticks_left;
last_tick = read_timer();
/* 24 timer ticks per microsecond (24 MHz, divided by 1) */
ticks_left = usec * 24;
/* FIXME: Should we consider timer rollover?
* From when we start the timer, we have almost three minutes before it
* rolls over, so we should be long into having booted our payload.
*/
while (ticks_left > 0) {
curr_tick = read_timer();
/* Timer value decreases with each tick */
ticks_left -= last_tick - curr_tick;
last_tick = curr_tick;
}
}
/*
* Delay x useconds
*/
void __udelay(unsigned long usec)
{
unsigned long now, last;
/*
* get the tmo value based on timer clock speed
* tmo = delay required / period of timer clock
*/
long tmo = usec * CONFIG_TIMER_CLOCK_KHZ / 1000;
last = read_timer();
while (tmo > 0) {
now = read_timer();
if (last >= now)
/* normal mode (non roll) */
tmo -= last - now;
else
/* we have overflow of the count down timer */
tmo -= TIMER_LOAD_VAL - last + now;
last = now;
}
}
int main()
{
uint32_t x;
DDRB = 1;
lcd_init();
start_timer();
delay_ms(950);
x = read_timer();
lcd_put_long(x);
return 0;
}
