int main()
{
vector<int> vecInt(100);
#pragma omp parallel for
for (int i = 0; i < vecInt.size(); ++i)
{
vecInt[i] = i*i;
}
return 0;
}

#pragma omp parallel
{
cout << "parallel run!!!\n";
}

externint parallelism_enabled;
#pragma omp parallel for if(parallelism_enabled)
for(int c=0; c<n;++c)
handle(c);

#pragma omp parallel for
for (int i = 0; i < 10; ++i)
{
printf("%d ", i);
}

int this_thread = omp_get_thread_num();
int num_threads = omp_get_num_threads();
int my_start = (this_thread)* 10 / num_threads;
int my_end = (this_thread + 1) * 10 / num_threads;
for (int n = my_start; n < my_end; ++n)
printf("%d ", n)

#pragma omp parallel
{
#pragma omp for
for (int i = 0; i < 10; ++i)
{
printf("%d ", i);
}
}

#pragma omp parallel for schedule(dynamic)
for (int i = 0; i < 10; ++i)
{
printf("%d ", i);
}

#pragma omp parallel for schedule(dynamic£¬3)
for (int i = 0; i < 10; ++i)
{
printf("%d ", i);
}

int a,b;
if(GOMP_loop_dynamic_start(0,10,1,3,&a,&b))
{
do{
for(int n=a; n<b;++n) printf(" %d", n);
}while(GOMP_loop_dynamic_next(&a,&b));
}

for (int i = 0; i < 10; ++i)
{
Data data = ReadFile(files[i]);
#pragma omp ordered
PutDataToDataset(data);
}

#pragma omp parallel sections
{
{ Work1();}
#pragma omp section
{ Work2();
Work3();}
#pragma omp section
{ Work4();}
}

struct node { node *left,*right;};
externvoid process(node*);
void traverse(node* p)
{
if(p->left)
#pragma omp task // p is firstprivate by default
traverse(p->left);
if(p->right)
#pragma omp task // p is firstprivate by default
traverse(p->right);
process(p);
}

struct node { node *left,*right;};
externvoid process(node*);
void postorder_traverse(node* p)
{
if(p->left)
#pragma omp task // p is firstprivate by default
postorder_traverse(p->left);
if(p->right)
#pragma omp task // p is firstprivate by default
postorder_traverse(p->right);
#pragma omp taskwait
process(p);
}

struct node {int data; node* next;};
externvoid process(node*);
void increment_list_items(node* head)
{
#pragma omp parallel
{
#pragma omp single
{
for(node* p = head; p; p = p->next)
{
#pragma omp task
process(p);// p is firstprivate by default
}
}
}
}

#pragma omp atomic
counter += value;

#pragma omp critical(dataupdate)
{
datastructure.reorganize();
}
...
#pragma omp critical(dataupdate)
{
datastructure.reorganize_again();
}

/* presumption: int a = 0, b = 0; */
/* First thread */ /* Second thread */
b =1; a =1;
#pragma omp flush(a,b) #pragma omp flush(a,b)
if(a ==0)if(b ==0)
{{
/* Critical section */ /* Critical section */
}}

int a, b=0;
#pragma omp parallel default(none) shared(b)
{
b += a;
}

int factorial(int number)
{
int fac =1;
#pragma omp parallel for
for(int n=2; n<=number;++n)
{
#pragma omp atomic
fac *= n;
}
return fac;
}

int factorial(int number)
{
int fac =1;
#pragma omp parallel
{
int fac_private =1;
#pragma omp for nowait
for(int n=2; n<=number;++n)
fac_private *= n;
#pragma omp atomic
fac *= fac_private;
}
return fac;
}

#pragma omp parallel
{
/* All threads execute this. */
SomeCode();
#pragma omp barrier
/* All threads execute this, but not before
* all threads have finished executing SomeCode().
*/
SomeMoreCode();
}

#pragma omp parallel
{
#pragma omp for
for(int n=0; n<10;++n) Work();
// This line is not reached before the for-loop is completely finished
SomeMoreCode();
}

// This line is reached only after all threads from
// the previous parallel block are finished.
CodeContinues();

#pragma omp parallel
{
#pragma omp for nowait
for(int n=0; n<10;++n) Work();
// This line may be reached while some threads are still executing the for-loop.
SomeMoreCode();
}

// This line is reached only after all threads from
// the previous parallel block are finished.
CodeContinues();

#pragma omp parallel
{
Work1();
#pragma omp single
{
Work2();
}
Work3();
}

#pragma omp parallel
{
Work1();
// This...
#pragma omp master
{
Work2();
}
// ...is practically identical to this:
if(omp_get_thread_num()==0)
{
Work2();
}

Work3();
}

#pragma omp parallel for
for(int y=0; y<25;++y)
{
#pragma omp parallel for
for(int x=0; x<80;++x)
{
tick(x,y);
}
}

#pragma omp parallel for
for(int y=0; y<25;++y)
{
#pragma omp for // ERROR, nesting like this is not allowed.
for(int x=0; x<80;++x)
{
tick(x,y);
}
}

#pragma omp parallel for collapse(2)
for(int y=0; y<25;++y)
for(int x=0; x<80;++x)
{
tick(x,y);
}

#pragma omp parallel for
for(int pos=0; pos<(25*80);++pos)
{
int x = pos%80;
int y = pos/80;
tick(x,y);
}

omp_set_nested(1);
#pragma omp parallel for
for(int y=0; y<25;++y)
{
#pragma omp parallel for
for(int x=0; x<80;++x)
{
tick(x,y);
}
}

for(int y=0; y<25;++y)
{
#pragma omp parallel for
for(int x=0; x<80;++x)
{
tick(x,y);
}
}

constchar* FindAnyNeedle(constchar* haystack, size_t size,char needle)
{
for(size_t p =0; p < size;++p)
if(haystack[p]== needle)
{return haystack+p; //ÕÒµ½needle£¬Ö±½ÓÍ˳öº¯Êý
}
return NULL;
}

constchar* FindAnyNeedle(constchar* haystack, size_t size,char needle)
{
constchar* result = NULL;
bool done =false;
#pragma omp parallel for
for(size_t p =0; p < size;++p)
{
#pragma omp flush(done)
if(!done)
{
/* Do work only if no thread has found the needle yet. */
if(haystack[p]== needle)
{
/* Inform the other threads that we found the needle. */
done =true;
#pragma omp flush(done)
result = haystack+p;
}
}
}
return result;
}

constchar* FindAnyNeedle(constchar* haystack, size_t size,char needle)
{
constchar* result = NULL;
#pragma omp parallel for
for(size_t p =0; p < size;++p)
if(haystack[p]== needle)
result = haystack+p;
return result;
}