Can this recursive function take less stack space (without rewriting as a loop)? - recursion

Question

I've got some code which is running for a while and then throwing stack overflow errors. Based on the behavior and debugging, I do not think this is a case of infinite recursion, but instead of deep (but finite) and inefficient recursion.
I'm pretty convinced the following code is to blame:
fn get_descendant_leaves(&self, p: Point) -> Vec<Point> {
let children = self.get_children(p);
if children.is_empty() {
vec![p]
} else {
children
.iter()
.map(|child_p| self.get_descendant_leaves(child_p.0))
.flatten()
.collect()
}
}
Note the recursive self.get_descendant_leaves call. get_children is a non-recursive function that does a little work to recompute immediate children based on what's stored at that location (maximum of 8, usually more like 1-3). Don't worry about the self parameter - there is a lot of information hiding behind it, but here it is only needed to compute the children of a given point.
I've found that the above function hits a depth of 2-3k simultaneously from multiple threads immediately before the program crashes, which is why I'm convinced it is to blame.
I'm sure I could fix this by manually re-implementing the function to instead loop with a couple of mutable vectors - one of discovered leaves, and one of non-leaves that still need to be explored. However, I sort of suspect that this is something Rust could do for me, were I only treating it more kindly.
Is there something I could do to represent this to rust in a way that would automatically avoid the growing call stack? I'm wondering if I handled the flatten or collect differently, maybe rust's iter could would automatically handle this in a way similar to the manual solution described above. (My reasoning is that because the recursive call is in a closure that could(?) be called lazily, this seems like something the compiler might be able to unwind on its own.)
(It has to run for an hour or more to grow complex enough to crash, so experimentation is slow.)
Bonus question: Debugging this to this state took me forever, using a mix of printlns and lldb's thread backtrace to see where things were when stuff exploded. What else should have been in my toolkit for investigating this? Googling "how to diagnose rust stack overflow" turned up mostly discouraging results.
EDIT: here's a parallel structure to make debugging more fruitful. Similarly to the code above, it recursively explores a tree, building a flattened vector from "leaves" where the base condition is met.
In the example case, the "tree" exists only in theory, but can be though of as a fibbonachi-esque tree where Tree(i) has as children Tree(i-1) and Tree(i-2) for i >=1, with Tree(1) and Tree(0) as leaves.
Can this be done keeping the recursive function definition, but in such a way that Rust does not actually explode the stack in computing it?
fn main() {
let awful = awful_vec_builder(10, 0);
println!("See it's awful: {:?}", awful);
println!("Let's smash the stack:");
let more_awful = awful_vec_builder(5000, 0);
println!("Please don't reach this case: {}", more_awful.len())
}
fn awful_vec_builder(i: usize, depth: usize) -> Vec<usize> {
if i < 2 {
vec![depth]
//Note that using vec![] here still overflows the stack
} else {
let v = vec![i - 1, i - 2];
v.iter()
.map(|i| awful_vec_builder(*i, depth + 1))
.flatten()
.collect()
}
}

Answer 1

I think the biggest problem in your implementation is the repeated flatten and collect calls. Why do those? You basically re-construct the vector in every single call.
Instead, pass the result vector through and write directly into it:
fn main() {
let awful = awful_vec_builder(10, 0);
println!("See it's awful: {:?}", awful);
println!("Let's smash the stack:");
let more_awful = awful_vec_builder(5000, 0);
println!("Please don't reach this case: {}", more_awful.len())
}
fn awful_vec_builder(i: usize, depth: usize) -> Vec<usize> {
fn awful_vec_builder_impl(i: usize, depth: usize, result: &mut Vec<usize>) {
if i < 2 {
result.push(depth);
} else {
let v = vec![i - 1, i - 2];
for i in v {
awful_vec_builder_impl(i, depth + 1, result);
}
}
}
let mut result = Vec::new();
awful_vec_builder_impl(i, depth, &mut result);
result
}
See it's awful: [9, 9, 8, 8, 8, 8, 8, 7, 8, 8, 7, 7, 7, 8, 8, 7, 7, 7, 7, 7, 6, 8, 8, 7, 7, 7, 7, 7, 6, 7, 7, 6, 6, 6, 8, 8, 7, 7, 7, 7, 7, 6, 7, 7, 6, 6, 6, 7, 7, 6, 6, 6, 6, 6, 5, 8, 8, 7, 7, 7, 7, 7, 6, 7, 7, 6, 6, 6, 7, 7, 6, 6, 6, 6, 6, 5, 7, 7, 6, 6, 6, 6, 6, 5, 6, 6, 5, 5, 5]
Let's smash the stack:
... hangs for a really long time ...
For your first example, here is some boilerplate code that makes it actually compile and crash, as specified:
fn main() {
let tree = Tree;
let awful = tree.get_descendant_leaves(Point { i: 10, depth: 0 });
println!("See it's awful: {:?}", awful);
println!("Let's smash the stack:");
let more_awful = tree.get_descendant_leaves(Point { i: 5000, depth: 0 });
println!("Please don't reach this case: {}", more_awful.len())
}
struct PointWrapper(Point);
#[derive(Debug, Copy, Clone)]
struct Point {
i: usize,
depth: usize,
}
struct Tree;
impl Tree {
fn get_children(&self, p: Point) -> Vec<PointWrapper> {
if p.i < 2 {
vec![]
} else {
vec![
PointWrapper(Point {
i: p.i - 1,
depth: p.depth + 1,
}),
PointWrapper(Point {
i: p.i - 2,
depth: p.depth + 1,
}),
]
}
}
fn get_descendant_leaves(&self, p: Point) -> Vec<Point> {
let children = self.get_children(p);
if children.is_empty() {
vec![p]
} else {
children
.iter()
.map(|child_p| self.get_descendant_leaves(child_p.0))
.flatten()
.collect()
}
}
}
Similar to my other example, you could fix it like this:
fn get_descendant_leaves(&self, p: Point) -> Vec<Point> {
fn get_descendant_leaves_impl(this: &Tree, p: Point, result: &mut Vec<Point>) {
let children = this.get_children(p);
if children.is_empty() {
result.push(p);
} else {
for child_p in children {
get_descendant_leaves_impl(this, child_p.0, result);
}
}
}
let mut result = Vec::new();
get_descendant_leaves_impl(self, p, &mut result);
result
}
That said, if there is a recursive solution, there is always a better iterative solution.
Like this one:
fn get_descendant_leaves(&self, p: Point) -> Vec<Point> {
let mut result = Vec::new();
let mut queue = Vec::new();
queue.push(p);
while let Some(p) = queue.pop() {
let children = self.get_children(p);
if children.is_empty() {
result.push(p);
} else {
queue.extend(children.into_iter().map(|child| child.0).rev())
}
}
result
}