Распараллеливание с помощью OpenMP

for (i=1; i<number; i++)
{
  do something;
}

#include <stdio.h>
#include <iostream>
#include <time.h>
#include "TimeCounter.h"
#include <omp.h>
 
using namespace std;
 
void mode (void)
{
    if (omp_in_parallel()) cout<<"Parallel"<<endl;
    else cout<<"Posl"<<endl;
}
 
int main (void)
{
    double start, end;
    int n;
    mode();
    start = omp_get_wtime();
    omp_set_nested(1);
#pragma omp parallel private(n)
    {
        n = omp_get_thread_num();
#pragma omp parallel 
        {
            cout<<"Part 1, thread "<<n<<' '<<omp_get_thread_num()<<endl;
            mode();
        }
    }
    omp_set_nested(0);
    #pragma omp parallel private(n)
    {
        n = omp_get_thread_num();
#pragma omp parallel 
        {
            cout<<"Part 2, thread "<<n<<' '<<omp_get_thread_num()<<endl;
        }
    }
    end = omp_get_wtime();
    cout<<end-start<<endl;;
#pragma omp parallel
    {
#pragma omp master
        {
            mode();
        }
    }
}

        for (i = 0; i<1000000; i++)
        {
            for (k = 1; k<1000; k++)
            {
                g = g*k % 7321;
            }
        }

int main (int argc, char* argv[])
{
    int i, k;
    omp_set_num_threads(4);
#pragma omp parallel private(i)
    {
#pragma omp for schedule (static, 2)
        
            for (i = 0; i<10; i++)
            {
                k = omp_get_thread_num();
                cout<<k<<endl;
            }
    }
 
 
    return 0;
}

#include <iostream>
#include <omp.h>
 
int main (int argc, char* argv[])
{
    int i, k;
    const int N = 10;
    int a[N];
    omp_set_num_threads(4);
#pragma omp parallel private(i)
    {
#pragma omp for schedule (static, 2)
 
        for (i = 0; i<N; i++)
        {
            a[i] = omp_get_thread_num();
        }
    }
 
    for (i = 0; i < N; i++)
        std::cout<<a[i]<<std::endl;
 
 
    return 0;
}

#pragma omp parallel private(func, select, cross, k, m, n, t, l, i, j, sp, test, tn, A, S, best, best_num, d, a, b, s, rel, speed, B), shared (A1, A2, A3, A4, A5, A6, A7)
    {
        for (test = 0; test<100; test++)
        {
            tn = omp_get_thread_num();
            test = test + 1;
            A1[tn][test-1] = test;
            first_population(A,n,k);
            A2[tn][test-1] = average_objective_function(A,B,m,n,k,func);
            best_num=best_population_individ(A,B,m,n,k,func);
            for (i=0;i<k;i++)
            {
                best[0][i]=A[best_num][i];
            }
            for (j=0;j<t;j++)
            {
                switch(select)
                {
                case 1:
                    {
                        rank_selection(A,B,S,m,n,k,func);
                        break;
                    }
                case 2:
                    {
                        tournament_selection(A,B,S,m,n,k,func);
                        break;
                    }
                default:
                    {
                        return 0;
                    }
                }
            
                switch(cross)
                {
                case 1:
                    {
                        one_point_crossingover(A,S,n,k);
                        break;
                    }
                case 2:
                    {
                        two_point_crossingover(A,S,n,k);
                        break;
                    }
                case 3:
                    {
                        equable_crossingover(A,S,n,k);
                        break;
                    }
                default:
                    {
                        return 0;
                    }
                }
 
                for (i=0;i<k;i++)
                {
                    A[0][i]=best[0][i];
                }
 
                moderate_mutation(A,n,k);
                s=s+decode(best,B,m,k,d,func);
 
                if (sp==0)
                {
                    sp = decode(best,B,m,k,d,func);
                    if (sp==1)
                    {
                        sp=j;
                    }
                }
 
                best_num=best_population_individ(A,B,m,n,k,func);
 
                if (objective_function(A,B,m,k,best_num,func)<=objective_function(best,B,m,k,0,func))
                {
                    for (i=0;i<k;i++)
                    {
                        best[0][i]=A[best_num][i];
                    }
                }
            }
 
            A3[tn][test-1] = average_objective_function(A,B,m,n,k,func);
            A4[tn][test-1] = s/t;
            s=0;
            A5[tn][test-1] = sp;
 
            if (sp==0)
            {
                sp=t;
                // массив A6 хранит новое ебанейшее значение sp
                A6[tn][test-1] = sp;
            }
            else
            {
                A6[tn][test-1] = sp;
            }
            sp = 0;
            A7[tn][test-1] = objective_function(best,B,m,k,0,func);
        }
    }
 
// потом еще код
return 1;
}