Is it possible to place a function call stack onto the heap?

Question

I have a recursion algorithm that may go into extrordinary depths and I don't want a stack overflow. Is there a way of storing function call stacks on the heap rather than the stack?

Answer 1

If you really want to extend your stack space, there is always pthread_attr_setstack, it is available in posix-like environments, requires you to do your work in a thread and lets you allocate as much as you want. It requires the memory to be read/write (not a problem for the heap) and somewhat aligned, consult your man pages for the exact details...

Answer 2

If you have lots of variables declared in the function to be stored on the stack, especially large arrays, you could just move the variables to the heap.

Answer 3

I have a recursion algorithm that may go into extrordinary depths and I don't want a stack overflow. Is there a way of storing function call stacks on the heap rather than the stack?

Have you explored a functor?

In the following, note that

• all (normal) functions of a class include the hidden " T* this " parameter.

• thus any data attribute of the class is directly accessible to each function.

Maybe your 'Functor packaging' can lighten the recursion stack load, eliminating much of the parameter passing between the calls.

Simple Example:

class T934c_t //  tail recursive, return string which contains step pattern,
{
   stringstream  ss;        // data attributes ALL pass function-to-function
   int64_t maxPtrnHgtWdth;  //   through the hidden this pointer.

public:
   string operator()(int64_t max)
      {
         maxPtrnHgtWdth = max;  // <<< save to functor data attributes
         exec();                // <<< filled in during execution
         return ss.str();       // return result of execution.
      }

private:
   void exec ()
      {
         ss << "\n\n\n  string T934c_t()(int64_t): -->"
            << " void exec (int64_t)     (" << maxPtrnHgtWdth
            << ")\n         tail recursive, return string which contains step pattern, ";

         execR (maxPtrnHgtWdth); // entry to recursive code
      }
   //                  8..1
   void execR (int64_t step)     // recursive 
      {
         if (0 >= step) return;  // recursion termination
         dotPndLine (step-1);    // build each line with dots and pound signs
         execR (step-1);         // tail recursion
      }
   //                       7..0
   void dotPndLine (int64_t step) // single line
      {
         ss << "\n  ";
         dotR (step);                 // 7..0  dots
         pndR (maxPtrnHgtWdth-step);  // 1..8  pound sign
         ss << ' ';
      }
   //                 7..0
   void dotR (int64_t dotCt) { // recursive
      if (0 >= dotCt) return;  // recursion termination
      ss << '.';               // simple execution
      dotR (dotCt-1);          // tail recursion
   }
   //                 1..8
   void pndR (int64_t pndCt) { // recursive
      if (0 >= pndCt)  return; // recursion termination
      ss << '#';               // simple
      pndR (pndCt-1);          // tail recursion
   }
}; // class T934c_t