EDIT:
The original thread title was: Interrupt/disable perform method while reallocating memory
I changed it, as it was based on searching for a solution caused by faulty code.
After discarding my code the topic of the thread got a new direction.

Hi,

I try to write an external, which calculates the averages of samples at their positions over time.

For example:
With average time = 3:
3 signals given over 3 blocks: [1, 3, 5 ...], [2, 4, 6...],[1, 3, 5...] should result in [1.33, 3,33, 5,33, ...]

The example code below works, as long as I don't try to resize the average time to a lower value while dsp is running.
On changing the average time while dsp is on, my code reallocates memory for the average vector. The result is an exception in the perform method in line 53 x->avg[n] -= x->sampel_arr[x->pos][n];

The commented lines using x->busy were an attempt to use a switch. But the code of the switch is never used, so it doesn't work.

Does anybody have an idea how to bypass the perform method while memory is reallocated?

#include "m_pd.h"
#include <string.h>
#include <stdlib.h>


static t_class *average_tilde_class;

typedef struct _average_tilde {
    t_object    x_obj;
    t_int       len_delay;
    t_int       block_size; 

    t_int       pos;
    t_sample    **sampel_arr;
    t_float     *avg;
    t_int       busy;

    t_inlet*    x_in;
    t_outlet*   x_out;

} t_average_tilde;

void average_tilde_free(t_average_tilde *x)
{   
    // Deallocate rows
    for (int i = 0; i < x->len_delay; ++i)
        free(x->sampel_arr[i]);
    // Deallocate columns
    free(x->sampel_arr);
    // Deallocate avg
    free(x->avg);
}

t_int *average_tilde_perform(t_int *w)
{   
    t_average_tilde *x = (t_average_tilde *)(w[1]);
    t_sample        *in = (t_sample *)(w[2]);
    t_sample        *out = (t_sample *)(w[3]);
    int             block = (int)(w[4]);

    /*if (x->busy == 1) {
        while (block--) {
            *out++ = *in++;
        }
        return (w + 5);
    };*/


    float val;

    for (int n = 0; n < x->block_size; n++) {

        x->avg[n] -= x->sampel_arr[x->pos][n];
        val = in[n] / x->block_size;
        x->avg[n] += val;
        x->sampel_arr[x->pos][n] = val;

        *out++ = x->avg[n];
    }

    x->pos++;
    if (x->pos == x->len_delay) x->pos = 0;

    return (w + 5);
}

void resize_avg_array(t_average_tilde *x)
{
    int i,j;

    /*post("resize");
    x->busy = 1;*/

    // Allocate the columns
    x->sampel_arr = (int**)realloc(x->sampel_arr, x->len_delay * sizeof(int*));

    /*if (x->sampel_arr == NULL)
        post("error");*/

    // The new column's pointer must be initialised to NULL
    for (i = 0; i < x->len_delay; i++)
        x->sampel_arr[i] = NULL;

    // Allocate the rows
    for (i = 0; i < x->len_delay; i++) {
        x->sampel_arr[i] = (float*)realloc(x->sampel_arr[i], x->block_size * sizeof(float));
        /*if (x->sampel_arr == NULL)
            post("error");*/
    }
        

    // Initialize the element(s)
    for (i = 0; i < x->len_delay; i++)
        for (j = 0; j < x->block_size; j++)
            x->sampel_arr[i][j] = 0.0;

    // Allocate avg-array
    x->avg = realloc(x->avg, x->block_size * sizeof(float));

    /*if (x->avg == NULL) 
        post("error");*/

    // Initialize avg-array
    for (i = 0; i < x->block_size; i++)
        x->avg[i] = 0.0;

    /*x->busy = 0;
    post("resize2");
    post(" ");*/

}

void average_tilde_dsp(t_average_tilde *x, t_signal **sp)
{
    x->block_size = sp[0]->s_n;

    float arr_size = sizeof(x->sampel_arr) / sizeof(x->sampel_arr[0][0]);

    if (x->block_size * x->len_delay != arr_size)
        resize_avg_array(x);

    dsp_add(average_tilde_perform, 4, 
        x,
        sp[0]->s_vec,
        sp[1]->s_vec,
        sp[0]->s_n);    
}

void set_len_delay(t_average_tilde *x, t_floatarg f)
{
    if ((int)f > 0) x->len_delay = (int)f;
    resize_avg_array(x);
}

void init_array(t_average_tilde *x)
{   
    int i = 0, j = 0;

    // Allocate the columns
    x->sampel_arr = (int**)calloc(x->len_delay, sizeof(int*));

    // Allocate the rows
    for (i = 0; i < x->len_delay; i++)
        x->sampel_arr[i] = (float*)calloc(x->block_size, sizeof(float));

    // Initialize the element(s)
    for (i = 0; i < x->len_delay; i++)
        for (j = 0; j < x->block_size; j++)
            x->sampel_arr[i][j] = 0.0;

    // Initialize avg-array
    x->avg = realloc(x->avg, x->block_size * sizeof(float));
    for (j = 0; j < x->block_size; j++)
        x->avg[j] = 0.0;
}

void *average_tilde_new(t_floatarg f)
{
    t_average_tilde *x = (t_average_tilde *)pd_new(average_tilde_class);

    // initialize values with defaults
    x->len_delay = ((int)f > 0) ? (int)f : 10;
    x->block_size = 64;
    x->pos = 0;
    init_array(x);
    x->busy = 0;

    x->x_out = outlet_new(&x->x_obj, &s_signal);

    return (void *)x;
}

void init_average(void) {
    average_tilde_class = class_new(gensym("r_avg~"),
        (t_newmethod)average_tilde_new,
        (t_method)average_tilde_free,
        sizeof(t_average_tilde),
        CLASS_DEFAULT,
        A_DEFFLOAT, 0);

    class_addmethod(average_tilde_class,
        (t_method)average_tilde_dsp, gensym("dsp"), 0);
    CLASS_MAINSIGNALIN(average_tilde_class, t_average_tilde, len_delay);
    class_addfloat(average_tilde_class, set_len_delay);
}

void helloworld_setup(void) {
    init_average();
}```

// The code for reallocation is taken from here:
// http://hesham-rafi.blogspot.de/2009/02/resize-2d-matrix-using-realloc.html

You can optimize my code but it's mostly for didactic purposes so I think it's better to have something clear than optimized but unreadable. In fact you'll find frequently that the first rule of code optimization is "don't",
I tried 64 of my objects with a length of 10 and a vector size of 64, and my CPU load is around 18% and the same with your objects is around 28% with no optimization. And with optimizations (-o3), around 9% for me and around 24% for yours . But I don't really trust the CPU time in Pd (without anything I'm already at 6-7%). In fact, benchmarks for this are really boring and complicated to implement and depend on a lot of thing (number of instances, vector size, length of the delay, machine, optimizations, etc.).

Ligne 89, the pointer to the output *out is created. Then I use a temporary address *cout that can be increment and when I want to go back to the first sample of the output I do cout = out (ligne 126 for example).

My code still has some errors, i.e. val = in[n] / x->block_size; line 46 should be val = in[n] / x-> len_avg;
I already corrected them on my machine. I will post some working code soon.

@Pierre-Guillot said:

In fact you'll find frequently that the first rule of code optimization is "don't",

I agree.

I don't really trust the CPU time in Pd (without anything I'm already at 6-7%). In fact, benchmarks for this are really boring and complicated to implement and depend on a lot of thing (number of instances, vector size, length of the delay, machine, optimizations, etc.).

I also agree. Nevertheless for me performance really matters.
I'm busy with live effects for speech. A lot of calculation is done in frequency domain, which is quite cpu intense. Therefore I always keep an eye on optimizations. I calculated MFCCs for example. It can be done in pure pd, but my patch looks horrible. I won't understand what I've done in a couple of month. In Python, which I know quite well, it would be some lines of code, but Python is too slow. That's why I stepped over to C.

P.S: Before I started with pd I tried Reaktor. Reaktor can show the cpu time for every single object. Even if it's not perfectly precise, it's a nice feature and helps with searching for bottlenecks.

Yes, I understand. Perhaps we can create a new thread about C optimizations for real time audio. Anyway, here are some of things I do when I try to optimize my code (because I also do it sometimes ):

• Create local variables on the stack of the perform function. For example if I need to read (usually several times) the member value of my object like this x->f_value, I prefer to use a local variable float value = x->f_value and to use this new valuevariable.

• Declare the variable only when they are necessary. For example, if I need to use a temporary float value at the middle of the perform method , I will declare it just before using it. But in fact, I mostly use this in C++ because in C, I encountered compilers without the C99 support and it was awful to debug and now I declare everything at the beginning of the function...

• Avoid memory access and especially to non-adjacent memory. For example, the matrix approach that I explained is also better because you can read all the matrix by using and incrementing a single pointer (the first cell of the next row is just after the last cell of the previous one). Another example about memory access can be the use of trigonometric functions that seems to be more efficient nowadays than to create a buffer and to interpolate. Last example, if you have for example a buffer and you want to read at specific location and to write in another instead of doinf something like that:

for(...) {
    val1?? = *read_ptr++;
    *write_ptr++ = val2??;
}

sometimes it's better to have two loops because the memory access is adjacent

for(...) {
    val1?? = *read_ptr++;
}
for(...) {
    *write_ptr++ = val2??;
}

• Unroll the loop (but normally the modern compilers can do it automatically). Miller Puckette uses it a lot for basic arithmetic objects (+, -, etc.). In the dsp method, he checks if the number of samples is a multiple of 8 and if so, he uses a specific method where the loops are optimized by increment the pointers by 8 samples. That allows to optimize the code because the processors have specific instructions for this kind of approach (see SMID).

I'll try to publish an optimized version of my perform function if you want.

Small comment: you should pay attention to the precision of the floating-point numbers. After a while, you can have bad results because you increment and decrement the avg value instead of calculating the average at each block. With a computer, something like a + b + c - a is not necessarily equal to b + c because a - a can be not null. And after a lot of time, you equation looks like a1 + a2 + a3 + ... + a10009 + a10010 - a1 - a2 - a3 - ... - a10000, so you can encounter a lot of approximations.

EDIT:
Sorry, I didn't see your last post when I posted this.

I uploaded my code here:
https://github.com/XRoemer/puredata/tree/master/average~

When you download the zip, you'll find the code I compiled in the folder average~/C.
If you are on windows, there's already a compiled .dll

You should be able to open test.pd
You might copy a .wav file into the folder average~/pd_patches/tools for testing.

I've got two issues with your code:

• setting length to 100 makes pd unusable, cpu > 100%
• I get exceptions when I change the length while dsp is on.

I think, the performance issue is caused by this lines:

// For each row i of the matrix, adds to the index j of the output vector
    // the value of the column j, like output[j] += matrix[i][j]
    for(i = 0; i < nrows; ++i)
    {
        cout = out;
        for(j = 0; j < n; ++j)
        {
            *cout++ += *read++;
        }
}

With [switch~4096 64] and a length of 100 your loop does 409600 actions on each dsp tick (length 64).

In the test.pd there's an array $0-differnce which tracks the differences between your method and mine. When you set both objects to the same length, the differences are close to 0. (Not exactly 0. Maybe floating point errors?)

My code is still missing a solution for the perform method in case, reallocation failed. I've seen yours if(!dspmethod), but didn't fully understand it yet.

I am on Mac so I had to compile your code so perhaps I don't have the same results. I renamed your object "paverage~" for my tests. Here are the kind of errors that I got over time with your object:

Depending on what you want to do, this can be unwanted or not. You just need to be aware of it.

If I don't activate optimizations, your code is more efficient. For your tests (block size 4096 and overlapping 64), I have something like ~30% for your object and more than 50% for mine. But if I activate optimizations (-o3 on Mac/Linux, /o2 I think on Windows), mine is ~15% and yours is ~25%. But I think, if you keep the same approach (using the buffer for the average) and you use some of the recommandations I made just before, you can optimize much more your code (with few basic changes, I achieved to get ~10% with your approach ).

ligne 240 of your code, you should replace resize_avg_array(x, 10, 0); with resize_avg_array(x, x->len_avg, 0); otherwise the float argument at the creation is ignored and you have to set the length manually.

I get exceptions when I change the length while dsp is on.
I can't recreate the error, are you sure you use the object compiled with the last version of the code. Sometimes on Windows, you really need to clean the project before compiling otherwise the modifications are not taken into account.

The dspmethod argument is used to tell if the function is called in our dsp method. If the allocation failed, the buffer are null and I need to avoid the perform method. If the dsp is off, there is no problem. But if the dsp is running, I need to notify Pd to stop and recompile the chain and to recall our dsp method that will say that the perform method can't be called. But, as in the dsp method we call the buffer allocation function, this can create a loop (imagine that the allocation fails again, so it tells to Pd to recompile the dsp chain, and in our dsp method we recall the buffer allocation function that fails again, so it tells to Pd to recompile the dsp chain, etc.). So the dspmethod argument is used to tell even if the dsp seems to be on because the dsp is compiling and the allocation fails don't notify Pd.

Perhaps we can create a new thread about C optimizations for real time audio.

I would appreciate that, although I wouldn't be much of a help.

I can't recreate the error, are you sure you use the object compiled with the last version of the code. Sometimes on Windows, you really need to clean the project before compiling otherwise the modifications are not taken into account.

I used your updated code, cleaned and rebuilded the project. Still get exceptions, with and without optimizations.
After some exceptions I sometimes have to restart the computer, as pd reacts strange on restarting the debugger.
As I said, I'm new to C and therefore to compiling as well.
I'm on win7, pd 0.47.1, Virtual Studio 2017 RC

I tried to follow your advise and implemented the average with one large vector. But I get errors as well - VS tells me, symbols are missing, but doesn't point me to a specific line.
My code is here:
https://github.com/XRoemer/puredata/blob/master/average~/C/r_average~2 -not working.h
EDIT2:
I made a stupid mistake: forgot to reallocate the avg array. I'll update the code.

EDIT:
I had to leave out EXTERN on meanblock_tilde_setup, as I couldn't compile with it. But I guess this is for CPP only, isn't it?
Also I compiled your meanblock as meanblock.h and not as meanblock.c

I updated and cleaned the code. It works now.
https://github.com/XRoemer/puredata/blob/master/average~/C/r_average~2.h
With a freshly started windows, no other applications started except pd, my object, compiled with optimizations, doesn't consume any remarkable cpu performance on my machine.

After 10 min running my test patch floating point errors are still below 0.00001. It depends on what you're doing of course, but I can live with that.

I still have to figure out what you wrote about dspmethod argument. For the moment there is an if statement in the perform method, which bypasses calculations, when reallocation failed and x->matrix is NULL. In terms of optimization, I guess it would be better, to tell pd, not to use the perform method. I don't know, if that's possible.

yes, I remember the compilation fails on Visual Studio if your dll is loaded by an application so if Pd is running a patch with your external you can't compile before closing Pd.

You still don't use the realloc method properly. The method is for reallocation, so you should give it the pointer to the memory you want to resize.
Something like

temp_vector = realloc(x->vector, len_avg_new * x->block_size * sizeof(t_sample*));
if (temp_vector) {
   // allocation succeed
   x->vector = temp_vector;
}
else
{
    // allocation failed but x->vector isn't freed so you have the choice, 
    // you can free it or continue to use the memory allocated.
   free(x->vector);
   x->vector = NULL;
}

With the first, x->vector should be set to NULL, this way the method will acts like malloc. In your code, you allocate new memory each time you resize the arrays without releasing them thus you have a lot of memory leaks.

Small esthetic remark: you can remove x_in and x_out in your object's structure, you never use it (and use directly outlet_new(&x->x_obj, &s_signal); without x->x_out = before).

@Pierre-Guillot said:

You still don't use the realloc method properly. The method is for reallocation, so you should give it the pointer to the memory you want to resize.
In your code, you allocate new memory each time you resize the arrays without releasing them thus you have a lot of memory leaks.

Sorry, I can't see my error. I think, lines 116-119 do free the allocated memory:

if (x->matrix) free(x->matrix);
    if (x->vector) free(x->vector);
    x->vector = temp_vector;
    x->matrix = temp_matrix;

VS shows me the process memory. When I do produce memory leaks, the process memory should raise, I guess. But with my code it corresponds to the size of the matrix. So lowering the sample length lowers the memory also.

With the first, x->vector should be set to NULL, this way the method will acts like malloc.

OK. I added x->matrix = NULL; x->vector = NULL; to the method average_init_arrays

My updated code is here:
https://github.com/XRoemer/puredata/blob/master/average%7E/C/r_average%7E2.h
(I also changed the method average_resize_arrays from:

void average_resize_arrays(t_average_tilde *x, t_floatarg f) {

    x->row = 0;
    x->len_avg = f;

    average_resize_avg(x, f);
    average_resize_matrix(x, f);

    if (!x->avg && !x->matrix) {
        x->matrix = NULL;
        pd_error(x, "allocation failed");
    }
}

to:

void average_resize_arrays(t_average_tilde *x, t_floatarg f) {

    x->row = 0;
    x->len_avg = f;

    average_resize_avg(x, f);
    average_resize_matrix(x, f);

    if (!x->avg || !x->matrix) {
        if (x->matrix) free(x->matrix);
        if (x->vector) free(x->vector);
        x->matrix = NULL;
        x->vector = NULL;
        pd_error(x, "allocation failed");
    }
}

Sorry, I can't see my error. I think, lines 116-119 do free the allocated memory:

Sorry I didn't notice these lines but you still use realloc like malloc (you never reallocate memory, you only allocate because the pointer you give to the function is always null), so you should change all the function with malloc, for example:

temp_vector = realloc(temp_vector, len_avg_new * x->block_size * sizeof(t_sample*));

by

temp_vector = malloc(len_avg_new * x->block_size * sizeof(t_sample*));

I see - I corrected the code.

Again, thanks a lot for your help.