Learn C programming fundamentals like data types, control flow, functions, pointers, and memory allocation while exploring debugging, profiling, and optimization tools like GDB and gcc.

clang.tar.gz

RunC

RunCwithGNUflags

RunCwithlmflag

Run_go_file 

RunC-without_warning_flag

Compile-only

doNothing

Posix

RunCFileGo

Compile-go-file

Compile-go-debugging-file

OpenMP

Make

MPI4Threads

MPI8Threads

Octave

RunC-without_warning_flag-KS

This comprehensive course covers the fundamentals and advanced concepts of C programming to build a solid foundation for your programming journey. You’ll learn about essential topics like data types, variables, constants, and C statements, along with deeper explorations of control flow in C, including for loops and conditional statements in C. You’ll also learn about C functions, scope of variables, function arguments, and work with arrays, strings, and pointers in C.

You’ll gain hands-on experience with dynamic memory allocation, stack vs. heap, C standard library, and advanced topics such as binary files, input and output streams, and header files. The course also teaches compiling in C, linking in C, and debugging with tools like GNU debugger (GDB) and gprof for code profiling. By mastering these concepts, you’ll confidently program in C and optimize your code using gcc optimization flags.

Learn C

# Multithreading

The **threads model** of parallel programming is one in which a single process (a single program) can spawn multiple, concurrent “threads” (sub-programs). Each thread runs independently of the others, although they can all access the same shared memory space (and hence they can communicate with each other if necessary). Threads can be spawned and killed as required, by the main program.

Once spawned by a program, threads are concurrent units of processing that can then be delegated by the operating system to multiple processing cores. Clearly the advantage of a multithreaded program (one that uses multiple threads that are assigned to multiple processing cores) is that you can achieve big speedups, as all cores of your CPU (and all CPUs if you have more than one) are used at the same time.


# Race conditions and synchronization

A challenge of using threads is the issue of collisions and race conditions. A **race condition** is a situation that arises when multiple threads are trying to access the same resource without proper coordination, which can result in errors and unintended consequences. For example, if multiple threads write to (and depend upon) a shared memory variable, then care must be taken to make sure that multiple threads don’t try to write to the same location simultaneously. There are mechanisms to synchronize threads, and to implement mutually exclusive access to shared variables so that the shared variables can be locked by one thread and then released, preventing collisions by other threads. These mechanisms ensure threads must “take turns” when accessing protected data.

We now want to go over different tools for implementing parallel programming starting with POSIX threads.

# POSIX Threads (pthreads)

**POSIX Threads** (**pthreads** for short) is a standard for programming with threads, and defines a set of C types, functions and constants. 

Here is a simple example program that spawns 5 threads, where each one runs the `myFun` function. 

Learn how parallel programming is a complex affair and get introduced to the POSIX thread library as the first of many tools we want to talk about.

POSIX Threads

Introduction to C Programming

Data Types in C

C Operators and C Expressions

Control Flow in C

Functions in C

Complex Data Types

Stack vs. Heap

Pointers in C

C string

Input and Output Stream

Macros and the C Preprocessor

Header Files, Compiling and Linking

C Debugger

Code Profiling

Parallel Programming in C

Project: Using a Bootstrapped t-test

Conclusion

Miscellaneous

Appendix: Setting Up the Environment

POSIX Threads

Multithreading