int main(int argc, char *argv[])
{
SETUP_THE_NUMBERS;
TEARDOWN_THE_NUMBERS;
char *char_string = string("asdasd");
int c;
while ((c = getopt(argc, argv, "hv")) != -1) {
switch (c) {
case 'h':
print_help_message();
prepare_for_exit();
return EXIT_FAILURE;
case 'v':
print_licence_message();
prepare_for_exit();
return EXIT_FAILURE;
}
}
random_init();
set_signals();
init_windows();
init_modes();
loop();
prepare_for_exit();
free_memory();
return EXIT_SUCCESS;
}
int main (int argc, char **argv) {
if (argc != 4) {
print_help_message(argv);
exit(1);
}
int n, choice;
choice = atoi(argv[1]);
n = atoi(argv[2]);
validate_inputs(n, choice);
int *A;
A = (int *) malloc(n * sizeof(int));
assert(A != 0);
int input_type = atoi(argv[3]);
assert(input_type >= 0);
assert(input_type <= 4);
gen_input(A, n, input_type);
int num_iterations = 10;
sort_routines(choice, A, n, num_iterations);
//insertion_sort(A, n, num_iterations);
free(A);
return 0;
}
static int pmain(lua_State *L)
{
struct Smain *s = &smain;
char **argv = s->argv;
int script;
int flags = 0;
globalL = L;
if (argv[0] && argv[0][0]) progname = argv[0];
LUAJIT_VERSION_SYM(); /* linker-enforced version check */
script = collectargs(argv, &flags);
if (script < 0) { /* invalid args? */
print_usage();
s->status = 1;
return 0;
}
if ((flags & FLAGS_NOENV)) {
lua_pushboolean(L, 1);
lua_setfield(L, LUA_REGISTRYINDEX, "LUA_NOENV");
}
lua_gc(L, LUA_GCSTOP, 0); /* stop collector during initialization */
luaL_openlibs(L); /* open libraries */
gsl_shell_openlibs(L);
lua_gc(L, LUA_GCRESTART, -1);
dolibrary (L, "gslext");
s->keep_windows = 1;
if (!(flags & FLAGS_NOENV)) {
s->status = handle_luainit(L);
if (s->status != 0) return 0;
}
if (s->status != 0) return 0;
if ((flags & FLAGS_VERSION)) print_version();
s->status = runargs(L, argv, (script > 0) ? script : s->argc);
if (s->status != 0) return 0;
if (script) {
s->status = handle_script(L, argv, script);
if (s->status != 0) return 0;
}
if ((flags & FLAGS_INTERACTIVE)) {
print_jit_status(L);
dotty(L);
s->keep_windows = 0;
} else if (script == 0 && !(flags & (FLAGS_EXEC|FLAGS_VERSION))) {
if (lua_stdin_is_tty()) {
print_version();
print_jit_status(L);
print_help_message();
dotty(L);
s->keep_windows = 0;
} else {
dofile(L, NULL); /* executes stdin as a file */
}
}
return 0;
}
int main(int argc, char *argv[]) {
if (argc <= 1) {
print_help_message();
return 1;
}
char expanded[MAX_EXPANDED_SIZE];
expand(argv[1], expanded);
printf("%s\n", expanded);
return 0;
}
void
print_bad_usage_message (int rank)
{
if (rank) return;
if (bad_usage.optarg) {
fprintf(stderr, "%s [-%c %s]\n\n", bad_usage.message,
(char)bad_usage.opt, bad_usage.optarg);
}
else {
fprintf(stderr, "%s [-%c]\n\n", bad_usage.message,
(char)bad_usage.opt);
}
print_help_message(rank);
}
int
main (int argc, char *argv[])
{
int i, numprocs, rank, size;
int skip;
double latency = 0.0, t_start = 0.0, t_stop = 0.0;
double timer=0.0;
double avg_time = 0.0, max_time = 0.0, min_time = 0.0;
char * sendbuf = NULL, * recvbuf = NULL;
int po_ret;
size_t bufsize;
set_header(HEADER);
set_benchmark_name("osu_gather");
enable_accel_support();
po_ret = process_options(argc, argv);
if (po_okay == po_ret && none != options.accel) {
if (init_accel()) {
fprintf(stderr, "Error initializing device\n");
exit(EXIT_FAILURE);
}
}
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &numprocs);
switch (po_ret) {
case po_bad_usage:
print_bad_usage_message(rank);
MPI_Finalize();
exit(EXIT_FAILURE);
case po_help_message:
print_help_message(rank);
MPI_Finalize();
exit(EXIT_SUCCESS);
case po_version_message:
print_version_message(rank);
MPI_Finalize();
exit(EXIT_SUCCESS);
case po_okay:
break;
}
if(numprocs < 2) {
if (rank == 0) {
fprintf(stderr, "This test requires at least two processes\n");
}
MPI_Finalize();
exit(EXIT_FAILURE);
}
if ((options.max_message_size * numprocs) > options.max_mem_limit) {
options.max_message_size = options.max_mem_limit / numprocs;
}
if (0 == rank) {
bufsize = options.max_message_size * numprocs;
if (allocate_buffer((void**)&recvbuf, bufsize, options.accel)) {
fprintf(stderr, "Could Not Allocate Memory [rank %d]\n", rank);
MPI_Abort(MPI_COMM_WORLD, EXIT_FAILURE);
}
set_buffer(recvbuf, options.accel, 1, bufsize);
}
if (allocate_buffer((void**)&sendbuf, options.max_message_size,
options.accel)) {
fprintf(stderr, "Could Not Allocate Memory [rank %d]\n", rank);
MPI_Abort(MPI_COMM_WORLD, EXIT_FAILURE);
}
set_buffer(sendbuf, options.accel, 0, options.max_message_size);
print_preamble(rank);
for (size=1; size <= options.max_message_size; size *= 2) {
if (size > LARGE_MESSAGE_SIZE) {
skip = SKIP_LARGE;
options.iterations = options.iterations_large;
} else {
skip = SKIP;
}
MPI_Barrier(MPI_COMM_WORLD);
timer=0.0;
for (i=0; i < options.iterations + skip ; i++) {
t_start = MPI_Wtime();
MPI_Gather(sendbuf, size, MPI_CHAR, recvbuf, size, MPI_CHAR, 0,
MPI_COMM_WORLD);
t_stop = MPI_Wtime();
if (i >= skip) {
timer+=t_stop-t_start;
}
MPI_Barrier(MPI_COMM_WORLD);
}
latency = (double)(timer * 1e6) / options.iterations;
MPI_Reduce(&latency, &min_time, 1, MPI_DOUBLE, MPI_MIN, 0,
MPI_COMM_WORLD);
MPI_Reduce(&latency, &max_time, 1, MPI_DOUBLE, MPI_MAX, 0,
MPI_COMM_WORLD);
MPI_Reduce(&latency, &avg_time, 1, MPI_DOUBLE, MPI_SUM, 0,
MPI_COMM_WORLD);
avg_time = avg_time/numprocs;
print_stats(rank, size, avg_time, min_time, max_time);
MPI_Barrier(MPI_COMM_WORLD);
}
if (0 == rank) {
free_buffer(recvbuf, options.accel);
}
free_buffer(sendbuf, options.accel);
MPI_Finalize();
if (none != options.accel) {
if (cleanup_accel()) {
fprintf(stderr, "Error cleaning up device\n");
exit(EXIT_FAILURE);
}
}
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
setbuf(stdout, NULL);
int i = 0, rank, size, disp;
int numprocs;
double latency = 0.0, t_start = 0.0, t_stop = 0.0;
double tcomp = 0.0, tcomp_total=0.0, latency_in_secs=0.0;
double test_time = 0.0, test_total = 0.0;
double timer=0.0;
double wait_time = 0.0, init_time = 0.0;
double init_total = 0.0, wait_total = 0.0;
char *sendbuf=NULL;
char *recvbuf=NULL;
int *sdispls=NULL, *sendcounts=NULL;
int po_ret;
size_t bufsize;
set_header(HEADER);
set_benchmark_name("osu_iscatterv");
enable_accel_support();
po_ret = process_options(argc, argv);
if (po_okay == po_ret && none != options.accel) {
if (init_accel()) {
fprintf(stderr, "Error initializing device\n");
exit(EXIT_FAILURE);
}
}
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &numprocs);
MPI_Request request;
MPI_Status status;
switch (po_ret) {
case po_bad_usage:
print_bad_usage_message(rank);
MPI_Finalize();
exit(EXIT_FAILURE);
case po_help_message:
print_help_message(rank);
MPI_Finalize();
exit(EXIT_SUCCESS);
case po_version_message:
print_version_message(rank);
MPI_Finalize();
exit(EXIT_SUCCESS);
case po_okay:
break;
}
if(numprocs < 2) {
if (rank == 0) {
fprintf(stderr, "This test requires at least two processes\n");
}
MPI_Finalize();
exit(EXIT_FAILURE);
}
if ((options.max_message_size * numprocs) > options.max_mem_limit) {
options.max_message_size = options.max_mem_limit / numprocs;
}
if (0 == rank) {
if (allocate_buffer((void**)&sendcounts, numprocs*sizeof(int), none)) {
fprintf(stderr, "Could Not Allocate Memory [rank %d]\n", rank);
MPI_Abort(MPI_COMM_WORLD, EXIT_FAILURE);
}
if (allocate_buffer((void**)&sdispls, numprocs*sizeof(int), none)) {
fprintf(stderr, "Could Not Allocate Memory [rank %d]\n", rank);
MPI_Abort(MPI_COMM_WORLD, EXIT_FAILURE);
}
bufsize = options.max_message_size * numprocs;
if (allocate_buffer((void**)&sendbuf, bufsize, options.accel)) {
fprintf(stderr, "Could Not Allocate Memory [rank %d]\n", rank);
MPI_Abort(MPI_COMM_WORLD, EXIT_FAILURE);
}
set_buffer(sendbuf, options.accel, 1, bufsize);
}
if (allocate_buffer((void**)&recvbuf, options.max_message_size,
options.accel)) {
fprintf(stderr, "Could Not Allocate Memory [rank %d]\n", rank);
MPI_Abort(MPI_COMM_WORLD, EXIT_FAILURE);
}
set_buffer(recvbuf, options.accel, 0, options.max_message_size);
print_preamble_nbc(rank);
for(size=options.min_message_size; size <=options.max_message_size; size *= 2) {
if(size > LARGE_MESSAGE_SIZE) {
options.skip = SKIP_LARGE;
options.iterations = options.iterations_large;
}
else {
options.skip = SKIP;
}
if (0 == rank) {
disp =0;
for ( i = 0; i < numprocs; i++) {
sendcounts[i] = size;
sdispls[i] = disp;
disp += size;
}
}
MPI_Barrier(MPI_COMM_WORLD);
timer = 0.0;
for(i=0; i < options.iterations + options.skip ; i++) {
t_start = MPI_Wtime();
MPI_Iscatterv(sendbuf, sendcounts, sdispls, MPI_CHAR, recvbuf,
size, MPI_CHAR, 0, MPI_COMM_WORLD, &request);
MPI_Wait(&request,&status);
t_stop = MPI_Wtime();
if(i>=options.skip){
timer += t_stop-t_start;
}
MPI_Barrier(MPI_COMM_WORLD);
}
MPI_Barrier(MPI_COMM_WORLD);
latency = (timer * 1e6) / options.iterations;
latency_in_secs = timer/options.iterations;
init_arrays(latency_in_secs);
if (0 == rank) {
disp =0;
for ( i = 0; i < numprocs; i++) {
sendcounts[i] = size;
sdispls[i] = disp;
disp += size;
}
}
MPI_Barrier(MPI_COMM_WORLD);
timer = 0.0; tcomp_total = 0; tcomp = 0;
init_total = 0.0; wait_total = 0.0;
test_time = 0.0, test_total = 0.0;
for(i=0; i < options.iterations + options.skip ; i++) {
t_start = MPI_Wtime();
init_time = MPI_Wtime();
MPI_Iscatterv(sendbuf, sendcounts, sdispls, MPI_CHAR, recvbuf,
size, MPI_CHAR, 0, MPI_COMM_WORLD, &request);
init_time = MPI_Wtime() - init_time;
tcomp = MPI_Wtime();
test_time = dummy_compute(latency_in_secs, &request);
tcomp = MPI_Wtime() - tcomp;
wait_time = MPI_Wtime();
MPI_Wait(&request,&status);
wait_time = MPI_Wtime() - wait_time;
t_stop = MPI_Wtime();
if(i>=options.skip){
timer += t_stop-t_start;
tcomp_total += tcomp;
test_total += test_time;
init_total += init_time;
wait_total += wait_time;
}
MPI_Barrier(MPI_COMM_WORLD);
}
MPI_Barrier (MPI_COMM_WORLD);
calculate_and_print_stats(rank, size, numprocs,
timer, latency,
test_total, tcomp_total,
wait_total, init_total);
}
if (0 == rank) {
free_buffer(sendcounts, none);
free_buffer(sdispls, none);
free_buffer(sendbuf, options.accel);
}
free_buffer(recvbuf, options.accel);
MPI_Finalize();
if (none != options.accel) {
if (cleanup_accel()) {
fprintf(stderr, "Error cleaning up device\n");
exit(EXIT_FAILURE);
}
}
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
int i, j, numprocs, rank, size;
double latency = 0.0, t_start = 0.0, t_stop = 0.0;
double timer=0.0;
double avg_time = 0.0, max_time = 0.0, min_time = 0.0;
float *sendbuf, *recvbuf;
int po_ret;
size_t bufsize;
int64_t* problems = all_reduce_kernels_size;
int64_t* numRepeats = all_reduce_kernels_repeat;
set_header(HEADER);
#ifdef ENABLE_MLSL
mlsl_comm_req request;
set_benchmark_name("mlsl_osu_allreduce");
#else
set_benchmark_name("osu_allreduce");
#endif
enable_accel_support();
po_ret = process_options(argc, argv);
if (po_okay == po_ret && none != options.accel) {
if (init_accel()) {
fprintf(stderr, "Error initializing device\n");
exit(EXIT_FAILURE);
}
}
#ifdef ENABLE_MLSL
MLSL_CALL(mlsl_environment_get_env(&env));
MLSL_CALL(mlsl_environment_init(env, &argc, &argv));
size_t process_idx, process_count;
MLSL_CALL(mlsl_environment_get_process_idx(env, &process_idx));
MLSL_CALL(mlsl_environment_get_process_count(env, &process_count));
rank = process_idx;
numprocs = process_count;
MLSL_CALL(mlsl_environment_create_distribution(env, process_count, 1, &distribution));
#else
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &numprocs);
#endif
switch (po_ret) {
case po_bad_usage:
print_bad_usage_message(rank);
FINALIZE();
exit(EXIT_FAILURE);
case po_help_message:
print_help_message(rank);
FINALIZE();
exit(EXIT_SUCCESS);
case po_version_message:
print_version_message(rank);
FINALIZE();
exit(EXIT_SUCCESS);
case po_okay:
break;
}
if(numprocs < 2) {
if (rank == 0) {
fprintf(stderr, "This test requires at least two processes\n");
}
FINALIZE();
exit(EXIT_FAILURE);
}
if (options.max_message_size > options.max_mem_limit) {
options.max_message_size = options.max_mem_limit;
}
bufsize = sizeof(float)*(options.max_message_size/sizeof(float));
if (allocate_buffer((void**)&sendbuf, bufsize, options.accel)) {
fprintf(stderr, "Could Not Allocate Memory [rank %d]\n", rank);
MPI_Abort(MPI_COMM_WORLD, EXIT_FAILURE);
}
set_buffer(sendbuf, options.accel, 1, bufsize);
bufsize = sizeof(float)*(options.max_message_size/sizeof(float));
if (allocate_buffer((void**)&recvbuf, bufsize, options.accel)) {
fprintf(stderr, "Could Not Allocate Memory [rank %d]\n", rank);
MPI_Abort(MPI_COMM_WORLD, EXIT_FAILURE);
}
set_buffer(recvbuf, options.accel, 0, bufsize);
print_preamble(rank, numprocs);
size = options.max_message_size/sizeof(float);
for (j = 0; j < _NUMBER_OF_KERNELS_; j++)
{
size = problems[j];
options.iterations = numRepeats[j];
MPI_Barrier(MPI_COMM_WORLD);
timer = 0.0;
t_start = MPI_Wtime();
for(i=0; i < options.iterations; i++) {
#ifdef ENABLE_MLSL
MLSL_CALL(mlsl_distribution_all_reduce(distribution, sendbuf, recvbuf, size, DT_FLOAT, RT_SUM, GT_DATA, &request));
MLSL_CALL(mlsl_environment_wait(env, request));
#else
MPI_Allreduce(sendbuf, recvbuf, size, MPI_FLOAT, MPI_SUM, MPI_COMM_WORLD);
#endif
}
t_stop = MPI_Wtime();
timer = t_stop-t_start;
latency = (double)(timer * 1e3) / options.iterations;
MPI_Reduce(&latency, &min_time, 1, MPI_DOUBLE, MPI_MIN, 0,
MPI_COMM_WORLD);
MPI_Reduce(&latency, &max_time, 1, MPI_DOUBLE, MPI_MAX, 0,
MPI_COMM_WORLD);
MPI_Reduce(&latency, &avg_time, 1, MPI_DOUBLE, MPI_SUM, 0,
MPI_COMM_WORLD);
avg_time = avg_time/numprocs;
print_stats(rank, size, avg_time, min_time, max_time);
MPI_Barrier(MPI_COMM_WORLD);
}
free_buffer(sendbuf, options.accel);
free_buffer(recvbuf, options.accel);
FINALIZE();
if (none != options.accel) {
if (cleanup_accel()) {
fprintf(stderr, "Error cleaning up device\n");
exit(EXIT_FAILURE);
}
}
return EXIT_SUCCESS;
}
/**
* @brief This method runs when the 'task_user' is called.
*
* @details This method runs inifitely when the task is called so all logic
* is contained in here. A for(;;) loop runs until it gets to the
* end where it delays for 1 ms to allow other lower level
* priority tasks a chance to run.
*/
void task_user::run (void)
{
time_stamp a_time; // Holds the time so it can be displayed
number_entered = 0; // Holds a number being entered by user
//
for (;;)
{
switch (state)
{
// Initialize first task where we wait for
case (0):
printMainMenu();
// If the user typed a character, read
if (hasUserInput())
{
// In this switch statement, we respond to different characters as commands typed in by the user
switch (char_in)
{
// The 't' command asks what time it is right now
case ('m'):
*p_serial << PMS("->Selected: ") << char_in;
*p_serial
<< endl
<< endl
<< PMS ("\t->Switching to Motor Module..")
<< endl
<< PMS ("\t->Clearing Registers and Menus..")
<< endl
<< PMS ("\t->Intializing Motors..")
<< endl;
// Reset the visible menu flag
resetMenus();
// Sets the variable to true so it doesn't go into single module yet
in_main_motor_module = true;
// go to case 1 over all
transition_to(1);
break;
// Enter encoder test module
case ('e'):
*p_serial << PMS("->Selected: ") << char_in;
*p_serial
<< ATERM_CLEAR_SCREEN << ATERM_CURSOR_TO_YX(1, 1)
<< PMS ("\t->Switching to Encoder Module..")
<< endl
<< PMS ("\t->Clearing Registers and Menus..")
<< endl
<< PMS ("\t->Intializing Encoder..")
<< endl << endl;
// Reset the visible menu flag
resetMenus();
// Sets the variable to true so it doesn't go into single module yet
in_encoder_module = true;
// go to case 1 over all
transition_to(3);
break;
// The 't' command asks what time it is right now
// Enter encoder test module
case ('i'):
*p_serial << PMS("->Selected: ") << char_in;
*p_serial
<< ATERM_CLEAR_SCREEN << ATERM_CURSOR_TO_YX(1, 1)
<< PMS ("\t->Switching to IMU Module..")
<< endl
<< PMS ("\t->Clearing Registers and Menus..")
<< endl
<< PMS ("\t->Intializing IMU..")
<< endl << endl;
// Reset the visible menu flag
resetMenus();
// Sets the variable to true so it doesn't go into single module yet
in_imu_module = true;
// go to case 1 over all
transition_to(4);
break;
// The 't' command asks what time it is right now
case ('t'):
*p_serial << (a_time.set_to_now ()) << endl;
break;
// The 's' command asks for version and status information
case ('s'):
show_status ();
break;
// The 'd' means drive control
case ('d'):
*p_serial << PMS("->Selected: ") << char_in;
*p_serial
<< ATERM_CLEAR_SCREEN << ATERM_CURSOR_TO_YX(1, 1)
<< PMS ("\t->Switching to Drive Mode..")
<< endl << endl;
transition_to(5);
in_drive_mode = true;
resetMenus();
break;
//case ('d'):
// The 'h' command is a plea for help; '?' works also
case ('h'):
case ('?'):
print_help_message ();
break;
// The 'n' command runs a test of entering a number
case ('n'):
while (char_in != 'q')
{
*p_serial << PMS ("Enter decimal numeric digits, "
"then RETURN or ESC") << endl;
getNumberInput();
*p_serial << endl << endl << PMS("\t->You Entered: ") << number_entered << endl;
}
break;
// A control-C character causes the CPU to restart
case (3):
*p_serial << PMS ("Resetting AVR") << endl;
wdt_enable (WDTO_120MS);
for (;;);
break;
// If character isn't recognized, ask What's That Function?
default:
*p_serial << '"' << char_in << PMS ("\": WTF?") << endl;
break;
}; // End switch for characters
} // End if a character was received
break; // End of state 0
// Motor Control BASE module
case (1):
if (in_main_motor_module) //first time here run menu and get input
{
// prints the menu for this module
printMotorMenu();
// user is going to input motor number or q
getNumberInput();
if (char_in == 'q')
{
*p_serial << PMS("->Selected: ") << char_in << endl
<< endl
<< endl
<< PMS("\t->Returning to Mission Control.. ")
<< endl
<< PMS("\t->Releasing Motors..") << endl
<< PMS("\t->Resetting AVR..") << endl;
//wdt_enable (WDTO_120MS);
//for (;;);
//break;
//release motors
//motor_select->put(1);
//motor_directive -> put(FREEWHEEL);
//
// no longer in this module, leaving
in_main_motor_module = false;
transition_to(0);
resetMenus();
break;
//reset menu flag
//resetMenus();
// set the transition & wait for break
//transition_to(0);
}
// if the number entered is valid
else if (isValidMotor(number_entered))
{
// re print user input and give them confirmation message.
*p_serial
<< endl
<< endl
<< PMS("\t->Switching to Control of Motor ") << number_entered << dec << PMS(".") << endl
<< PMS ("\t->Return to the Main Motor Module to swap Motors.") << endl;
// set local motor select value
local_motor_select = number_entered;
//reset menus
resetMenus();
//set flag to off so we can go into the single motor module
in_main_motor_module = false;
// go back to the top of this menu
// since in_main_motor_module flag is set off, we will go into single motor control when this state reloops
transition_to(1);
}
else
{
*p_serial << PMS("Try Again. ") << endl;
in_main_motor_module = true;
}
break;
}
if (!in_main_motor_module) //already were here now we go deeper
{
printSingleMotorOptions();
// They now select the motor task
if (hasUserInput())
{
switch (char_in)
{
case ('s'):
*p_serial
<< PMS("->Selected: ") << char_in << endl;
*p_serial
<< endl
<< PMS ("Enter the Power Value (-255 to 255);")
<< endl
<< PMS(" *Note: Negative Values = Reverse")
<< endl;
//motor_directive -> put(1);
getNumberInput();
//setPower(motor_select->get(), number_entered);
setMotor(local_motor_select, (int16_t)number_entered, SETPOWER);
*p_serial
<< endl << endl
<< PMS ("\tPower set at ") << number_entered
<< PMS(". ") << endl;
resetMenus();
printDashBoard();
//now that operation is complete, ask for more
*p_serial
<< endl << PMS("->Choose Motor ")
<< local_motor_select << PMS(" operation: ")
<< PMS("\t(Press 'o' for options)")
<< endl;
break;
case ('b'):
*p_serial
<< PMS("->Selected: ") << char_in
<< endl;
*p_serial
<< PMS ("\t->Enter the Brake Force(0 - 255)")
<< endl;
getNumberInput();
*p_serial
<< endl << endl
<< PMS ("\tBrake set at ") << number_entered
<< PMS(". ") << endl;
setMotor(local_motor_select, number_entered, BRAKE);
resetMenus();
printDashBoard();
//now that operation is complete, ask for more
*p_serial
<< endl << PMS("->Choose Motor ")
<< local_motor_select << PMS(" operation: ")
<< PMS("\t(Press 'o' for options)")
<< endl;
break;
case ('f'):
*p_serial
<< PMS("->Selected: ") << char_in << endl;
*p_serial
<< PMS ("\t->Releasing Motor..") << endl;
setMotor(0, 0, FREEWHEEL);
resetMenus();
printDashBoard();
//now that operation is complete, ask for more
*p_serial
<< endl << PMS("->Choose Motor ")
<< local_motor_select << PMS(" operation: ")
<< PMS("\t(Press 'o' for options)")
<< endl;
break;
case ('p'):
*p_serial
<< endl << PMS("->Selected: ")
<< char_in << endl
<< PMS("\t->Entering Potentiometer Control... ") << endl;
*p_serial << PMS ("\t->Potentiometer Activated.") << endl << endl;
*p_serial << endl << endl
<< PMS ("\t->Press 'q' to return to the Motor ") << local_motor_select << PMS(" Control")
<< endl << PMS ("\t->Press 'r' to refresh the DashBoard ") << endl;
transition_to(2);
resetMenus();
break;
case ('o'):
resetMenus();
printSingleMotorOptions();
break;
case ('q'):
*p_serial
<< PMS("->Selected: ") << char_in << endl
<< PMS(" Returning to Main Motor Module.. ")
<< endl;
transition_to(1);
resetMenus();
in_main_motor_module = true;
break;
default:
*p_serial
<< endl << PMS("'") << char_in
<< PMS ("' is not a valid entry.") << endl;
*p_serial
<< endl << PMS("->Choose Motor ")
<< local_motor_select
<< PMS(" operation: ") << endl;
break;
}
}
}
break;
//Potentiometer Mode
case (2):
if (hasUserInput())
{
if (char_in == 'q')
{
*p_serial << endl << PMS("->Selected: ") << char_in << endl;
transition_to(1);
resetMenus();
break;
//
}
if (char_in == 'r')
{
*p_serial << endl << PMS("->Selected: ") << char_in << endl;
resetMenus();
printDashBoard();
*p_serial << endl << endl
<< PMS ("\t->Press 'q' to return to the Motor ") << local_motor_select << PMS(" Control")
<< endl << PMS ("\t->Press 'r' to refresh the DashBoard ") << endl;
}
}
setMotor(local_motor_select, motor_power -> get(), POTENTIOMETER);
printDashBoard();
break;
//for use later [3,4]
case (3):
if (in_encoder_module)
{
printEncoderModuleOptions();
if (hasUserInput())
switch (char_in)
{
case ('q'):
*p_serial << ATERM_CLEAR_SCREEN << ATERM_BKG_WHITE
<< PMS("->Selected: ") << char_in << endl
<< endl
<< endl
<< PMS("\t->Returning to Mission Control.. ")
<< endl
<< PMS("\t->Releasing Encoder..") << endl;
transition_to(0);
in_main_motor_module = true;
in_encoder_module = false;
resetMenus();
*p_serial
<< ATERM_CLEAR_SCREEN
<< ATERM_CURSOR_TO_YX(1, 1) << endl;
break;
case ('r'):
//constant refreshing already
transition_to(1)
in_imu_module = true;
break;
default:
break;
}
}
break;
case (4):
if (in_imu_module)
{
printIMUModuleOptions();
if (hasUserInput())
switch (char_in)
{
case ('q'):
*p_serial << ATERM_CLEAR_SCREEN
<< PMS("->Selected: ") << char_in << endl
<< endl
<< endl
<< PMS("\t->Returning to Mission Control.. ")
<< endl
<< PMS("\t->Releasing IMU..") << endl;
transition_to(0);
in_imu_module = false;
resetMenus();
break;
default:
break;
*p_serial << ATERM_CLEAR_SCREEN;
}
case ('r'):
break;
default:
break;
}
}
break;
// Drive Mode
case (5):
if (in_drive_mode)
{
printDriveModeOptions();
// printDashBoard();
if (hasUserInput())
switch (char_in)
{
case ('q'):
*p_serial << ATERM_CLEAR_SCREEN
<< PMS("->Selected: ") << char_in << endl
<< endl
<< endl
<< PMS("\t->Returning to Mission Control.. ")
<< endl
<< PMS("\t->Releasing Drive Mode..") << endl;
transition_to(0);
in_drive_mode = false;
resetMenus();
break;
case ('s'):
*p_serial << endl
<< PMS("Input Power Value for Motor: ")
<< endl;
getNumberInput();
setMotor(0, (int16_t)number_entered, SETPOWER);
*p_serial
<< endl << endl
<< PMS ("\tPower set at ") << number_entered
<< PMS (". ") << endl << endl
<< PMS ("Printing DashBoard.. ") << endl
<< endl;
resetMenus();
printDashBoard();
break;
case ('r'):
*p_serial
<< PMS ("Printing DashBoard.. ")
<< endl
<< endl;
resetMenus();
printDashBoard();
break;
default:
break;
}
int16_t x_direction = y_joystick -> get();
int16_t map_x = x_direction - 526;
if (x_direction > 526)
{
map_x = 2 * (x_direction - 526);
}
else
{
map_x = -2 * (526 - x_direction);
}
motor_setpoint -> put(map_x);
motor_directive -> put(SETPOWER);
// *p_serial
// << ATERM_CURSOR_TO_YX(19, 1)
// << ATERM_ERASE_IN_LINE(0)
// << gear_state -> get()
// << PMS ("\t\t")
// << motor_setpoint -> get()
// << PMS("\t")
// << PMS("\t")
// << motor_power -> get()
// << PMS("\t")
// << PMS("\t")
// << encoder_count -> get()
// << PMS("\t")
// << ATERM_CURSOR_TO_YX(23, 1)
// << ATERM_ERASE_IN_LINE(0)
// << steering_power -> get()
// << PMS(" \t")
// << encoder_ticks_per_task -> get()
// << PMS("\t")
// << PMS("\t")
// << x_joystick -> get()
// << PMS("\t")
// << PMS("\t")
// << y_joystick -> get()
// << PMS("\t");
*p_serial << encoder_ticks_per_task -> get() << endl;
}
break;
//JoyStick test
case (6):
break;
default:
*p_serial << PMS ("Illegal state! Resetting AVR") << endl;
wdt_enable (WDTO_120MS);
for (;;);
break;
} // End switch state
runs++; // Increment counter for debugging
// No matter the state, wait for approximately a millisecond before we
// run the loop again. This gives lower priority tasks a chance to run
delay_ms (5);
}
int main(int argc, char *argv[])
{
int i = 0, rank;
int numprocs;
double avg_time = 0.0, max_time = 0.0, min_time = 0.0;
double latency = 0.0, t_start = 0.0, t_stop = 0.0;
double timer=0.0;
int po_ret;
set_header(HEADER);
set_benchmark_name("osu_barrier");
enable_accel_support();
po_ret = process_options(argc, argv);
if (po_okay == po_ret && none != options.accel) {
if (init_accel()) {
fprintf(stderr, "Error initializing device\n");
exit(EXIT_FAILURE);
}
}
options.show_size = 0;
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &numprocs);
switch (po_ret) {
case po_bad_usage:
print_bad_usage_message(rank);
MPI_Finalize();
exit(EXIT_FAILURE);
case po_help_message:
print_help_message(rank);
MPI_Finalize();
exit(EXIT_SUCCESS);
case po_version_message:
print_version_message(rank);
MPI_Finalize();
exit(EXIT_SUCCESS);
case po_okay:
break;
}
if(numprocs < 2) {
if(rank == 0) {
fprintf(stderr, "This test requires at least two processes\n");
}
MPI_Finalize();
return EXIT_FAILURE;
}
print_preamble(rank);
options.skip = options.skip_large;
options.iterations = options.iterations_large;
timer = 0.0;
for(i=0; i < options.iterations + options.skip ; i++) {
t_start = MPI_Wtime();
MPI_Barrier(MPI_COMM_WORLD);
t_stop = MPI_Wtime();
if(i>=options.skip){
timer+=t_stop-t_start;
}
}
MPI_Barrier(MPI_COMM_WORLD);
latency = (timer * 1e6) / options.iterations;
MPI_Reduce(&latency, &min_time, 1, MPI_DOUBLE, MPI_MIN, 0,
MPI_COMM_WORLD);
MPI_Reduce(&latency, &max_time, 1, MPI_DOUBLE, MPI_MAX, 0,
MPI_COMM_WORLD);
MPI_Reduce(&latency, &avg_time, 1, MPI_DOUBLE, MPI_SUM, 0,
MPI_COMM_WORLD);
avg_time = avg_time/numprocs;
print_stats(rank, 0, avg_time, min_time, max_time);
MPI_Finalize();
return EXIT_SUCCESS;
}
/* Parse arguments from command-line
Arguments:
int argc number of command-line arguments
char **argv array of command-line arguments
int rank process id
char *task_file pointer to task file buffer
bool *verbose pointer to verbose flag
bool *wait_on_idle pointer to wait flag
bool *retry pointer to retry flag
int *sleep_time pointer to sleep duration variable
int *max_retries pointer to maximum retries variable
*/
void parse_command_line_arguments(int argc, char **argv, int rank, char *task_file,
bool *verbose, bool *wait_on_idle, bool* retry, int *sleep_time, int *max_retries)
{
int i = 1;
bool file;
if (argc < 2)
{
if (rank == 0)
{
print_help_message();
}
MPI_Finalize();
exit(0);
}
else
{
if (argc == 2)
{
if (strcmp(argv[1],"-h") == 0 || strcmp(argv[1],"--help") == 0)
{
if (rank == 0)
{
print_help_message();
}
MPI_Finalize();
exit(0);
}
}
else
{
while (i < argc)
{
if (strcmp(argv[i],"-f") == 0 || strcmp(argv[i],"--file") == 0)
{
i++;
file = true;
strcpy(task_file, argv[i]);
}
else if (strcmp(argv[i],"-v") == 0 || strcmp(argv[i],"--verbose") == 0)
{
*verbose = true;
}
else if (strcmp(argv[i],"-w") == 0 || strcmp(argv[i],"--wait-on-idle") == 0)
{
*wait_on_idle = true;
}
else if (strcmp(argv[i],"-r") == 0 || strcmp(argv[i],"--retry") == 0)
{
*retry = true;
}
else if (strcmp(argv[i],"-s") == 0 || strcmp(argv[i],"--sleep-time") == 0)
{
i++;
*sleep_time = atof(argv[i]);
}
else if (strcmp(argv[i],"-m") == 0 || strcmp(argv[i],"--max-retries") == 0)
{
i++;
*max_retries = atof(argv[i]);
}
else if (strcmp(argv[i],"-h") == 0 || strcmp(argv[i],"--help") == 0)
{
if (rank == 0)
{
print_help_message();
}
MPI_Finalize();
exit(0);
}
else
{
if (rank == 0)
{
fprintf(stderr, "[ERROR]: Unknown command-line option %s\n", argv[i]);
fprintf(stderr, "For help run \"taskfarmer -h\"\n");
}
MPI_Finalize();
exit(1);
}
i++;
}
}
}
if (!file)
{
if (rank == 0)
{
fprintf(stderr, "[ERROR]: A task file must be specified with \"-f/--file\"\n");
fprintf(stderr, "For help run \"taskfarmer -h\"\n");
}
MPI_Finalize();
exit(1);
}
// only attempt to launch tasks once if retry option is unset
if (!*retry) *max_retries = 1;
else
{
// make sure number of retries is a positive, non-zero integer
if (*max_retries <= 0)
{
if (rank == 0)
{
fprintf(stderr, "[ERROR]: Maximum number of retries must be greater than zero!\n");
}
MPI_Finalize();
exit(1);
}
}
if (*wait_on_idle)
{
// make sure sleep time is a positive, non-zero integer
if (*sleep_time <= 0)
{
if (rank == 0)
{
fprintf(stderr, "[ERROR]: Sleep time must be greater than zero!\n");
}
MPI_Finalize();
exit(1);
}
}
}
char *handle_arguments(int argc, char *argv[], char **f1, char **f2, int *arg_mode)
{
int i, c, indexptr;
/* Value to return: */
static char *delimiter = NULL;
while ((c = getopt_long(argc, argv, "123", long_options, &indexptr)) != -1)
{
switch (c)
{
case '1':
/* Don't print 1st column. */
*arg_mode |= NO_C1;
break;
case '2':
/* Don't print 2nd column. */
*arg_mode |= NO_C2;
break;
case '3':
/* Don't print 3rd column. */
*arg_mode |= NO_C3;
break;
case 't':
/* Trim blanks from an end of lines. */
*arg_mode |= TRIM;
break;
case 's':
/* Suppress warnings. */
*arg_mode |= NO_WARN;
opterr = 0;
break;
case 'd':
/* Take delimiter argument. */
delimiter = optarg;
break;
case 'v':
/* Print version and other information and exit. */
print_version();
break;
case 'h':
/* Print help message and exit. */
print_help_message();
break;
case '?':
/* Some error in parsing arguments occurred
e.g., missing argument or unknown switch.
Do nothing. getopt_long() will print the
error on it's own if NO_WARN flag is not set. */
break;
default:
/* Something totaly unexpected. */
abort();
break;
}
} /* end of WHILE loop */
/* Look for non-switch arguments.
Two valid file names expected */
for (i = optind; i < argc; i++)
{
if (*f1 == NULL)
*f1 = argv[i];
else if (*f2 == NULL)
*f2 = argv[i];
else
break;
}
return delimiter;
}
int main (int argc, char *argv[])
{
SYNC sync_type=FLUSH;
int rank,nprocs;
int page_size;
int po_ret = po_okay;
WINDOW win_type=WIN_ALLOCATE;
MPI_CHECK(MPI_Init(&argc, &argv));
MPI_CHECK(MPI_Comm_size(MPI_COMM_WORLD, &nprocs));
MPI_CHECK(MPI_Comm_rank(MPI_COMM_WORLD, &rank));
if(nprocs != 2) {
if(rank == 0) {
fprintf(stderr, "This test requires exactly two processes\n");
}
MPI_CHECK(MPI_Finalize());
return EXIT_FAILURE;
}
po_ret = process_options(argc, argv, &win_type, &sync_type, rank);
switch (po_ret) {
case po_bad_usage:
print_help_message(rank);
MPI_CHECK(MPI_Finalize());
return EXIT_FAILURE;
case po_help_message:
print_help_message(rank);
MPI_CHECK(MPI_Finalize());
return EXIT_SUCCESS;
}
page_size = getpagesize();
assert(page_size <= MAX_ALIGNMENT);
sbuf =
(char *) (((unsigned long) sbuf_original + (page_size - 1)) /
page_size * page_size);
memset(sbuf, 0, MAX_SIZE);
rbuf =
(char *) (((unsigned long) rbuf_original + (page_size - 1)) /
page_size * page_size);
memset(rbuf, 0, MAX_SIZE);
cbuf =
(char *) (((unsigned long) cbuf_original + (page_size - 1)) /
page_size * page_size);
memset(cbuf, 0, MAX_SIZE);
print_header(rank, win_type, sync_type);
switch (sync_type){
case LOCK:
run_get_acc_with_lock(rank, win_type);
break;
case LOCK_ALL:
run_get_acc_with_lock_all(rank, win_type);
break;
case PSCW:
run_get_acc_with_pscw(rank, win_type);
break;
case FLUSH_LOCAL:
run_get_acc_with_flush_local(rank, win_type);
break;
case FENCE:
run_get_acc_with_fence(rank, win_type);
break;
default:
run_get_acc_with_flush(rank, win_type);
break;
}
MPI_CHECK(MPI_Finalize());
return EXIT_SUCCESS;
}
/// parse command line options
// ==============================================================
void read_parameters(int argc, char** argv)
// ==============================================================
{
params_good = true;
make_matrices = false;
sensitivity = .75;
num_of_opts = 0;
max_line_length=50.;
int i;
for (i=1; i<argc && argv[i][0]=='-'; i++)
{
num_of_opts++;
switch (argv[i][1])
{
case '-' : {
read_long_parameter(argc,argv,i);
break;
}
case 's' : {
if (strlen(argv[i])>3)
{
throw bbq_exception(std::string("Unknown option: ")+std::string(argv[i])+std::string("\n"));
}
if (i+1<argc)
{
if (argc<=i+1 || !is_flt(argv[i+1]))
{
throw bbq_exception("expected float specifying sensitivity.\n");
}
sensitivity = atof(argv[i+1]);
i++;
num_of_opts++;
} else {
params_good = false;
}
break;
}
case 'L' : {
if (strlen(argv[i])>3)
{
throw bbq_exception(std::string("Unknown option: ")+std::string(argv[i])+std::string("\n"));
}
if (i+1<argc)
{
if (argc<=i+1 || !is_flt(argv[i+1]))
{
throw bbq_exception("expected float specifying line length scale factor\n (in percent, i.e., default is -L 100).\n");
}
max_line_length = atof(argv[i+1])/2.;
i++;
num_of_opts++;
} else {
params_good = false;
}
break;
}
case 'm' : {
if (strlen(argv[i])>3)
{
throw bbq_exception(std::string("Unknown option: ")+std::string(argv[i])+std::string("\n"));
}
make_matrices = true;
break;
}
case 'h' : {
print_help_message();
exit(0);
}
}
}
}