1 / 29

High Performance Computing Seminar: 'C' Programming Basics

Join our seminar to learn basic 'C' programming skills, MPI bindings, performance modeling, and more for high performance computing coursework. Contact us for more info.

malha
Download Presentation

High Performance Computing Seminar: 'C' Programming Basics

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. MPI and C-Language Seminars 2010 High Performance Computing

  2. Seminar Plan (1/3) • Aim:Introduce the ‘C’ Programming Language. • Plan to cover: • Basic C, and programming techniques needed for HPC coursework. • C-bindings for the Message Passing Interface (MPI). • Performance modelling. • We won’t be covering C++ (but many of the skills are transferable).

  3. Seminar Plan (2/3) • Week 1 – Introduction, Data Types, Control Flow, Pointers • Week 2 – Arrays, Structures, Enums, I/O, Memory • Week 3 – Compiler Options and Debugging • Week 4 – MPI in C and Using the HPSG Cluster • Week 5 – “How to Build a Performance Model” • Week 6-9 – Coursework Troubleshooting(Seminar tutors available in their office)

  4. Seminar Plan (3/3) • The first three weeks focus on developing basic C skills; much of this will be familiar. • Feel free to skip this if you already feel confident. • Unless you have done this course before, or are on a PhD programme with HPSG, it is a good idea to attend from Week 4 onwards. • Seminars will usually be held on Wednesdays, 11:00 – 12:00.

  5. Contact Info • For C-related queries: • John Pennycook (sjp@dcs.warwick.ac.uk) • For performance modelling queries: • Oli Perks (o.perks@warwick.ac.uk) • Availability: • Always on e-mail. • High Performance Systems Group (CS 2.04). • Resources: • http://go.warwick.ac.uk/ep/pg/csrgai/teaching/cs402

  6. Books • Worth consulting (in the library): • The C Programming Language, (2nd Edition), Kernighan & Ritchie, 1988 • C – How to Program, (5th Edition), Deitel, 2006 • Online reference book linked at: • http://go.warwick.ac.uk/ep/pg/csrgai/teaching/cs402

  7. Overview of C • Much of the Java language builds on C/C++. Some of the language keywords and behaviour is very similar. • Beware – Though keywords and ‘names’ of types may be similar, they are often different. • Mixing between languages can introduce lots of bugs unless you’re sure what you’re doing.

  8. Data Types

  9. Data Types in C • There are only four basic data types in C: • char – a single byte (8-bits) capable of holding an ASCII character. • int – an integer value, the size of which is based on the word size of the machine (often 32-bits). • float – a single precision floating point number (often 32-bit, IEEE). • double – a double precision floating point number (often 64-bit, IEEE). • Note:These sizes are the most commonly encountered, but may be different on some platforms (non-Intel/AMD).

  10. Integers in C (1/2) • Two additional qualifiers to control the size of integer values: • short int – a ‘shorter’ version of int. • long int – a ‘longer’ version of int. • Rules: • short int <= int <= long int • short int >= 16 bits. • int >= 16 bits. • long int >= 32 bits.

  11. Integers in C (2/2) • Two (more) additional qualifiers for integer types: • unsigned – interpret the value as starting from 0. • signed – allow negative numbers. • Use unsigned to increase the range of values available, provided you are sure negative values will not be required. • Mixing unsigned and signed values can cause bugs, so be careful.

  12. Booleans in C • There is noboolean ‘type’ in C. • Booleans are implemented and evaluated as integer values: • TRUE = 1 • FALSE = 0 • Keywords may not be pre-defined in every implementation of C. • Conversely: • 0 = FALSE • Non-zero = TRUE

  13. Arrays in C (1/2) • Arrays in C are just allocated contiguous blocks of memory. • For example:intmyarray[5];allocates space for 5 integers in one contiguous block. • Arrays are not objects, so you cannot access properties (like length). You must record the maximum length of the array.

  14. Arrays in C (2/2) • The name of the array variable can be used as a pointer:int* pointer = myarray; • myarray is a pointer to the first element in the array. • We will come back to this when we start looking at pointers in more detail...

  15. Strings in C (1/2) • Strings are implemented using an array of characters, but with an additional element at the end of the string. • Strings must terminate with the null character, ‘\0’. • For example:“Hello” = { ‘H’, ‘e’, ‘l’, ‘l’, ‘o’, ‘\0’ }

  16. Strings in C (2/2) • Most important functions are implemented in the string library. • To use the string library, put:#include <string.h>at the top of your file. • All string functions in the C libraries will use the ‘\0’ character to detect the end of a string.

  17. Control Flow

  18. Control Flow in C (1/2) • if, while, do ... while are identical, except that conditions must produce an integer ‘boolean’ result. • Consider:if (2 % 2) { ...}... Will not run, since 2 % 2 = 0.

  19. Control Flow in C (2/2) • for loops are not quite identical. • Depending on the language mode, you may not be able to declare variable inside a for-loop definition:inti;for (i = 0; i < 10; i++) {printf(“%d \n”, i);}

  20. Operators in C • Mathematical operators in C are identical to those in Java. • +, -, *, / • <=, >=, ==, !=, <, >, &&, || • ! • % (modulus) • &, | • ++i, i++, --i, i-- (pre/post-increment/decrement)

  21. Pointers

  22. Pointers (1/4) • Pointers are references to locations in memory. • They are one of the biggest causes of bugs in software construction. • Worse – they are one of the biggest reasons coursework does not produce correct solutions on marking day.

  23. Pointers (2/4) • To declare a pointer:intmyvalue = 42;int* mypointer;mypointer = &myvalue; • int* creates a pointer to a location in memory. This is treated as if it were an integer value. • &myvalueis the location of myvalue in memory.

  24. Pointers (3/4) • Remember: • *ptr– look at the address pointed to by ptr. • &v – get the address at which v is stored. • Be careful – every year pointers cause problems.The compiler can detect some common bugs, but not all of them... The only way to fix these is to inspect your code manually.

  25. Pointers (4/4) • Common mistakes: • Uninitialised PointersThe pointer is not initialised before it is used.An un-initialised pointer has a value of 0 by default.This causes a segmentation fault. • Out-of-bounds Memory AccessA pointer is used to access an array, and pushed outside of the array’s bounds.This either corrupts memory or gives a segmentation fault.

  26. Getting Started

  27. Hello World • Typical “Hello World” program:#include <stdio.h>main (intargc, char *argv[]) {printf(“Hello world!\n”);} • The #include acts like a Java ‘import’ statement.

  28. Compilation (1/2) • To compile a C file to object code:gcc –c myfile.c • To link object code in an executable:gcc –o myprogrammyfile.o • To run the executable:./myprogram

  29. Compilation (2/2) • Compilers: • Linux/Mac OS X – gcc • Windows – Microsoft Visual C++/Intel C Compiler • Code and seminar contents should work with these compilers (but no promises). • You may not be able to compile the MPI coursework at home unless you compile and install the MPI runtimes. • Your code will be tested running on department machines; it may be best to do your compilation here.

More Related