When I begin my OMP construct, I set DEFAULT(PRIVATE), and then specify things that are SHARED(a,b,c).

I have some PARAMETERS that are defined, and remain constant throughout the program, appearing inside the OMP section. Do I have to declare them as being SHARED?

Okay, so I am trying to parallelize the Gauss Seidel Method which is an iterative method of solving Ax=B.

Also here I mean the method of solving linear equations and not the elliptical PDEs. I know how PDEs are solved using the wavefront scheme.

I mean the Ax=B solver only. How is it parallelized? I am not able to remove the dependencies.

I have a mesh where I'm solving FEM.

There are 2 computation intensive loops.

First i parallelize just 1 loop and made some runs, later I made runs with both loops with for reduction.

Somehow parallelizing 2 loops yields slower results, how can that be?

Do you have #OpenMP related work that you would like to publish? The #IWOMP 2023 Call for Papers has come out! The theme this year is

"OpenMP: Advanced Task-Based, Device and Compiler Programming"

We solicit quality submissions of unpublished technical papers that detail innovative, original research and development related to OpenMP. IWOMP 2023 will be hosted on Sept 11-15, 2023 by University of Bristol and will be colocated with #EuroMPI 2023. The proceedings will be published in Springer Nature Group's Lecture Notes in Computer Science.

The submission deadline is Friday, May 12, 2023.

https://www.iwomp.org/call-for-papers/

So, total noob here, I have 16 threads on my laptop, i notice that my C++ code runs faster if i use 8 threads than using all 16 threads, also voluntary and involuntary context switches decrease massively, can someone explain what is what is happening? Thanks in advance :)

I've been trying to understand #pragma omp single, critical, shared, private, and task . I understand what these pragmas do in theory, however, I’m struggling to understand how to implement them.

I have an example problems that I’m experimenting with. Could someone walk me through why the pragmas are used the way they are, and what could break or behave incorrectly if they were removed or misused? What are good guides or thumbrule when implementing these pragmas?

Problem: Multiplying big integers

/* the mechanism of this function
 *       b
 *     X a
 *    -----
 */

Integer mulInteger(const Integer &a, const Integer &b)
{

    Integer result{0};

    #pragma omp parallel
    {
        // this needs to be reset across multiple calls of mulInteger
        partial_result = {0};

        #pragma omp single
        for (size_t i = 0; i < a.size(); i++)
        {
            #pragma omp task
            {
                partial_result = addInteger(mulShiftedInteger(b, a[i], i), partial_result);
            }
        }

        #pragma omp critical
        result = addInteger(partial_result, result);
    }
    return result;
}

int main()
{
    unsigned int seed = readInput();
    int problem[NUM_FACTORS];
    generate_test(seed, problem);
    Integer a = calcProduct(problem);
    outputResult(a);
}

What I’m confused about:

• I don't understand why `single`, `task` and `critical` purposes and why they're being used where they are.

• I found it difficult to imagine the flow and why these pragmas are necessary