Russian Qt Forum

C++ (Qt)
#pragma omp parallel for
for (int i = 0; i < N; ++i)
 DoCalcNormal(i);

C++ (Qt)
void threadFunc( void )
{
  while (true) {
   int index = theAtomicCount++;
   if (index >= maxTask) return;
   CalcNormal(index);
 }
}
 

C++ (Qt)
    const int nVolumes = volumeShells.size();
    const int nThreads = QThread::idealThreadCount() - 1;
 
    QThread** threads = new QThread* [nThreads];
    NormalSolver** solvers = new NormalSolver* [nThreads + 1];
 
    for (int i = 0; i < nThreads; ++i)
    {
        (solvers[i] = new NormalSolver)->moveToThread(threads[i] = new QThread(this));
        qDebug() << connect(threads[i], SIGNAL(started()), solvers[i], SLOT(run()));
    }
    solvers[nThreads] = new NormalSolver;
 
    volumeShellNormals.resize(nVolumes);
 
    for (int i = 0; i < nVolumes; ++i) // для каждого объёма
    {
        int nVertices = volumeShells.at(i).size();
        int nTriangles = nVertices / 3;
        int trianglesPerThread = nTriangles / (nThreads + 1);
 
        volumeShellNormals[i].resize(nVertices);
 
        const float* data = volumeShells.at(i).constData();
        float* dest = volumeShellNormals[i].data();
 
        for (int j = 0; j < nThreads; ++j)
        {
            const float* begin = data + j * trianglesPerThread,
                       * end = begin + trianglesPerThread;
            solvers[i]->setSrc(begin, end);
            solvers[i]->setDst(dest + j * trianglesPerThread);
            threads[i]->start();
        }
 
        solvers[nThreads]->setSrc(data + nThreads * trianglesPerThread, data + nVertices);
        solvers[nThreads]->setDst(dest + nThreads * trianglesPerThread);
        solvers[nThreads]->run();
 
        for (int j = 0; j < nThreads; ++j)
            threads[j]->wait();
    }
 
    for (int i = 0; i < nThreads; ++i)
    {
        delete solvers[i];
        delete threads[i];
    }
    delete solvers[nThreads];
    delete[] solvers;
    delete[] threads;
 

C++ (Qt)
    while (src != srcEnd)
    {
        // присваиваем временные имена
        const float& x0 = *(src++);
        const float& y0 = *(src++);
        const float& z0 = *(src++);
 
        const float& x1 = *(src++);
        const float& y1 = *(src++);
        const float& z1 = *(src++);
 
        const float& x2 = *(src++);
        const float& y2 = *(src++);
        const float& z2 = *(src++);
 
        // вычисляем векторы
        float a[3] = {x1 - x0, y1 - y0, z1 - z0},
              b[3] = {x2 - x0, y2 - y0, z2 - z0};
 
        const int x = 0,
                  y = 1,
                  z = 2;
        // вычисление и запись перпендикуляра
        *dest = a[y] * b[z] - a[z] * b[y];
        dest[1] = a[z] * b[x] - a[x] * b[z];
        dest[2] = a[x] * b[y] - a[y] * b[x];
 
        // вычисление длины и нормализация
        float inv_length = 1.0 / sqrt(*dest * *dest +
                                      dest[y] * dest[y] +
                                      dest[z] * dest[z]);
        *dest *= inv_length;
        dest[y] *= inv_length;
        dest[z] *= inv_length;
 
        // копирование во все вершины
        memcpy(dest + 3, dest, 3 * sizeof(float));
        memcpy(dest + 6, dest, 3 * sizeof(float));
 
        dest += 9;
    }
 

C++ (Qt)
void CalcNormals( const float * srcF, int numF, float * dstF )
{
 const QVector3D * src = (QVector3D *) srcF;
 QVector3D * dst = (QVector3D *) dstF;
 int N = numF / 3 / 3;
 
// #pragma omp parallel for
 for (int i = 0; i < N; ++i) {
   int j = i * 3;
   dst[j] = dst[j + 1] = dst[j + 2] = QVector3D::crossProduct(src[j + 1] - src[j], src[j + 2] - src[j]).normalize();
 }
}

C++ (Qt)
    int times = (srcEnd - src) / sizeof(float) / 9;
    #pragma omp parallel for
    for(int i = 0; i < times; i++)
    {
        // присваиваем временные имена
        int j = i * 9;
        const float& x0 = src[j];
        const float& y0 = src[j + 1];
        const float& z0 = src[j + 2];
 
        const float& x1 = src[j + 3];
        const float& y1 = src[j + 4];
        const float& z1 = src[j + 5];
 
        const float& x2 = src[j + 6];
        const float& y2 = src[j + 7];
        const float& z2 = src[j + 8];
 
        // вычисляем векторы
        float a[3] = {x1 - x0, y1 - y0, z1 - z0},
              b[3] = {x2 - x0, y2 - y0, z2 - z0};
 
        const int x = 0,
                  y = 1,
                  z = 2;
        // вычисление и запись перпендикуляра
        float& xNorm = dest[j] = a[y] * b[z] - a[z] * b[y];
        float& yNorm = dest[j + 1] = a[z] * b[x] - a[x] * b[z];
        float& zNorm = dest[j + 2] = a[x] * b[y] - a[y] * b[x];
 
        // вычисление длины и нормализация
        float inv_length = 1.0 / sqrt(xNorm * xNorm +
                                      yNorm * yNorm +
                                      zNorm * zNorm);
        xNorm *= inv_length;
        yNorm *= inv_length;
        zNorm *= inv_length;
 
        // копирование во все вершины
        memcpy(&xNorm + 3, &xNorm, 3 * sizeof(float));
        memcpy(&xNorm + 6, &xNorm, 3 * sizeof(float));
 
    }
 

C++ (Qt)
    while (src != srcEnd)
    {
        // присваиваем временные имена
        const float& x0 = *(src++);
        const float& y0 = *(src++);
        const float& z0 = *(src++);
 
        const float& x1 = *(src++);
        const float& y1 = *(src++);
        const float& z1 = *(src++);
 
        const float& x2 = *(src++);
        const float& y2 = *(src++);
        const float& z2 = *(src++);
 
        // вычисляем векторы
        float a[3] = {x1 - x0, y1 - y0, z1 - z0},
              b[3] = {x2 - x0, y2 - y0, z2 - z0};
 
        const int x = 0,
                  y = 1,
                  z = 2;
        // вычисление и запись перпендикуляра
        *dest = a[y] * b[z] - a[z] * b[y];
        dest[1] = a[z] * b[x] - a[x] * b[z];
        dest[2] = a[x] * b[y] - a[y] * b[x];
 
        // вычисление длины и нормализация
        float inv_length = 1.0 / sqrt(*dest * *dest +
                                      dest[y] * dest[y] +
                                      dest[z] * dest[z]);
        *dest *= inv_length;
        dest[y] *= inv_length;
        dest[z] *= inv_length;
 
        // копирование во все вершины
        memcpy(dest + 3, dest, 3 * sizeof(float));
        memcpy(dest + 6, dest, 3 * sizeof(float));
 
        dest += 9;
    }
 

C++ (Qt)
// размер "порции" 10К 
#pragma omp parallel for schedule(dynamic, 10000) 

C++ (Qt)
    int nVolumes = volumeShells.size(); // количество объёмов
    nodeElemsMap.clear();
    nodeElemsMap.resize(nVolumes);
 
    QMultiMap<int, int>* maps = nodeElemsMap.data();
    const int* pVolumeDepend = volumeDepend.constData(),
             * pElems = elems.constData();
 
    for (int i = 0; i < volumeDepend.size(); ++i)
        for (int j = i * 4; j < (i + 1) * 4; ++j)
            maps[pVolumeDepend[i]].insert(pElems[j], i);
 

C++ (Qt)
#pragma omp parallel for
    for (int i = 0; i < 100000000; ++i)
    {
        vec.append(i);
    }
 

C++ (Qt)
#pragma omp parallel for
for (int i = 0; i < 100000000; ++i)
{
#pragma omp critical
     vec.append(i);
}
 

C++ (Qt)
void Solver::CalcParallel( void )
{
  QAtomicInt numDone = 0;
 
#pragma omp parallel for
  for (int i = 0; i < data.size; ++i) {
   DoCalc(data[i]);
   ++numDone;
 
#pragma omp master
   mainWindow->UpdateNumDone(numDone);
  }
}