From 6d1d7f95529d826ea916ac80d236f5e8616daf64 Mon Sep 17 00:00:00 2001 From: Vito Caputo Date: Sun, 29 May 2022 09:59:39 -0700 Subject: *: pivot to til_module_context_t - modules now allocate their contexts using til_module_context_new() instead of [cm]alloc(). - modules simply embed til_module_context_t at the start of their respective private context structs, if they do anything with contexts - modules that do nothing with contexts (lack a create_context() method), will now *always* get a til_module_context_t supplied to their other methods regardless of their create_context() presence. So even if you don't have a create_context(), your prepare_frame() and/or render_fragment() methods can still access seed and n_cpus from within the til_module_context_t passed in as context, *always*. - modules that *do* have a create_context() method, implying they have their own private context type, will have to cast the til_module_context_t supplied to the other methods to their private context type. By embedding the til_module_context_t at the *start* of their private context struct, a simple cast is all that's needed. If it's placed somewhere else, more annoying container_of() style macros are needed - this is strongly discouraged, just put it at the start of struct. - til_module_create_context() now takes n_cpus, which may be set to 0 for automatically assigning the number of threads in its place. Any non-zero value is treated as an explicit n_cpus, primarily intended for setting it to 1 for single-threaded contexts necessary when embedded within an already-threaded composite module. - modules like montage which open-coded a single-threaded render are now using the same til_module_render_fragment() as everything else, since til_module_create_context() is accepting n_cpus. - til_module_create_context() now produces a real type, not void *, that is til_module_context_t *. All the other module context functions now operate on this type, and since til_module_context_t.module tracks the module this context relates to, those functions no longer require both the module and context be passed in. This is especially helpful for compositing modules which do a lot of module context creation and destruction; the module handle is now only needed to create the contexts. Everything else operating on that context only needs the single context pointer, not module+context pairs, which was unnecessarily annoying. - if your module's context can be destroyed with a simple free(), without any deeper knowledge or freeing of nested pointers, you can now simply omit destroy_context() altogether. When destroy_context() is missing, til_module_context_free() will automatically use libc's free() on the pointer returned from your create_context() (or on the pointer that was automatically created if you omitted create_context() too, for the bare til_module_context_t that got created on your behalf anyways). For the most part, these changes don't affect module creation. In some ways this eases module creation by making it more convenient access seed and n_cpus if you had no further requirement for a context struct. In other ways it's slightly annoying to have to do type-casts when you're working with your own context type, since before it was all void* and didn't require casts when assigning to your typed context variables. The elimination for requiring a destroy_context() method in simple free() of private context scenarios removes some boilerplate in simple cases. I think it's a wash for module writers, or maybe a slight win for the simple cases. --- src/modules/julia/julia.c | 35 +++++++++++++++-------------------- 1 file changed, 15 insertions(+), 20 deletions(-) (limited to 'src/modules/julia') diff --git a/src/modules/julia/julia.c b/src/modules/julia/julia.c index d9cfdff..dd11f25 100644 --- a/src/modules/julia/julia.c +++ b/src/modules/julia/julia.c @@ -5,6 +5,7 @@ #include "til.h" #include "til_fb.h" +#include "til_module_context.h" /* Copyright (C) 2017 Vito Caputo */ @@ -13,12 +14,13 @@ /* 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 threshold; + til_module_context_t til_module_context; + float rr; + float realscale; + float imagscale; + float creal; + float cimag; + float threshold; } julia_context_t; static uint32_t colors[] = { @@ -65,26 +67,20 @@ static uint32_t colors[] = { }; -static void * julia_create_context(unsigned seed, unsigned ticks, unsigned n_cpus, til_setup_t *setup) +static til_module_context_t * julia_create_context(unsigned seed, unsigned ticks, unsigned n_cpus, til_setup_t *setup) { julia_context_t *ctxt; - ctxt = calloc(1, sizeof(julia_context_t)); + ctxt = til_module_context_new(sizeof(julia_context_t), seed, n_cpus); if (!ctxt) return NULL; ctxt->rr = ((float)rand_r(&seed)) / (float)RAND_MAX * 100.f; - return ctxt; + return &ctxt->til_module_context; } -static void julia_destroy_context(void *context) -{ - free(context); - -} - static inline unsigned julia_iter(float real, float imag, float creal, float cimag, unsigned max_iters, float threshold) { unsigned i; @@ -110,9 +106,9 @@ static inline unsigned julia_iter(float real, float imag, float creal, float cim /* Prepare a frame for concurrent drawing of fragment using multiple fragments */ -static void julia_prepare_frame(void *context, unsigned ticks, unsigned n_cpus, til_fb_fragment_t *fragment, til_fragmenter_t *res_fragmenter) +static void julia_prepare_frame(til_module_context_t *context, unsigned ticks, til_fb_fragment_t *fragment, til_fragmenter_t *res_fragmenter) { - julia_context_t *ctxt = context; + julia_context_t *ctxt = (julia_context_t *)context; *res_fragmenter = til_fragmenter_slice_per_cpu; @@ -137,9 +133,9 @@ static void julia_prepare_frame(void *context, unsigned ticks, unsigned n_cpus, /* Draw a morphing Julia set */ -static void julia_render_fragment(void *context, unsigned ticks, unsigned cpu, til_fb_fragment_t *fragment) +static void julia_render_fragment(til_module_context_t *context, unsigned ticks, unsigned cpu, til_fb_fragment_t *fragment) { - julia_context_t *ctxt = context; + julia_context_t *ctxt = (julia_context_t *)context; unsigned x, y; unsigned width = fragment->width, height = fragment->height; uint32_t *buf = fragment->buf; @@ -160,7 +156,6 @@ static void julia_render_fragment(void *context, unsigned ticks, unsigned cpu, t til_module_t julia_module = { .create_context = julia_create_context, - .destroy_context = julia_destroy_context, .prepare_frame = julia_prepare_frame, .render_fragment = julia_render_fragment, .name = "julia", -- cgit v1.2.3