How to avoid double for loop when using an update definition

[Frontier789]

I have a dynamic programming problem, where a func (f)'s columns depend on the value of the column to the left. After computing this f, it's used in another func, g.

Here is a simplified version of the setup:

import halide as hl

w = 100

f = hl.Func("row_producer")
x = hl.Var("x")

r = hl.RDom([(1, w - 1)])

f[x] = hl.f32(0)
f[r] = f[r - 1] + 1

g = hl.Func("row_consumer")
g[x] = f[x] + 42

f.bound(x, 0, w)
g.bound(x, 0, w)

g.print_loop_nest()

This, however produces a double for loop:

produce row_consumer:
  for x in [0, 99]:
    produce row_producer:
      for x in [0, 99]:
        row_producer(...) = ...
      for r146 in [1, 99]:
        row_producer(...) = ...
    consume row_producer:
      row_consumer(...) = ...

I tried different scheduling options, but none really changed anything:

# f.compute_at(g, x)
# f.update().compute_with(f, x)
# f.compute_with(g, x)

I can split f and g using f.compute_root():

produce row_producer:
  for x in [0, 99]:
    row_producer(...) = ...
  for r155 in [1, 99]:
    row_producer(...) = ...
consume row_producer:
  produce row_consumer:
    for x in [0, 99]:
      row_consumer(...) = ...

However, this will be run on the GPU and in reality I have multiple update steps, therefore I'd like to avoid running so many kernels.
Ideally I would like to find a scheduling that produces the equivalent of this C code:

float g[100];

float acc = 0;

for (int x=0;x<100;x++) {
    g[x] = acc;
    g[x] += 42;
    acc += x;
}

I.e. perfectly inline f into g. How can I achieve that?

[alexreinking]

Just an immediate reaction. You can avoid initializing all those zeros with undef():

f[x] = hl.undef(hl.Float(32))
f[0] = hl.f32(0)
f[r] = f[r - 1] + 1

Doesn't solve your scheduling question yet.