By d000hg
TopCoder Member

Figure 1.

#include <omp.h>

1. omp_set_num_threads(int num_threads) - declared in <omp.h> - can be used to set the maximum thread count at run-time, OUTSIDE of a parallel section.
2. Set an environment variable OMP_NUM_THREADS to the maximum thread count.
3. If neither of these is used, the default is implementation specific - it could be 1, or it could be the number of cores, or it could, in theory, be any other number.

#include <iostream>
using namespace std;
#include <omp.h>	//required for omp_... API functions

void main()
{
	//tell OpenMP to use 3 threads in parallel regions
	omp_set_num_threads(3);

//inform OpenMP that the following code block is a parallel region
#pragma omp parallel
	{
		//create a local variable for each thread
		int thread = omp_get_thread_num();
		//prove it's multi-threaded!
		cout << "Hello world from thread " << thread << endl;
	}//end of parallel region
}

1. Initially a single master thread is running.
2. At the start of the block preceded by #pragma omp parallel, the master thread creates two child threads.
3. All three threads now execute the body of the parallel section simultaneously. Each thread creates its own variable thread, containing the ID of that thread. That's right - there are three different variables, each named thread.
4. At the end of the parallel section OpenMP places what is known as a barrier. This simply means that program execution waits here until all threads have completed. In normal multithreaded programming you have to explicitly create a barrier otherwise the master thread would quite happily continue on with the rest of the program - in all likelihood immediately trying to read some data which has not yet been written by an incomplete thread.
5. When all threads have reached the barrier, all but the master thread are destroyed or deactivated.
6. Program execution resumes with the master thread only - in this case, only as far as the end of the program.

void example2()
{
	//tell OpenMP to use 6 threads in parallel regions
	omp_set_num_threads(6);
	//this variable will be of shared scope in the parallel region
	int i = 0;
//inform OpenMP that the following code block is a parallel region
#pragma omp parallel
	{
		cout << "++i = "<<++i<<endl;
	}//end of parallel region
}

#pragma omp parallel
[if(scalar_expression)] /
[private(list)] /
[shared(list)] /
[default(private* |shared | none)] /
[firstprivate(list)] /
[reduction(operator: list)] /
[copyin(list)]
{
...
}

void example3()
{
	//tell OpenMP to use 6 threads in parallel regions
	omp_set_num_threads(6);

	int i = 0;
//the default clause means we're forced to specify the scope for i.
//here it's private. Note that as an object, even cout must be scoped!
#pragma omp parallel default(none) private(i) shared(cout)
	{
		cout << "++i = "<<++i<<endl;
	}//end of parallel region

	cout << "After parallel region, i ="<<i<<endl;
}

void example4()
{
	omp_set_num_threads(2);

	for(int i=0;i<3;++i)
	{
	//the default clause means we're forced to specify the scope for i.
	//here we've made it private. Note that even cout must be scoped!
		cout << endl <<"Thread listing for i="<<i<<':'<<endl;
	#pragma omp parallel default(none) shared(i) shared(cout) if(i)
		{
			cout << "Thread "<<omp_get_thread_num()<<endl;
		}//end of parallel region
	}
}

X+=5;

1. Load the value from X's memory location into a CPU register.
2. Add 5 to the contents of the register.
3. Store the contents of the register back to X's memory location.

1. Thread 1 loads X (2) into a CPU register.
2. Thread 1 adds 5 to the contents of the register (2). So the register holds 7, X is still 2.
3. Thread 2 loads X (2) into a CPU register.
4. Thread 1 stores the contents of the register (7) into X. So X=7.
5. Thread 2 adds 5 to the contents of the register (2). So the register holds 7.
6. Thread 2 stores the contents of the register (7) into X. So X=7.

#pragma omp atomic
X+=5;

• ++X & X++
• --X & X—
• X binary-op=expr, where expr is independent of X. e.g. X+=5, X&=Y

#pragma omp critical CRIT_1
{
	X+=5;
}

#pragma omp critical
{
	cout << "Hello from thread" << omp_get_thread_num()<<endl;
}

• Any synchronisation technique is slower than no synchronisation - be sure that you really need it.
• An atomic operation is preferable to wrapping the operation within a critical section, since the compiler can optimise the operation to a single instruction.
• If you have several operations that need to be 'safe,' you may need to experiment to find which technique is faster. For instance, which is better:
  

  #pragma omp atomic
  	X+=5;
  #pragma omp atomic
  	Y*=X;
  #pragma omp atomic
  	Y%=4;
  

  Or:

  #pragma omp critical
  {
  X+=5;
  Y=(Y*X)%4;
  }
  

• When using critical sections, make sure to name them so that only sections modifying the same variables share the same name.

void example5()
{
	omp_set_num_threads(4);

	int val[8];
#pragma omp parallel default(none) shared(val)
	{
	//we'll use our 4 threads to calculate & store the cubes of 1 - 9
	#pragma omp for
		for(int i=1;i<9;++i)
		{
			val[i-1] = i*i*i;
			int thread = omp_get_thread_num();
		//use a critical section for i/o
		#pragma omp critical CRIT_1
			{
		cout<<i<<"^3="<<val[i-1]<<", using thread "<<thread<<endl;
		}
		}
	}
	
}

		for(int i=1;i<9;++i)
		{
			val[i-1] = i*i*i;

		for(int i=1;i<8;++i)
		{
			val[i] = val[i-1]*2;