*: use fragment generator

Rather than laying out all fragments in a frame up-front in
ray_module_t.prepare_frame(), return a fragment generator
(rototiller_fragmenter_t) which produces the numbered fragment
as needed.

This removes complexity from the serially-executed
prepare_frame() and allows the individual fragments to be
computed in parallel by the different threads.  It also
eliminates the need for a fragments array in the
rototiller_frame_t, indeed rototiller_frame_t is eliminated
altogether.

5 files changed, 83 insertions, 21 deletions

diff --git a/src/modules/julia/julia.c b/src/modules/julia/julia.c
index 3215902..f2fb87d 100644
--- a/src/modules/julia/julia.c
+++ b/src/modules/julia/julia.c
@@ -13,11 +13,12 @@
 /* TODO: explore using C99 complex.h and its types? */
 
 typedef struct julia_context_t {
-	float	rr;
-	float	realscale;
-	float	imagscale;
-	float	creal;
-	float	cimag;
+	float		rr;
+	float		realscale;
+	float		imagscale;
+	float		creal;
+	float		cimag;
+	unsigned	n_cpus;
 } julia_context_t;
 
 static uint32_t	colors[] = {
@@ -100,13 +101,21 @@ static inline unsigned julia_iter(float real, float imag, float creal, float cim
 }
 
 
+static int julia_fragmenter(void *context, const fb_fragment_t *fragment, unsigned num, fb_fragment_t *res_fragment)
+{
+	julia_context_t	*ctxt = context;
+
+	return fb_fragment_divide_single(fragment, ctxt->n_cpus, num, res_fragment);
+}
+
+
 /* Prepare a frame for concurrent drawing of fragment using multiple fragments */
-static void julia_prepare_frame(void *context, unsigned n_cpus, fb_fragment_t *fragment, rototiller_frame_t *res_frame)
+static void julia_prepare_frame(void *context, unsigned n_cpus, fb_fragment_t *fragment, rototiller_fragmenter_t *res_fragmenter)
 {
 	julia_context_t	*ctxt = context;
 
-	res_frame->n_fragments = n_cpus;
-	fb_fragment_divide(fragment, n_cpus, res_frame->fragments);
+	*res_fragmenter = julia_fragmenter;
+	ctxt->n_cpus = n_cpus;
 
 	ctxt->rr += .01;
 			/* Rather than just sweeping creal,cimag from -2.0-+2.0, I try to keep things confined
diff --git a/src/modules/plasma/plasma.c b/src/modules/plasma/plasma.c
index 9746882..b9c5cc4 100644
--- a/src/modules/plasma/plasma.c
+++ b/src/modules/plasma/plasma.c
@@ -26,6 +26,7 @@ static int32_t	costab[FIXED_TRIG_LUT_SIZE], sintab[FIXED_TRIG_LUT_SIZE];
 
 typedef struct plasma_context_t {
 	unsigned	rr;
+	unsigned	n_cpus;
 } plasma_context_t;
 
 static inline uint32_t color2pixel(color_t *color)
@@ -58,8 +59,16 @@ static void plasma_destroy_context(void *context)
 }
 
 
+static int plasma_fragmenter(void *context, const fb_fragment_t *fragment, unsigned num, fb_fragment_t *res_fragment)
+{
+	plasma_context_t	*ctxt = context;
+
+	return fb_fragment_divide_single(fragment, ctxt->n_cpus, num, res_fragment);
+}
+
+
 /* Prepare a frame for concurrent drawing of fragment using multiple fragments */
-static void plasma_prepare_frame(void *context, unsigned n_cpus, fb_fragment_t *fragment, rototiller_frame_t *res_frame)
+static void plasma_prepare_frame(void *context, unsigned n_cpus, fb_fragment_t *fragment, rototiller_fragmenter_t *res_fragmenter)
 {
 	plasma_context_t	*ctxt = context;
 	static int		initialized;
@@ -70,9 +79,8 @@ static void plasma_prepare_frame(void *context, unsigned n_cpus, fb_fragment_t *
 		init_plasma(costab, sintab);
 	}
 
-	res_frame->n_fragments = n_cpus;
-	fb_fragment_divide(fragment, n_cpus, res_frame->fragments);
-
+	*res_fragmenter = plasma_fragmenter;
+	ctxt->n_cpus = n_cpus;
 	ctxt->rr += 3;
 }
 
diff --git a/src/modules/ray/ray.c b/src/modules/ray/ray.c
index 4af9715..f442928 100644
--- a/src/modules/ray/ray.c
+++ b/src/modules/ray/ray.c
@@ -117,12 +117,38 @@ static ray_scene_t	scene = {
 static float		r;
 
 
+typedef struct ray_context_t {
+	unsigned	n_cpus;
+} ray_context_t;
+
+static void * ray_create_context(void)
+{
+	return calloc(1, sizeof(ray_context_t));
+}
+
+
+static void ray_destroy_context(void *context)
+{
+	free(context);
+}
+
+
+static int ray_fragmenter(void *context, const fb_fragment_t *fragment, unsigned num, fb_fragment_t *res_fragment)
+{
+	ray_context_t	*ctxt = context;
+
+	return fb_fragment_divide_single(fragment, ctxt->n_cpus * 64, num, res_fragment);
+}
+
+
 /* prepare a frame for concurrent rendering */
-static void ray_prepare_frame(void *context, unsigned n_cpus, fb_fragment_t *fragment, rototiller_frame_t *res_frame)
+static void ray_prepare_frame(void *context, unsigned n_cpus, fb_fragment_t *fragment, rototiller_fragmenter_t *res_fragmenter)
 {
+	ray_context_t	*ctxt = context;
+
 	/* TODO experiment with tiled fragments vs. rows */
-	res_frame->n_fragments = n_cpus * 64;
-	fb_fragment_divide(fragment, n_cpus * 64, res_frame->fragments);
+	ctxt->n_cpus = n_cpus;
+	*res_fragmenter = ray_fragmenter;
 
 	/* TODO: the camera doesn't need the width and height anymore, the fragment has the frame_width/frame_height */
 	camera.width = fragment->frame_width,
@@ -161,6 +187,8 @@ static void ray_render_fragment(void *context, fb_fragment_t *fragment)
 
 
 rototiller_module_t	ray_module = {
+	.create_context = ray_create_context,
+	.destroy_context = ray_destroy_context,
 	.prepare_frame = ray_prepare_frame,
 	.render_fragment = ray_render_fragment,
 	.name = "ray",
diff --git a/src/modules/roto/roto.c b/src/modules/roto/roto.c
index 2074414..f076188 100644
--- a/src/modules/roto/roto.c
+++ b/src/modules/roto/roto.c
@@ -25,6 +25,7 @@ typedef struct color_t {
 
 typedef struct roto_context_t {
 	unsigned	r, rr;
+	unsigned	n_cpus;
 } roto_context_t;
 
 static int32_t	costab[FIXED_TRIG_LUT_SIZE], sintab[FIXED_TRIG_LUT_SIZE];
@@ -168,8 +169,16 @@ static void init_roto(uint8_t texture[256][256], int32_t *costab, int32_t *sinta
 }
 
 
+static int roto_fragmenter(void *context, const fb_fragment_t *fragment, unsigned num, fb_fragment_t *res_fragment)
+{
+	roto_context_t	*ctxt = context;
+
+	return fb_fragment_divide_single(fragment, ctxt->n_cpus, num, res_fragment);
+}
+
+
 /* prepare a frame for concurrent rendering */
-static void roto_prepare_frame(void *context, unsigned n_cpus, fb_fragment_t *fragment, rototiller_frame_t *res_frame)
+static void roto_prepare_frame(void *context, unsigned n_cpus, fb_fragment_t *fragment, rototiller_fragmenter_t *res_fragmenter)
 {
 	roto_context_t	*ctxt = context;
 	static int	initialized;
@@ -180,8 +189,8 @@ static void roto_prepare_frame(void *context, unsigned n_cpus, fb_fragment_t *fr
 		init_roto(texture, costab, sintab);
 	}
 
-	res_frame->n_fragments = n_cpus;
-	fb_fragment_divide(fragment, n_cpus, res_frame->fragments);
+	*res_fragmenter = roto_fragmenter;
+	ctxt->n_cpus = n_cpus;
 
 	// This governs the rotation and color cycle.
 	ctxt->r += FIXED_TO_INT(FIXED_MULT(FIXED_SIN(ctxt->rr), FIXED_NEW(16)));
diff --git a/src/modules/sparkler/sparkler.c b/src/modules/sparkler/sparkler.c
index a2210dc..13b1563 100644
--- a/src/modules/sparkler/sparkler.c
+++ b/src/modules/sparkler/sparkler.c
@@ -18,6 +18,7 @@
 
 typedef struct sparkler_context_t {
 	particles_t	*particles;
+	unsigned	n_cpus;
 } sparkler_context_t;
 
 extern particle_ops_t	simple_ops;
@@ -58,12 +59,19 @@ static void sparkler_destroy_context(void *context)
 }
 
 
-static void sparkler_prepare_frame(void *context, unsigned ncpus, fb_fragment_t *fragment, rototiller_frame_t *res_frame)
+static int sparkler_fragmenter(void *context, const fb_fragment_t *fragment, unsigned num, fb_fragment_t *res_fragment)
 {
 	sparkler_context_t	*ctxt = context;
 
-	fb_fragment_divide(fragment, ncpus, res_frame->fragments);
-	res_frame->n_fragments = ncpus;
+	return fb_fragment_divide_single(fragment, ctxt->n_cpus, num, res_fragment);
+}
+
+static void sparkler_prepare_frame(void *context, unsigned ncpus, fb_fragment_t *fragment, rototiller_fragmenter_t *res_fragmenter)
+{
+	sparkler_context_t	*ctxt = context;
+
+	*res_fragmenter = sparkler_fragmenter;
+	ctxt->n_cpus = ncpus;
 
 	particles_sim(ctxt->particles);
 	particles_add_particles(ctxt->particles, NULL, &simple_ops, INIT_PARTS / 4);