Recursion Depth Cut Off Strategy: Parallel QuickSort - c++

Question

I have a parallel quickosort alogirthm implemented. To avoid overhead of excess parallel threads I had a cut off strategy to turn the parallel algorithm into a sequential one when the vector size was smaller than a paticular threshold. However, now I am trying to set the cut off strategy based on recursion depth. i.e I want my algorithm to turn sequential when a certain recursion depth is reached. I employed the following code, but it dosent work. I'm not sure how to proceed. Any ideas?
template <class T>
void ParallelSort::sortHelper(typename vector<T>::iterator start, typename vector<T>::iterator end, int level =0) //THIS IS THE QUICKSoRT INTERFACE
{
static int depth =0;
const int insertThreshold = 20;
const int threshold = 1000;
if(start<end)
{
if(end-start < insertThreshold) //thresholf for insert sort
{
insertSort<T>(start, end);
}
else if((end-start) >= insertThreshold && depth<threshold) //threshhold for non parallel quicksort
{
int part = partition<T>(start,end);
depth++;
sortHelper<T>(start, start + (part - 1), level+1);
depth--;
depth++;
sortHelper<T>(start + (part + 1), end, level+1);
depth--;
}
else
{
int part = partition<T>(start,end);
#pragma omp task
{
depth++;
sortHelper<T>(start, start + (part - 1), level+1);
depth--;
}
depth++;
sortHelper<T>(start + (part + 1), end, level+1);
depth--;
}
}
}
I tried the static variable depth and also the non static variable level but both of them dont work.
NOTE: The above snipped only depends on depth. level is included to show both the methods tried

Answer 1

static depth being written to from two threads makes your code execute unspecified behavior, as what those writes do is not specified.
As it happens, you are passing down level, which is your recursion depth. At each level, you double the number of threads -- so a limit on level equal to 6 (say) corresponds to 2^6 threads at most. Your code is only half parallel, because the partition code occurs in the main thread, so you will probably have fewer than the theoretical maximum number of threads going at once.
template <class T>
void ParallelSort::sortHelper(typename vector<T>::iterator start, typename vector<T>::iterator end, int level =0) //THIS IS THE QUICKSoRT INTERFACE
{
const int insertThreshold = 20;
const int treeDepth = 6; // at most 2^6 = 64 tasks
if(start<end)
{
if(end-start < insertThreshold) //thresholf for insert sort
{
insertSort<T>(start, end);
}
else if(level>=treeDepth) // only 2^treeDepth threads, after which we run in sequence
{
int part = partition<T>(start,end);
sortHelper<T>(start, start + (part - 1), level+1);
sortHelper<T>(start + (part + 1), end, level+1);
}
else // launch two tasks, creating an exponential number of threads:
{
int part = partition<T>(start,end);
#pragma omp task
{
sortHelper<T>(start, start + (part - 1), level+1);
}
sortHelper<T>(start + (part + 1), end, level+1);
}
}
}

Answer 2

Alright, I figured it out. It was a stupid mistake on my part.
The algorithm should fall back onto the sequential code when the stack size is greater than some threshold, not smaller. Doing so solves the problem, and gives me a speedup.