ASSIG 1

1. What is OpenMP? What is the motive behind using OpenMP?

2. How to compile and execute the code in the parallel region of OpenMP program?
3. State the feature set of OpenMP API.
4. How work can be shared among threads in an OpenMP program? State the OpenMP
directives used for the same.
5. OpenMP is basically used to parallelize an application. Justify the statement.

What is OpenMP?

OpenMP (Open Multi-Processing) is a tool that helps programs run faster by using multiple
processors at the same time. It is mainly used in C, C++, and Fortran to make programs
execute tasks in parallel (simultaneously).

Motive Behind Using OpenMP

The main goal of OpenMP is to speed up programs by distributing work among multiple
cores in a CPU. Instead of one processor doing all the work, OpenMP allows multiple
processors to work together, reducing execution time and making the program more
efficient.
For example, if a task takes 10 seconds on one processor, OpenMP can divide the work
among four processors, so each one does a part, potentially completing the task in around
2.5 seconds.

How to compile and execute the code in the parallel region of OpenMP program?

Create a C or C++ program using OpenMP directives.

Use a compiler that supports OpenMP (such as gcc for C or g++ for C++).
Run the compiled file: Each thread will print a message, showing parallel execution.
Control the Number of Threads= Use the OMP_NUM_THREADS environment variable:

State the feature set of OpenMP API.

Parallel Execution
Uses #pragma omp parallel to create multiple threads for executing code simultaneously.
Thread Management
 omp_get_thread_num() to get the thread ID.
 omp_get_num_threads() to get the total number of threads.
Work-Sharing Constructs
 #pragma omp for → Splits loop iterations among threads.
 #pragma omp sections → Divides tasks among threads.
Reduction Operations
 #pragma omp reduction(operator:variable) → Performs operations like sum, max, min across
threads.
Data Handling (Shared & Private Variables)
 shared(variable) → Shared across all threads.
 private(variable) → Each thread gets its own copy.

How work can be shared among threads in an OpenMP program? State the OpenMP directives
used for the same.
 In OpenMP, work can be shared among threads using work-sharing constructs. These directives
help distribute tasks efficiently among multiple threads without creating new parallel regions.

 #pragma omp for → Splits loop iterations among threads.

 #pragma omp sections → Divides tasks among threads.

 #pragma omp single → Ensures a block of code runs on only one thread.

OpenMP is basically used to parallelize an application. Justify the statement

OpenMP (Open Multi-Processing) is designed specifically to enable parallel programming in

applications. It allows developers to utilize multiple CPU cores efficiently, improving performance and
reducing execution time.
Parallel Execution of Code
OpenMP enables multiple threads to run sections of code simultaneously using the #pragma omp
parallel directive.
Justification: Instead of a single processor handling the task, multiple processors share the workload,
making execution faster.
Parallelizing Loops (Work Sharing)
Loops are often performance bottlenecks. OpenMP speeds up execution by dividing loop iterations
among multiple threads.
Justification: The workload is split, reducing the total execution time.
Efficient Resource Utilization
OpenMP allows applications to utilize multi-core processors, preventing underutilization of
computing resources.
Without OpenMP (Single Thread) With OpenMP (Multiple Threads)
Only one core is used = Multiple cores share the workload
Slower execution= Faster execution
No parallelism= Efficient parallel processing

Explain all the constructs that a programmer really should be familiar with while writing a
OpenMP program?
Essential OpenMP Constructs for Writing Parallel Programs
When writing an OpenMP program, a programmer should be familiar with key constructs that
control parallel execution, work distribution, synchronization, and data handling. These constructs
allow efficient parallel programming and performance optimization.
Parallel Region (#pragma omp parallel)
Defines a region where multiple threads execute simultaneously.
Work-Sharing Constructs

#pragma omp for → Splits loop iterations among threads.

#pragma omp sections → Divides tasks among threads.

Data Handling (Shared & Private Variables)

shared(variable) → Shared across all threads.

private(variable) → Each thread gets its own copy.
Synchronization Constructs
Ensure proper coordination between threads to avoid race conditions.
critical Directive
Ensures only one thread executes a block at a time.
barrier Directive
Forces all threads to wait until they reach this point.
What is the role of parallel constructs in OpenMP program?
Role of Parallel Constructs in OpenMP Programs
Parallel constructs in OpenMP play a crucial role in enabling multi-threaded execution by
distributing work among multiple processors. They allow efficient utilization of CPU resources,
improving performance and scalability.
Parallel Region (#pragma omp parallel)
Defines a region where multiple threads execute simultaneously.
Work-Sharing Constructs

#pragma omp for → Splits loop iterations among threads.

#pragma omp sections → Divides tasks among threads.

Data Handling (Shared & Private Variables)

shared(variable) → Shared across all threads.

private(variable) → Each thread gets its own copy.
Synchronization Constructs
Ensure proper coordination between threads to avoid race conditions.
critical Directive
Ensures only one thread executes a block at a time.
barrier Directive
Forces all threads to wait until they reach this point.
Reduction Operations

 #pragma omp reduction(operator:variable) → Performs operations like sum, max, min across
threads.

Explain the use of following library functions.

omp_set_num_threads(int num_threads): Sets the number of threads for parallel execution.
(b) omp_get_num_threads(void): Returns the number of threads in the current parallel region.
(c) omp_get_max_threads(void): Returns the maximum number of threads available.
(d) omp_get_thread_num(void): Returns the unique ID of the calling thread.
(e) omp_get_num_procs(void): Returns the number of available CPU cores.
(f) omp_in_parallel(void): Checks if the code is running inside a parallel region.
(g) omp_set_dynamic(int dynamic_threads): Enables or disables dynamic thread adjustment.
(h) omp_get_dynamic(void): Returns whether dynamic thread adjustment is enabled.
(i) omp_set_nested(int nested): Enables or disables nested parallelism.
(j) omp_get_nested(void): Checks if nested parallelism is enabled.
(k) omp_init_lock(omp_lock_t *lock): Initializes a lock for thread synchronization.
(l) omp_destroy_lock(omp_lock_t *lock): Destroys a previously initialized lock.
What are the different causes supported by the parallel construct? Explain.
it supports various clauses that control thread behavior, data handling, and workload distribution.

 num_threads(n): Sets the number of threads for parallel execution.

 default(shared | none): Defines default data-sharing behavior for variables.

 shared(var1, var2, ...): Makes specified variables shared among all threads.

 private(var1, var2, ...): Gives each thread a separate copy of specified variables.

 firstprivate(var1, var2, ...): Like private, but initializes with the original value.

 lastprivate(var1, var2, ...): Like private, but updates the original variable after execution.

 reduction(operator: var1, var2, ...): Combines values from all threads using an operator.

 if(condition): Executes parallel region only if the condition is true.

State OpenMP working constructs.

 #pragma omp parallel – Defines a parallel region where multiple threads execute.
 #pragma omp for – Distributes loop iterations among threads.
 #pragma omp sections – Divides code into separate, parallel execution sections.
 #pragma omp single – Ensures a block of code runs only on one thread.
 #pragma omp master – Executes a block only on the master thread.
 #pragma omp critical – Defines a section that only one thread can execute at a time.

Explain loop construct in OpenMP program.

 #pragma omp for – Distributes loop iterations among threads.
 schedule(type, chunk_size) – Controls how iterations are assigned (static, dynamic, guided).
 nowait – Allows threads to proceed without waiting for others after the loop.
 collapse(n) – Merges n nested loops into a single parallel loop for better efficiency.

State the significance of the section construct in OpenMP program.

 #pragma omp sections – Divides code into independent sections executed by different threads.
 #pragma omp section – Defines individual sections within the sections construct.
 Improves workload distribution – Useful when tasks are independent but take different execution
times.
 Reduces execution time – Multiple tasks run in parallel instead of sequentially.

What are the different clauses supported by the loop construct? Explain
Clauses Supported by the Loop Construct in OpenMP
1. private(var) – Each thread gets a separate copy of the variable.
2. firstprivate(var) – Like private, but initializes with the original value.
3. lastprivate(var) – Like private, but updates the original variable after execution.
4. reduction(operator: var) – Combines values from all threads using an operator (+, *, min,
max, etc.).
5. schedule(type, chunk_size) – Controls iteration distribution (static, dynamic, guided).
6. nowait – Allows threads to proceed without waiting for others after the loop.
7. collapse(n) – Merges n nested loops into a single parallel loop.
What are the different clauses supported by the section construct? Explain
Clauses Supported by the sections Construct in OpenMP
1. private(var) – Each thread gets a separate copy of the variable inside a section.
2. firstprivate(var) – Like private, but initializes with the original value.
3. lastprivate(var) – Like private, but updates the original variable after execution.
 4. reduction(operator: var) – Combines values from all sections using an operator (+, *, min,
max, etc.).
5. nowait – Allows threads to proceed without waiting for other sections to finish.
Give the list of clauses supported by the single construct.
Clauses Supported by the single Construct in OpenMP
1. private(var) – Each thread gets a separate copy of the variable inside the single region.
2. firstprivate(var) – Like private, but initializes with the original value before entering the
single region.
3. copyprivate(var) – Copies the value of a variable from the executing thread to all other
threads after the single region.
4. nowait – Allows other threads to continue execution without waiting for the single thread to
finish.
Explain single construct in OpenMP program.
The single construct ensures that a block of code is executed by only one thread, while other threads
in the team skip that block and continue execution.
Key Features:
1. Only one thread executes the block – No guarantee which thread runs it.
2. Other threads skip and continue execution – Unlike master, they don’t wait unless specified.
3. Optional synchronization using nowait

 Shared clause (shared(var)) – Specifies that a variable is shared among all threads.
 Private clause (private(var)) – Each thread gets its own separate copy of the variable.
 Lastprivate clause (lastprivate(var)) – Like private, but updates the original variable after
execution.
 Firstprivate clause (firstprivate(var)) – Like private, but initializes with the original value.
 Default clause (default(shared | none | private)) – Sets default data-sharing behavior for
variables.
 Nowait clause (nowait) – Prevents threads from waiting at a barrier after a construct.
 Schedule clause (schedule(type, chunk_size)) – Controls loop iteration distribution among threads
(static, dynamic, guided).

Explain or describe all the schedule kinds supported on the schedule clause.
The schedule clause in OpenMP controls how loop iterations are distributed among threads in a
#pragma omp for directive.
1. static[, chunk_size] – Divides iterations into equal chunks assigned to threads in order.
2. dynamic[, chunk_size] – Assigns chunks to threads dynamically as they finish previous
chunks.
3. guided[, chunk_size] – Threads get exponentially decreasing chunk sizes, with a minimum
size of chunk_size.
4. runtime – The scheduling strategy is set at runtime using the OMP_SCHEDULE environment
variable.
Explain OpenMP synchronization constructs with their significance.
ensure correct execution order and prevent race conditions when multiple threads access shared
data.
 Barrier (#pragma omp barrier) – Makes all threads wait until every thread reaches this point.
 Ordered (#pragma omp ordered) – Ensures specific loop iterations execute in order.
 Critical (#pragma omp critical) – Allows only one thread at a time to execute a block of code.
  Atomic (#pragma omp atomic) – Ensures safe updates to a shared variable without full
locking.

Explain how OpenMP uses multi-threading to enhance program execution speed.

Parallel Region (#pragma omp parallel)
Defines a region where multiple threads execute simultaneously.
Work-Sharing Constructs

#pragma omp for → Splits loop iterations among threads.

#pragma omp sections → Divides tasks among threads.

Data Handling (Shared & Private Variables)

shared(variable) → Shared across all threads.

private(variable) → Each thread gets its own copy.
Synchronization Constructs
Ensure proper coordination between threads to avoid race conditions.
critical Directive
Ensures only one thread executes a block at a time.
barrier Directive
Forces all threads to wait until they reach this point.
Reduction Operations

 #pragma omp reduction(operator:variable) → Performs operations like sum, max, min across
threads.

Differentiate between parallel region and work-sharing constructs in OpenMP.

How one can manage data and thread private variables in OpenMP?
 shared → All threads use the same variable.
 private → Each thread gets its own copy (starts empty).
 firstprivate → Like private, but keeps the original value.
 lastprivate → Like private, but saves the last value after execution.
 threadprivate → Makes a global variable private for each thread.

Describe how loop constructs function in OpenMP, and their advantages.

OpenMP uses #pragma omp for to divide loop iterations among multiple threads, making execution
faster
Faster Execution 🚀 – Multiple threads run the loop at the same time.
✔ Better CPU Usage 🔄 – Uses all available cores efficiently.
✔ Automatic Work Sharing 📊 – OpenMP distributes loop iterations among threads.
✔ Scalability 📈 – Can handle large data efficiently.
✔ Easy to Use ✅ – Just add #pragma omp for, no need for manual thread management.

How does OpenMP deal with nested parallelism?

Nested parallelism means creating a parallel region inside another parallel region. By default,
OpenMP disables it, but you can enable it
How OpenMP Manages Nested Parallelism:
1. omp_set_nested(1) → Turns nested parallelism ON.
2. omp_get_level() → Checks how deep the parallel regions go.
3. omp_set_max_active_levels(n) → Limits the depth of nested parallelism.

How does OpenMP handle exceptions in a parallel region?

OpenMP does not have built-in exception handling for parallel regions, especially in C and C++. If an
exception is thrown inside a #pragma omp parallel block, it can lead to undefined behavior because
multiple threads may not handle exceptions properly.
 Use try-catch inside each thread – Prevents unhandled exceptions from crashing the program.
 Avoid throwing exceptions across threads – OpenMP does not support exception propagation.
 Use a shared flag or variable – If an exception occurs, set a shared flag to signal all threads to stop.
 Use OpenMP #pragma omp cancel – Helps stop execution in certain cases.

Can you explain how OpenMP’s thread teams work?

OpenMP creates a team of threads when it enters a #pragma omp parallel region.
🔹 The main (master) thread (Thread 0) creates worker threads to share the work.
🔹 Each thread has a unique ID (omp_get_thread_num()) and knows the total threads
(omp_get_num_threads()).

How does OpenMP handle memory management, particularly in a multi threading context?
Shared Memory – All threads access the same variable (shared clause).
🔹 Private Memory – Each thread gets its own copy (private clause).
🔹 Thread-local Storage – Keeps data persistent across parallel regions (threadprivate).
🔹 Dynamic Memory – Threads can allocate memory using malloc() or new.

. How do you determine the number of threads to use in OpenMP for optimal performance?
 Number of CPU Cores – Use omp_get_num_procs() to get available cores.
 Workload Type – For CPU-heavy tasks, match threads to cores; for I/O tasks, use fewer threads.
 Hyperthreading – If enabled, try using 1.5x to 2x the core count.
 Memory Usage – Too many threads can cause memory contention and slow down execution.
 Experimentation – Test different thread counts (num_threads) and measure performance.

Could you provide an example of how and when to use the ‘atomic’ directive in OpenMP?
The #pragma omp atomic directive ensures safe updates to a shared variable when multiple threads
modify it simultaneously.
🔹 It prevents race conditions by ensuring only one thread updates the variable at a time.

How would you handle data race conditions in OpenMP?

A data race condition occurs when multiple threads access the same shared variable without proper
synchronization, leading to unpredictable results.

private – Each thread gets its own copy of a variable.

🔹 atomic – Ensures only one thread updates a shared variable at a time.
🔹 critical – Allows only one thread to execute a code block.
🔹 reduction – Safely combines values across threads (e.g., sum, min, max).
🔹 barrier – Synchronizes threads to prevent conflicts.

How does the ‘collapse’ clause work in OpenMP, and in what situations would you use it?

The collapse(n) clause merges n nested loops into a single loop for better parallelization.
🔹 It is useful when outer loops have fewer iterations, allowing inner loops to be parallelized as well.

Describe how the ‘ordered’ directive is used in OpenMP

The #pragma omp ordered directive ensures that certain parts of a loop execute in sequential order,
even within a parallelized loop.
🔹 It is used when some operations inside a parallel loop must follow a strict order (e.g., writing to a
file, debugging, or dependent calculations).

How does OpenMP’s dynamic adjustment of threads feature work?

OpenMP allows dynamic adjustment of threads to optimize performance when the workload varies.
It enables the runtime to increase or decrease the number of threads based on system load.

. Using suitable example (parallel code), explain in what situation schedule clause is used in
OpenMP?

Usage of schedule Clause in OpenMP

The schedule clause is used in OpenMP to control how loop iterations are distributed among threads,
optimizing performance based on workload characteristics.

Use static for uniform workloads (e.g., simple loops).

Use dynamic when iterations vary in execution time.

Use guided when heavy workload decreases over time.

Use runtime to allow external configuration.

Gustafson Barsis law says that “Speedup tends to increase with problem size.” Justify the
statement.

Gustafson-Barsis' Law: "Speedup Increases with Problem Size"

Gustafson-Barsis' Law states that as the problem size increases, the parallel portion also grows,
leading to higher speedup.
Why?

✅ More parallel work → Efficient processor utilization.

✅ Fixed serial work → Becomes negligible with a larger problem.

✅ More processors contribute effectively → No diminishing returns.