L-systems as Rose Trees

Wiebe-Marten Wijnja

Summary

L-systems?
Existing Algorithms
Rose Trees?
New Algorithms
Benchmarking
Conclusions

What is an L-system?

What: Parallel Rewrite System
Why: Plants, Trees, Cells, Fractals
How:
- generation
  - (short) procedural description $\longrightarrow$ (long) string
- interpretation
  - (long) string $\longrightarrow$ 2D/3D picture/statistic/...

L-system Generation

Theory

alphabet: A set of symbols $V$

axiom: starting string $\omega \in V^+$
production rules: $P \subset V \times V^+$

Each rule is usually written as $ a \rightarrow \chi $ where:

$a$, is called the antecedent
$\chi$, is called the consequent

Context-free L-system $G = \langle V, \omega, P \rangle$

Deterministic Context-Free ('D0')

more powerful classes of L-systems expand on this

L-system Generation

Theory

alphabet: A set of symbols $V$

axiom: starting string $\omega \in V^+$
production rules: $P \subset V \times V^+$

Each rule is usually written as $ a \rightarrow \chi $ where:

$a$, is called the antecedent
$\chi$, is called the consequent

Context-free L-system $G = \langle V, \omega, P \rangle$

Generation: transforming $$ \mu = a_1 a_2\ldots a_n $$ into

$$ \nu = \chi_1 \chi_2 \ldots \chi_n $$

... and repeat as desired

to arbitrary depth $d$

Deterministic Context-Free ('D0')

more powerful classes of L-systems expand on this

L-system Generation

Example: Algae

L-system Generation

Example: Plant

L-system Generation

Algorithm

rewriteString(rules: LSystemRules, string: String) {
  string
  |> map(|symbol| lookupSymbol(rules, symbol))
  |> flatten()
}

sequentialRewrite(rules: LSystemRules, string: String, depth: ℤ) {
  if depth == 0 {
    string
  } else {
    let result <- rewriteString(string, rules);
    sequentialRewrite(rules, result, depth - 1)
  }
}

L-system Generation

Algorithm

rewriteString(rules: LSystemRules, string: String) {
  string
  |> map(|symbol| lookupSymbol(rules, symbol))
  |> flatten()
}

sequentialRewrite(rules: LSystemRules, string: String, depth: ℤ) {
  if depth == 0 {
    string
  } else {
    let result <- rewriteString(string, rules);
    sequentialRewrite(rules, result, depth - 1)
  }
}

Oof $\longrightarrow$

L-system Generation

Problems

Paralellize?
Prevent repeated work?

L-system Generation

Problems

Paralellize? $\rightarrow$ Gathering results = difficult
Prevent repeated work?

L-system Generation

Lipp-Wonka-Wimmer

lippWonkaWimmerRewrite(rules: LSystemRules, string: String, depth: ℤ)
if depth == 0 {
  string
} else {
  let rewrite_lengths <- scatterJoin(string, |string_part|
    rewriteLength(string_part, rules)
  );
  let mut result <- allocateString(∑(rewrite_lengths));
  let indexes <- prefixSum(rewrite_lengths);
  scatterJoin(⧼string, indexes, rewrite_lengths⧽, |⧼string_part, start_index, length⧽|
    let end_index <- start_index + length;
    result[start_index..end_index] <- rewriteString(string_part, rules);
  );
  lippWonkaWimmerRewrite(rules, result, depth - 1)
}

3 boundaries
- threads need to wait for slowest
still repeated work

Can we do better?

Rose Trees

'multi-way' tree
Each node has many (ordered) children

Rose Trees

'multi-way' tree
Each node has many (ordered) children

Rose Trees

'multi-way' tree
Each node has many (ordered) children

$\uparrow$ Always the same!

Rose Trees

Different L-system generation algorithms ⟶ different tree traversals
Rules are self-similar at every level ⟶ prevent repeated work!

Still holds true for more powerful classes of L-systems,
with some exceptions

TreeConquer

Depth-first tree-traversal
'Parallel Divide-And-Conquer'

treeConquerRewrite(rules: LSystemRules, string: String, depth: ℤ){
  if(depth == 0) {
    string
  } else if(*small amount of work*) {
    let result <- rewriteString(string, rules);
    treeConquerRewrite(rules, result, depth - 1);
  } else { /* string is long, large amount of work */
    let (left_half, right_half) <- splitInHalf(string);
    let (left_res, right_res) <- forkJoin(
      || treeConquerRewrite(rules, left_half, depth),
      || treeConquerRewrite(rules, right_half, depth)
    );
    concatenate(left_res, right_res)
  }
}

Penultimate

Leverage structure of rules
- same at every level
- flatten, bottom-up

penultimateRewrite(rules: LSystemRules, string: String, depth: ℤ) {
  if depth == 0 {
    string
  } else {
    let mut flat_rules <- rules;
    for depth > 1; depth <- depth - 1 {
      flat_rules <- flattenRules(rules, flat_rules);
    }
    rewriteString(string, flat_rules)
  }
}

Variant: PenultimateSquaring, based on exponentiation by squaring,

needs only $\mathcal{O}(\log(d))$ rewrites.

Benchmarking is fun!

Benchmarks

Without Peregrine, it would have taken weeks rather than days...
...if finishing at all: 16+ GB of RAM usage for some L-systems at double-digit depths
Thank you, Peregrine!