6.1 Sequential versions with 2 compilers

We will begin by illustrating that the same code file for vector addition can be compiled and run by different C compilers: gcc and pgcc. All of the examples in this chapter use the same functions for gathering command line arguments and for utility functions that initialize the vectors, print them, and check for correct results. These are in separate files in the code on the repository and are shown in code blocks below whose run button is disabled.

Note

The OpenACC compiler, pgcc, uses the .c suffix, because code files are treated as C code files that can be compiled with a C compiler. Though the pgcc compiler is creating CUDA code behind the scenes for versions that will run on the GPU, we now think of OpenACC code files as C code files with pragmas, much like OpenMP.

Command line argument handling

files: utils/getCommandLine.h, utils.getCommandLine.c

The following code block contains the functions for gathering the command line arguments for our vector addition program. It uses a C library function call getopt(), which enables us to use syntax like this when executing this from the command line on your own machine:

./vectorAdd -n 1024 -t 4

The getopt() function is used on line 19 below. If you have not used this before, you should be able to find tutorials on the web for it.

#include <stdio.h> #include <unistd.h> #include <stdlib.h> #include <ctype.h> void getArguments(int argc, char *argv[], int * n, int *numThreads); int isNumber(char s[]); void exitWithError(char cmdFlag, char ** argv); void Usage(char *program); void getArguments(int argc, char *argv[], int * n, int *numThreads) { char *nvalue; // number of elements char *numThreads_value; int c; // result from getopt calls while ((c = getopt (argc, argv, "n:t:")) != -1) { switch (c) { case 'n': if (isNumber(optarg)) { nvalue = optarg; *n = atoi(nvalue); } else { exitWithError(c, argv); } break; case 't': if (isNumber(optarg)) { numThreads_value = optarg; *numThreads = atoi(numThreads_value); } else { exitWithError(c, argv); } break; case ':': printf("Missing arg for %c\n", optopt); Usage(argv[0]); exit(EXIT_FAILURE); break; case '?': if (isprint (optopt)) { fprintf (stderr, "Unknown option `-%c'.\n", optopt); Usage(argv[0]); exit(EXIT_FAILURE); } else { fprintf (stderr, "Unknown non-printable option character `\\x%x'.\n", optopt); Usage(argv[0]); exit(EXIT_FAILURE); } break; } } } int isNumber(char s[]) { for (int i = 0; s[i]!= '\0'; i++) { if (isdigit(s[i]) == 0) return 0; } return 1; } void exitWithError(char cmdFlag, char ** argv) { fprintf(stderr, "Option -%c needs a number value\n", cmdFlag); Usage(argv[0]); exit(EXIT_FAILURE); } void Usage(char *program) { fprintf(stderr, "Usage: %s [-n numElements] [-t numThreads]\n", program); }

Helper functions used by each example

The following functions are used for each different main program function that you find here and in the sections following this one.

files: utils/helper_add.h

/* * Functions for setting up arrays and error checking */ #include <stdio.h> #include <math.h> // To reset the arrays for each trial void initialize(float *x, float *y, int N) { // initialize x and y arrays on the host for (int i = 0; i < N; i++) { x[i] = 1.0f; y[i] = 2.0f; } } // showVec prints the vector for debugging void showVec(float *vector, int n) { for (int i = 0; i < n; i++) { printf("%f ", vector[i]); if ((i+1)%10 == 0) printf("\n"); } printf("\n"); } // check whether the kernel functions worked as expected void checkForErrors(float *y, int N) { // Check for errors (all values should be 3.0f) float maxError = 0.0f; for (int i = 0; i < N; i++) maxError = fmaxf(maxError, fabs(y[i]-3.0f)); // std::cout << "Max error: " << maxError << std::endl; printf("Max error: %f\n", maxError); }

Sequential main program: gcc compiler

The main program below is compiled by including the above two code blocks. As you can see below the code, there is a place for you to change the command line arguments, as we have seen in other examples in this book and the PDC for Beginners book. There is also now a box where we expose the compiler arguments that in this case are sent to the gcc compiler. Run it first with all of these values given to you.

#include <math.h> // ceil function #include <stdio.h> // printf #include <stdlib.h> // malloc // CPU version of add sequentially void CPUadd(int n, float *x, float *y) { for (int i = 0; i < n; i++) { y[i] = x[i] + y[i]; } } int main(int argc, char **argv) { printf("Vector addition using several compilers.\n"); // Set up size of arrays for vectors // int N = 1<<20; // same value, shown as multiple of 1024 int N = 1024*1024; int numThreads =1; // get command line args to change size of array getArguments(argc, argv, &N, &numThreads); // ignore numThreads for sequential case if (numThreads != 1) { numThreads = 1; // not used below printf("Warning: this is a sequential version and the number of threads is always 1, even though you used -t\n"); } printf("size (N) of 1D arrays are: %d\n\n", N); // host vectors float *x, *y; // Size, in bytes, of each vector size_t bytes = N*sizeof(float); // Allocate memory for each vector on host x = (float*)malloc(bytes); y = (float*)malloc(bytes); // initialize x and y arrays on the host initialize(x, y, N); // set values in each vector if (N < 40) { // debug printf("x:\n"); showVec(x, N); printf("y:\n"); showVec(y, N); } printf("add vectors on host\n"); CPUadd(N, x, y); if (N < 40) { // debug printf("y result:\n"); showVec(y, N); } checkForErrors(y, N); printf("execution complete\n"); // Release host memory free(x); free(y); return 0; }

Notes:

• Note that for this code, if the number of values in each array is less than 40, the arrays will be printed so that you can verify visually what is in them and that it is added them correctly. You can experiment with the ‘10’ n the command line arguments to illustrate this.

• Since this is a sequential version, the option for number of threads is ignored.

• The default compiler flags provided are -Ofast (capital O, not zero) for a fast code optimization level, and -lm for math library functions. To generate a compiler error you could try adding ,’-foo’ to the comma-separated list after ‘-lm’.

Sequential main program: pgcc compiler

The main program is compiled by including the two code blocks for command line arguments and helper functions. You can run this one to see how the new pgcc compiler runs the program and creates compiler output that is explained below.

#include <math.h> // ceil function #include <stdio.h> // printf #include <stdlib.h> // malloc // CPU version of add sequentially void CPUadd(int n, float *x, float *y) { for (int i = 0; i < n; i++) { y[i] = x[i] + y[i]; } } int main(int argc, char **argv) { printf("Vector addition using several compilers.\n"); // Set up size of arrays for vectors // int N = 1<<20; // same value, shown as multiple of 1024 int N = 1024*1024; int numThreads =1; // get command line args to change size of array getArguments(argc, argv, &N, &numThreads); // ignore numThreads for sequential case if (numThreads != 1) { numThreads = 1; // not used below printf("Warning: this is a sequential version and the number of threads is always 1, even though you used -t\n"); } printf("size (N) of 1D arrays are: %d\n\n", N); // host vectors float *x, *y; // Size, in bytes, of each vector size_t bytes = N*sizeof(float); // Allocate memory for each vector on host x = (float*)malloc(bytes); y = (float*)malloc(bytes); // initialize x and y arrays on the host initialize(x, y, N); // set values in each vector if (N < 40) { // debug printf("x:\n"); showVec(x, N); printf("y:\n"); showVec(y, N); } printf("add vectors on host\n"); CPUadd(N, x, y); if (N < 40) { // debug printf("y result:\n"); showVec(y, N); } checkForErrors(y, N); printf("execution complete\n"); // Release host memory free(x); free(y); return 0; }

Here is how to interpret the output from running this version:

• The output from the program comes first. Note how it is the same as the default gcc version above.

• After the program output, there is a line that looks like this: ===== STANDARD ERROR =====. What follows this is the output from the pgcc compiler. We indicated that we wanted this output by using the compiler flag ‘-Minfo=opt’. This pgcc compiler provides this option so that you can see the optimizations the compiler used as a result of including the -fast option. Look at the Wikipedia page for loop unrolling to see a discussion of this technique, which was the optimization used here.

You have attempted of activities on this page