Как реализовать параллельные вычисления рекурсивной функции с помощью openmp?

#include<iostream>
#include<omp.h>
 
using std::cout;
using std::endl;
#define count_of_count 2000000
class ParallelQuickSort {
    //keep count of threads
    int k = 0;
 
private:
    //partitioning procedure
    int partition(int *arr, int l, int r) {
        int i = l + 1;
        int j = r;
        int key = arr[l];
        int temp;
        while (true) {
            while (i < r && key >= arr[i])
                i++;
            while (key < arr[j])
                j--;
            if (i < j) {
                temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
            else {
                temp = arr[l];
                arr[l] = arr[j];
                arr[j] = temp;
                return j;
            }
        }
    }
 
public:
    void quickSort(int* arr, int l, int r) {
        if (l < r) {
            int p = partition(arr, l, r);
 
 
#pragma omp task
                {
                    k = k + 1;
                    quickSort(arr, l, p - 1);
                }
#pragma omp task
                {
                    k = k + 1;
                    quickSort(arr, p + 1, r);
                }
#pragma omp taskwait
 
        }
    }
    //prints array
    void printArr(int arr[], int n) {
        for (int i = 0; i < n; i++)
            cout << arr[i] << " ";
        cout << endl;
    }
    //run the whole procedure
    void run() {
        double endTime = 0, startTime = 0, totalTime = 0;
        int* dan;
        dan = new int[count_of_count];
        for (int i = 0; i < count_of_count; i++) {
            dan[i] = rand() % 100000;
        }
        startTime = time(NULL);
        quickSort(dan, 0, count_of_count - 1);
        endTime = time(NULL);
        cout << endTime - startTime << "\n";
    }
};
 
int main() {
    ParallelQuickSort pqs;
    pqs.run();
    return 0;
}

#include <iostream>
#include <omp.h>
#ifndef _OPENMP
static_assert(false, "openmp support required");
#endif
using namespace std;
#define count_of_count 20000000
// Function to swap two numbers a and b
void swap(int* a, int* b)
{
    int t = *a;
    *a = *b;
    *b = t;
}
 
// Function to perform the partitioning
// of array arr[]
int partition(int *arr, int start, int end)
{
    // Declaration
    int pivot = arr[end];
    int i = (start - 1);
 
#pragma omp parallel for num_threads(8)
    for (int j = start; j <= end - 1; j++) {
        if (arr[j] < pivot) {
#pragma omp critical
            {
                i++;
                swap(&arr[i], &arr[j]);
            }
            
        }
    }
    swap(&arr[i + 1], &arr[end]);
 
    // Returning the respective index
    return (i + 1);
}
 
// Function to perform QuickSort Algorithm
// using openmp
void quicksort(int *arr, int start, int end)
{
    // Declaration
    int index;
 
    if (start < end) {
 
        // Getting the index of pivot
        // by partitioning
        index = partition(arr, start, end);
        
        // Parallel sections
 
        
            
 
            
 
 
                
                    //cout << omp_get_num_threads() << "\n";
                    quicksort(arr, start, index - 1);
                
 
            
                    //cout << omp_get_num_threads() << "             222222\n";
                    quicksort(arr, index + 1, end);
                
            
        
    }
}
 
// Driver Code
int main()
{
    // Declaration
    int *dan;
    dan = new int[count_of_count];
    double endTime = 0, startTime = 0, totalTime = 0;
 
 
    cout << "Enter the array: \n";
 
    // Taking input that array
    for (int i = 0; i < count_of_count; i++) {
        dan[i] = rand() % 100000;
    }
 
    // Calling quicksort having parallel
    // code implementation
    startTime = time(NULL);
    quicksort(dan, 0, count_of_count - 1);
    endTime = time(NULL);
    cout << endTime - startTime << "\n";
    // Printing the sorted array
    cout << "Array after Sorting is: \n";
    /*for (int i = 0; i < count_of_count; i++) {
        if (i % 1000 == 0)
        {
            cout << dan[i] << " ";
        }
    }*/
    
 
    return 0;
}