High Performance Computing

Transcription

1 High Performance Computing MPI and C-Language Seminars 2009 Photo Credit: NOAA (IBM Hardware)

2 High Performance Computing - Seminar Plan Seminar Plan for Weeks 1-5 Week 1 - Introduction, Data Types, Control Flow, Pointers Week 2 - Arrays, Structures, Enumerations, I/O, File I/O Week 3 - Dynamic Memory, Preprocessing, Compile Time Options Week 4 - MPI in C Week 5 - How to Build a Performance Model Week Coursework Troubleshooting (a number of seminar tutors will be available during these sessions - go to each tutor s office)

3 Quick Recap (from last week) Types are machine dependent (but follow rules) No boolean type - we use integer results to control looping/branching Strings are a char[] terminated with a null character ( \0 ) Pointers causes bugs - we will revisit them (briefly) today. Control flow keywords (while, for, if etc) are approximately the same as Java but using integers instead of pure booleans.

4 Arrays

5 Arrays in the C Language Arrays are contiguous blocks of memory (with a useful addressing mechanism). Every element is the same type.

6 Arrays in the C Language Arrays are contiguous blocks of memory (with a useful addressing mechanism). Every element is the same type. Declared in C by doing the following: int a[10]; a[0] = 1; a[1] = 2;... Note: There is no new declaration for arrays like there is in Java.

7 Iterating over an Array Can iterate over an array using an index variable for(i = 0; i < 10; i++) { printf( Value at index %i is: %i\n, i, a[i]); } Can iterate over an array using a pointer int *ptrtoarray; ptrtoarray = &a[0]; printf( Value at 0 is: %i\n, *ptrtoarray); ptrtoarray++; printf( Value at 1 is: %i\n, *ptrtoarray);

8 Iterating over an Array Why should I use pointers? Can be more efficient than using array index variables. If you ve done the compilers course (at Warwick) the details of array accesses are covered. These are beyond the scope of this seminar. Why should I not use pointers? Usually the most common cause of program errors and bugs - almost always the cause of problems with the coursework!

9 Typing a Pointer Typing a pointer is important if you plan to use it to iterate over arrays or move through memory. /* pointer 1 */ int* myintptr; /* pointer 2 */ void* myvoidptr; What is the difference?

10 Structures and Enumerations

11 Structures Structures are a way of grouping data together (when it makes sense to do so!). For instance: a point in a 2-dimensional plane. We might group together two integers in a structure called Point2D. Note: these are not the same as Java classes because a structure does not have any methods which operate on the structure s internal data. If you want to do this then you really need to use C++ (sorry).

12 Defining a Structure To define our 2-dimensional point structure: struct point { int x; int y; }; Note the ; are the definition of the structure.

13 Using a Structure Now we can use a structure in our programs just as we might a normal C type. The definition for a structure must appear before it is used. int a = 5; struct point mypoint; mypoint.x = a; mypoint.y = a;

14 Using Pointers and Structures Structures are used almost everywhere in large scale C programs (for instance: Linux kernel, GCC compiler). Using pointers to access structures in very large programs can get a big tricky so there is some nice shorthand. struct point origin, *ptr_origin; ptr_origin = &origin; printf( x at the origin is %d, (*ptr_origin).x);

15 Using Pointers and Structures Structures are used almost everywhere in large scale C programs (for instance: Linux kernel, GCC compiler). Using pointers to access structures in very large programs can get a big tricky so there is some nice shorthand. struct point origin, *ptr_origin; ptr_origin = &origin; printf( x at the origin is %d, ptr_origin->x); We trust the compiler to handle our shorthand for us (keeps programs nice and tidy).

16 Enumerations Enumerations are a way of grouping constants. For instance months of the year: enum months = { JAN = 1, FEB, MAR, APR, MAY, JUN, JUL, AUG, SEP, OCT, NOV, DEC }; The compiler will turn these into incrementally numbered values for us (or we can assign our own as we have done with January).

17 Using Enumerations The effect of an enum declaration in C is to introduce named constants into our program. For instance, we can now use three letter abbreviations for months: int birthday_month = 12; if(birthday_month == DEC) { printf( you have a birthday in the best month ); } else { printf( sorry bud! worst month ever! ); }

18 Input/Output Operations

19 General Notes on I/O Input/Output operations in C use pointers to locate the start of the array to read/write to. Remember - it is easy to cause program errors by reading or writing too far into memory. To use any I/O function we need to add (at top of file): #include <stdio.h>

20 Printing to Screen Printing to screen is done with the printf(...) function. printf( hello %d, 5) - %d tells the compiler to print a decimal integer (not a double!). printf( hello %u, 5) - %u tells the compiler to print an unsigned decimal. printf( hello %f, 1.25) - %f tells the compiler to print a float/ double printf( hello %s, hello ) - %s tells the compiler to print a string printf( hello %% ) - %% tells the compiler to print a %

21 Reading from Standard Input Reading from Standard Input (console) is done using the scanf(...) function. For instance: we can read an integer by doing the following: int myinteger; scanf( %d, &myinteger); Note: we need the & because scanf(...) reads data from the console and places it into memory at the location specified (using pointers/ addressing). Do not forget the & or it will cause disaster!

22 Files and I/O Operations Operations on files are similar to those used for the screen. There is one addition - the file handle (to which you want to read/write). Define a file handle: FILE *f; f = fopen( /home/johndoe/myfile.txt, r ); Second parameter represents the access type: r = Reading Text, w = Writing Text (truncate to zero), a = Append rb = Read Binary, wb = Writing Binary, ab = Append Binary

23 Files and I/O Operations You should always try to close a file when you re finished. Some systems aren t good at clearing up unused resources. Is possible to use all the file handles in some systems. Close a file handle: fclose(f); Causes a flush of data from buffers and then frees the handle for use elsewhere. Returns 0 if successful

24 Printing to Files in C When we wrote to the console using printf(...) we didn t need a file handle (the system redirects I/O to the standard output). To write to a file we use: fprintf(f, Hello World\n); Exactly the same behaviour except the first parameter is the file handle (same for most file operations).

25 Read from Files in C When we wrote to the console we used the scanf(...) function. To read from a file we use: int x; fscanf(f, %d, &x); Same as before, first parameter is the file handle and we make use of the & (address operator) to locate the memory location x is stored at.

26 Checking for End of File In a lot of applications we want to read all of the data in a file. We can do this using the following: feof(f); File End of File function will check the location of the file pointer, if we re at the end it will return a non-zero value. If the return is zero there is still more data to go.

27 End of Seminar Thanks for coming, see you next week. Seminar worksheets are in the seminar note pack