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

There are a lot of errors in your code:

• (int**)calloc(x->len_delay, sizeof(int*)); should be replaced by (t_sample**)calloc(x->len_delay, sizeof(t_sample*)); idem with realloc
• You should check if the allocations failed
• realloc should not be used like this, see ref and you should free the memory of the columns before reallocating the rows
• etc.

I tried to find all my errors, corrected them and now it seemes to work.
(The method init_array is still missing a check if allocations failed.)

Do I really have to free the colums before reallocating the rows? Isn't it the other way around?

#include "m_pd.h"

#include <stdlib.h>
#include <stdio.h>
#include <math.h>

static t_class *average_tilde_class;

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

    t_int       pos;
    t_sample    **sampel_arr;
    t_sample    *avg;

    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_avg; ++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]);

    t_sample 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_avg) x->pos = 0;

    return (w + 5);
}

void resize_avg_array(t_average_tilde *x, int len_avg_new)
{
    int i,j;
    int success = 1;

    t_sample **temp = NULL;
    t_sample *temp2 = NULL;

    do {
        success = 1;

        // Allocate the columns
        temp = realloc(temp, len_avg_new * sizeof(t_sample*));

        if (temp == NULL) {
            len_avg_new--;
            free(temp);
            success = 0;
        }
        else {
            // The new column's pointer must be initialised to NULL
            for (i = 0; i < len_avg_new; i++)
                temp[i] = NULL;

            // Allocate the rows
            for (i = 0; i < len_avg_new; i++) {
                temp[i] = realloc(temp[i], x->block_size * sizeof(t_sample));

                if (temp[i] == NULL) {
                    len_avg_new--;
                    success = 0;
                    break;
                }
                else {
                    // Initialize the element(s)
                    for (j = 0; j < x->block_size; j++)
                        temp[i][j] = 0.0;
                }
            }

            if (success == 1) {

                // Initialize avg-array
                temp2 = realloc(temp2, x->block_size * sizeof(t_sample));

                if (temp2 == NULL) {
                    len_avg_new--;
                    success = 0;
                    free(temp2);
                }
                else {
                    // Initialize the element(s)
                    for (i = 0; i < x->block_size; i++)
                        temp2[i] = 0.0;
                }

                if (success == 1) {

                    // Deallocate rows
                    for (i = 0; i < x->len_avg; ++i)
                        free(x->sampel_arr[i]);
                    // Deallocate columns
                    free(x->sampel_arr);

                    // Copy temps to arrays
                    x->len_avg = len_avg_new;
                    x->sampel_arr = temp;
                    free(x->avg);
                    x->avg = temp2;
                    x->pos = 0;
                }
            }
        }
    } while (success = 0 && len_avg_new > 0);

    if (success = 0) {
        post("length of avg-vector stayed at %i samples", x->len_avg);
    }
}

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_avg != arr_size)
        resize_avg_array(x, 10);

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

void set_len_avg(t_average_tilde *x, t_floatarg f)
{
    if ((int)f > 0)
        resize_avg_array(x, f);
}

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

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

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

    // Initialize the element(s)
    for (i = 0; i < x->len_avg; 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(t_sample));
    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_avg = ((int)f > 0) ? (int)f : 10;
    x->block_size = 64;
    x->pos = 0;
    init_array(x);

    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_avg);
    class_addfloat(average_tilde_class, set_len_avg);
}

void helloworld_setup(void) {
    init_average();
}

EDIT: Corrected some logical errors in the code.
The variable success has to be set to 1 in each do while loop
The arrays x->sampel_arr and x->avg have to be freed inside the do while loop

Do I really have to free the colums before reallocating the rows?

Normally, but a good practice in C is:
Allocation:

t_sample ** matrix = (t_sample**)getbytes(nrows * sizeof(t_sample *));
if(matrix)
{
    t_sample * vector = (t_sample*)getbytes(nrows * ncols * sizeof(t_sample));
    if(vector)
    {
       for(int i = 0; i <  nrows; ++i)
       {
          matrix[i] = vector+i*ncols;
       }
    }
    else
    {
        freebytes(matrix, nrows * sizeof(t_sample *));
        matrix = NULL;
        pd_error(x, "allocation failed");
    }
}
else
{
    vector = NULL;
    pd_error(x, "allocation failed");
}

Release:

if(matrix)
freebytes(matrix, nrows * sizeof(t_sample *));
matrix = NULL;
if(vector)
freebytes(vector, nrows * ncols * sizeof(t_sample));
vector = NULL;

Reallocation:

temp_matrix = resizebytes(matrix, nrows * sizeof(t_sample *), new_nrows * sizeof(t_sample *));
if(temp_matrix)
{
        temp_vector = resizebytes(vector, nrows * ncols * sizeof(t_sample *), new_ncols * new_nrows * sizeof(t_sample));
        if(temp_vector)
        {
            vector = temp_vector;
            matrix = temp_matrix;
            nrows = new_nrows;
            ncols = new_ncols;
            for(int i = 0; i < nrows; ++i)
            {
                matrix[i] = vector+i*ncols;
            }
        }
        else
        {
            freebytes(temp_matrix, new_nrows * sizeof(t_sample *));
            freebytes(vector, nrows * ncols * sizeof(t_sample));
            vector = NULL;
            matrix = NULL;
            pd_error(x, "allocation failed");
        }
 }
else
{
    freebytes(matrix, nrows * sizeof(t_sample *));
    freebytes(vector, nrows * ncols * sizeof(t_sample));
    vector = NULL;
    matrix = NULL;
    pd_error(x, "allocation failed");
}

Your example is much better readable than mine.
Besides that, I can see the differences of our codes and the reason for me, thinking that freeing has to be done the other way around:

• You create two variables. The first one vector allocates one large array, the second matrix points to every nth field of vector. Whereas I create one variable sampel_arr (which corresponds to your matrix) and a new array for every entry of that variable. I wonder if your method of allocating one array has any performance advantages inside the perform method?

• If I would free sample_arr first, I would loose the references to the allocated arrays.

• Your code needs a larger block of free memory than mine.

• When allocation fails, my code reduces the size of the matrix and tries to allocate again. (I don't know if that makes much sense. Beeing so close to full memory might cause performance issues anyway.)

Is there any advantage of using freebytes() instead of free() except for the includes?

I wonder if your method of allocating one array has any performance advantages inside the perform method?

Yes in theory because all the sample are next to each other. If you allocate several vectors, one can be "far" from another and the memory access can be CPU expensive.

If I would free sample_arr first, I would loose the references to the allocated arrays.

No because the matrix (sample_arr) doesn't own the memory of the "real" vector. The matrix is in fact array of pointers that point to the "real" vector but it's just addresses.

Your code needs a larger block of free memory than mine.

No, you allocate n times a vector of size m and I allocate a single vector of size n*m, it's the same memory size (except the matrix that is one vector of pointers of size n that is pretty small). Anyway, nowadays the size of memory allocated isn't really a problem.

When allocation fails, my code reduces the size of the matrix and tries to allocate again. (I don't know if that makes much sense. Beeing so close to full memory might cause performance issues anyway.)

I think with modern computer and for the size of matrices you want, it's almost impossible that the allocation fail. But if it happens, in my opinion, the best is to notify that something wrong happened and to avoid the perform method. Instead of pushing the computer in its limits, the user or the developer can change and correct its approach because it means that there is an error somewhere (an error of matrix size for example).

Is there any advantage of using freebytes() instead of free() except for the includes?

No I don't think but it was used to keep a track of the global amount of allocated memory and freed so you can check if there are memory leaks in the application.

I added two examples, maxicatch~ and meanblock~, for your questions in my repository if you want to have a look.

I changed the thread title, so someone with questions about matrices might find it more easily.

Thanks for clearifications and examples. Really helpfull.

Can you make some comments about meanblock~? After looking at the code I'm not totaly shure about what you want to achieve in the perform method.
And I compiled it and get an exception when I change the length while dsp is on.
(VS tells me Schreibzugriffsverletzung (write access injury) in line 77)

I'm glad it helped. Thanks, I didn't really check the object and you're right, I did a mistake in the "length" method and I forgot a "+" in an operation of the perform method. I corrected and updated the code and I added some comments.

Comparing your code to mine, they produce exactly the same output. But your code consumes much more cpu.

(on my machine: mine <1%, yours >4%, with [switch~ 4096 64], which doesn't surprise me, as your code runs 4 loops (one is even nested), whereas mine runs 1 inside the perform method)

Pointers are still confusing me.
In my code the line:
*out++ = x->avg[n];
produces the output. As far as I understand, this sets the output pointer to x-avg[n] and increases the address of the pointer afterwards by one.

Your code assignes cout = out and increases *cout several times. In which line is the output created?

Another problem I have is to determine the size of matrix. The line:
float arr_size = sizeof(x->sampel_arr) / sizeof(x->sampel_arr[0][0]);
should have calculated the size of the matrix. But it divides the size of an pointer by a size of another pointer, which is of course always one.
If I only have pointers, is there a way to get the size of the matrix?

I've found the answer to my last question already here:
how-to-find-the-sizeofa-pointer-pointing-to-an-array

I tried the code that you posted and I don't have the same results. In fact I don't understand your results. Perhaps I'm wrong but if you give a unitary signal, the result should be this signal isn't it? And it seems that the length of your delay is always 10.
At the end of the method resize_avg_array, the success variable is assigned and not compared (success = 0) ligne 132 & ligne 134.

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.