wie kann ich mein quicksort als parallelen algo implementieren?

int partition(vector<int> &vec, int left, int right) {
    int pivot_index = left + rand() % (right - left + 1);
    int pivot = vec[pivot_index];

    swap(vec[pivot_index], vec[right]);  // Move pivot to end
    int store_index = left;

    for(int i = left; i < right; i++) {
    	if(vec[i] <= pivot) {
            swap(vec[store_index], vec[i]);
            store_index++;
    	}
    }

    swap(vec[right], vec[store_index]);  // Move pivot to its final place
    return store_index;
}

void quicksort(int *a, int l, int r) {
    // If the list has 2 or more items
    // sort left part
    if(l < j) {
    	// Get lists of bigger and smaller items and final position of pivot
        int pivot_index = partition(a, left, right);

        // Recursively sort elements smaller than the pivot (assume pivotNewIndex - 1 does not underflow)
        quicksort(a, left, pivot_index - 1);
        // Recursively sort elements at least as big as the pivot (assume pivotNewIndex + 1 does not overflow)
        quicksort(a, pivot_index + 1, right);
    }
}

// Recursively sort elements smaller than the pivot (assume pivotNewIndex - 1 does not underflow)
quicksort(a, left, pivot_index - 1);
// Recursively sort elements at least as big as the pivot (assume pivotNewIndex + 1 does not overflow)
quicksort(a, pivot_index + 1, right);

man koennte folgende aufrufe parallelisieren?

// Recursively sort elements smaller than the pivot (assume pivotNewIndex - 1 does not underflow)
quicksort(a, left, pivot_index - 1);
// Recursively sort elements at least as big as the pivot (assume pivotNewIndex + 1 does not overflow)
quicksort(a, pivot_index + 1, right);