Underrun detected: 10 blocks dropped

slogan01

Hi, I am trying to implement the Stiff String on Bela. I've been having issues with blocks being dropped for a while now. So I went offline and made my code more memory efficient. Now, when I run my code it runs fine but I keep getting this message 'Underrun detected: 10 blocks dropped' and can only hear the first second of audio and this is after setting the buffer size to 4096. I am concerned that the Bela just doesn't have the processing power and I was wondering if there is a way round this. Appreciate any advice anyone can give. I have attached my code below for reference.

slogan01

#include <Bela.h>
#include "StringModel.h"

bool runOnce = true;

bool setup(BelaContext *context, void *userData)
{
	
	return true;
}

void render(BelaContext *context, void *userData)
{
	
    
    
    StringModel string;
    
    string.FirstSet(10, 1, 2e11, 7850, 0.0001, 10, 0.6, context->audioSampleRate);
    
    
    for(unsigned int n = 0; n < context->audioFrames; n++)
    {
    	string.UpdateState();
    	
    	if (runOnce)
    	{
    		string.UpdateInput(0.9, 1.0, 3.0);
	        runOnce = false;
    	}
    	
    	double out = string.Output(); 
    	
    	for(unsigned int channel = 0; channel < context->audioOutChannels; channel++)
    	{
    		audioWrite(context, n, channel, out);
    	}
    	
    }
}

void cleanup(BelaContext *context, void *userData)
{

}

slogan01

//  main.cpp
//  StringModel
//
//  Created by Sam Logan on 07/06/2023.
//

#include <iostream>
#include "StringModel.h"
/**
 This script simulates a stiff string using the FDTD method
*/
StringModel::StringModel()
{
    // Memory
    u  = udata;
    u1 = u1data;
    u2 = u2data;
    

    prev_out = 0.0;
    

    memset(udata,  0, max_string_ss * sizeof(double));
    memset(u1data, 0, max_string_ss * sizeof(double));
    memset(u2data, 0, max_string_ss * sizeof(double));
}

/**
 Sets up the physical parameters of the string

 @param T0 tension (N)
 @param L length (m)
 @param E0 young's Modulus
 @param rho0 density (kg/m^3)
 @param r0 radius (m)
 @param low_T60 low decay (s)
 @param high_T60P high decay (s)
 */
void StringModel::FirstSet(double T0, double L, double E0, double rho0, double r0, double low_T60, double high_T60P, double sampleR)
{
    

    memset(udata,  0, max_string_ss * sizeof(double));
    memset(u1data, 0, max_string_ss * sizeof(double));
    memset(u2data, 0, max_string_ss * sizeof(double));
    

    double high_T60 = high_T60P*low_T60;
    double k        = 1.0/sampleR;
    double A0       = M_PI*r0*r0;                 // cross sectional area
    double I0       = 0.25*M_PI*r0*r0*r0*r0;      // moment of inertia
    

    double kappa    = sqrt(E0*I0/(rho0*A0));    // stiffness parameter
    c        = sqrt(T0/(rho0*A0));       // wave speed
    _sig0           = 6.0*log(10.0)/low_T60;    // numerical loss parameter
    

    double z1       = (-c*c + sqrt(c*c*c*c + 4.0*kappa*kappa*(2.0*M_PI*1000.0)*(2.0*M_PI*1000.0) )) / (2.0*kappa*kappa);
    

    if(kappa<0.1) z1 = (2.0*M_PI*1000.0)*(2.0*M_PI*1000.0) / (c*c);
    if(c<0.1)     z1 = 2.0*M_PI*1000.0/kappa;
    

    double sig_1    = (6.0*log(10.0)/z1)*(1.0/high_T60 - 1.0/low_T60);
    

    _h              = sqrt(c*c*k*k + 4.0*sig_1*k + sqrt( (c*c*k*k + 4.0*sig_1*k)*(c*c*k*k + 4.0*sig_1*k) + 16.0*kappa*kappa*k*k));
    _N              = floor(L/_h);
    _h = L/_N;
    double mu       = k*kappa / (_h*_h);        // Courant number (stiffness)
    double lambda   = c*k/_h;
    

    // Check not over max array size !!
    if (_N>(max_string_ss-6))
    {
        _N = max_string_ss-6;
        std::cout<<"\nState size is larger than memory...\n";
    }
    

    double mu2    = mu*mu;
    double sik    = 1.0+_sig0*k;
    double sk     = sig_1*k/(_h*_h);
    double l2     = lambda*lambda;
    

    _B0           = (2.0 - 6.0*mu2 - 2.0*l2 - 4.0*sk ) / sik;
    _B1           = (      4.0*mu2     + l2   + 2*sk ) / sik;
    _B2           = (         -mu2                   ) / sik;
    

    _C0           = (_sig0*k - 1.0 + 4*sk ) /sik;
    _C1           = ( -2.0*sk  ) /sik;
    _C10          = ( -4.0*sk  ) /sik;
    

    _B00          = (2.0 - 5.0*mu2 - 2.0*l2 - 4.0*sk ) / sik;
    _B10          = (      2.0*mu2     + l2   + 2*sk ) / sik;
    _B100         = (      4.0*mu2 + 2.0*l2   + 4*sk ) / sik;
    _B000         = (2.0 - 2.0*mu2 - 2.0*l2 - 4.0*sk ) / sik;
    _B20          = (     -2.0*mu2                   ) / sik;
}

void StringModel::UpdateParams(double T0, double L, double E0, double rho0, double r0, double low_T60, double high_T60P, double sampleR)
{
    double high_T60 = high_T60P*low_T60;
    double k        = 1.0/sampleR;
    double A0       = M_PI*r0*r0;                 // cross sectional area
    double I0       = 0.25*M_PI*r0*r0*r0*r0;      // moment of inertia
    

    double kappa    = sqrt(E0*I0/(rho0*A0));    // stiffness parameter
    c        = sqrt(T0/(rho0*A0));       // wave speed
    _sig0           = 6.0*log(10.0)/low_T60;    // numerical loss parameter
    

    double z1       = (-c*c + sqrt(c*c*c*c + 4.0*kappa*kappa*(2.0*M_PI*1000.0)*(2.0*M_PI*1000.0) )) / (2.0*kappa*kappa);
    

    if(kappa<0.1) z1 = (2.0*M_PI*1000.0)*(2.0*M_PI*1000.0) / (c*c);
    if(c<0.1)     z1 = 2.0*M_PI*1000.0/kappa;
    

    double sig_1    = (6.0*log(10.0)/z1)*(1.0/high_T60 - 1.0/low_T60);
    

    _h              = sqrt(c*c*k*k + 4.0*sig_1*k + sqrt( (c*c*k*k + 4.0*sig_1*k)*(c*c*k*k + 4.0*sig_1*k) + 16.0*kappa*kappa*k*k));
    _N              = floor(L/_h);
    _h = L/_N;
    double mu       = k*kappa / (_h*_h);        // Courant number (stiffness)
    double lambda   = c*k/_h;
    

    // Check not over max array size !!
    if (_N>(max_string_ss-6))
    {
        _N = max_string_ss-6;
        std::cout<<"\nState size is larger than memory...\n";
    }
    

    double mu2    = mu*mu;
    double sik    = 1.0+_sig0*k;
    double sk     = sig_1*k/(_h*_h);
    double l2     = lambda*lambda;
    

    _B0           = (2.0 - 6.0*mu2 - 2.0*l2 - 4.0*sk ) / sik;
    _B1           = (      4.0*mu2     + l2   + 2*sk ) / sik;
    _B2           = (         -mu2                   ) / sik;
    

    _C0           = (_sig0*k - 1.0 + 4*sk ) /sik;
    _C1           = ( -2.0*sk  ) /sik;
    _C10          = ( -4.0*sk  ) /sik;
    

    _B00          = (2.0 - 5.0*mu2 - 2.0*l2 - 4.0*sk ) / sik;
    _B10          = (      2.0*mu2     + l2   + 2*sk ) / sik;
    _B100         = (      4.0*mu2 + 2.0*l2   + 4*sk ) / sik;
    _B000         = (2.0 - 2.0*mu2 - 2.0*l2 - 4.0*sk ) / sik;
    _B20          = (     -2.0*mu2                   ) / sik;
}




/**
 Calculates the state equation for the FDTD Stiff String and defines the boundaries
 */
void StringModel::UpdateState()
{
    int cp;
    

    // This loop will hopefully be vectorized by the compiler..
    for(cp=2;cp<(_N-1);cp++)
    {
        u[cp] = _B0*u1[cp] + _B1*( u1[cp-1] + u1[cp+1] ) + _B2*( u1[cp-2] + u1[cp+2] ) + _C0*u2[cp] + _C1*( u2[cp-1] + u2[cp+1] );
    }
    

    // Boundaries
    u[1]    = _B00*u1[1]    + _B10*u1[0]     + _B1*u1[2]    + _B2*u1[3]    + _C0*u2[1]    + _C1*(u2[0]  + u2[2]);
    

    u[_N-1] = _B00*u1[_N-1] + _B10*u1[_N]    + _B1*u1[_N-2] + _B2*u1[_N-3] + _C0*u2[_N-1] + _C1*(u2[_N] + u2[_N-2]);
    

    u[0]    = _B000*u1[0]   + _B100*u1[1]    + _B20*u1[2]                  + _C0*u2[0]    + _C10*u2[1];
    

    u[_N]   = _B000*u1[_N]  + _B100*u1[_N-1] + _B20*u1[_N-2]               + _C0*u2[_N]   + _C10*u2[_N-1];
    

}

/**
 Defines the position and scale of the 'pluck' of the string
 
 @param inpos input position (where the string is plucked)
 @param fin output position
 @param scale the amplitude of the pluck
 */
void StringModel::UpdateInput(double inpos,double fin,double scale)
{
    int in_cell = floor(inpos*(_N + 1)) - 1;
    

    u[in_cell]+= fin*scale;
}


/**
Reads the output and shifts the state
 */
double StringModel::Output()
{
    double read = u[10];
    

    // Differentiate the output
    double output = read - prev_out;
    

    prev_out = read;
    

    // swap pointers
    double *dummy_ptr;
    dummy_ptr = u2;
    u2 = u1;
    u1 = u;
    u = dummy_ptr;
    

    return output;
}
```~

slogan01

//  StringModel.h
//  StringModel
//
//  Created by Sam Logan on 07/06/2023.
//

#ifndef StringModel_h
#define StringModel_h

#pragma once
#define max_string_ss 1000
#define scaleamp_string 1e10
#include <string.h>
#include <math.h>
class StringModel
{
    
public:
    
    StringModel();
    
    
    void FirstSet(double T0,                                                 // Tension (N)
             double L,                                                  // Length (m)
             double E0,                                                 // Young's modulus  2e11
             double rho0,                                               // Density (kg/m^3) 7850
             double r0,                                                 // Radius (m)       0.001
             double low_T60,                                            // Decay low T60 (sec)
             double high_T60P,
             double sampleR);                                         // Decay high T60 (% of T60_low)
    
    void UpdateParams(double T0,                                                 // Tension (N)
             double L,                                                  // Length (m)
             double E0,                                                 // Young's modulus  2e11
             double rho0,                                               // Density (kg/m^3) 7850
             double r0,                                                 // Radius (m)       0.001
             double low_T60,                                            // Decay low T60 (sec)
             double high_T60P,
             double sampleR);                                         // Decay high T60 (% of T60_low)
    
    
    void UpdateState();
    
    void UpdateInput(double inpos,                                      // Input position (range 0 ~ 1)
                     double fin,                                        // Input value
                     double scale);                                     // Scalar
    
    double Output();
        
private:
    
    // State Memory
    double *u, *u1, *u2;    // scheme variables
    alignas(32) double udata[max_string_ss];
    alignas(32) double u1data[max_string_ss];
    alignas(32) double u2data[max_string_ss];
    
    double c;   // wave speed
    double prev_out;
    double _h, _sig0; // grid spacing and numerical loss parameter
    
    // derivative operators
    double _B0, _B1, _B2, _C0, _C1, _C10;
    double _B00, _B10, _B100, _B000, _B20;
    int _N;     // number of segments
    
};
#endif /* StringModel_h */

giuliomoro

at first sight, using double precision operands for arithmetics and the double version of transcendental functions and several of these for each sample is almost guaranteed to be very slow. I would recommend that you run your code adding the following to the custom command line options of the program:

 --board=Batch --codec-mode="s=1,p=95,t=2"

this will run the program in batch mode for 2 seconds and report a CPU usage figure.

Then I'd try to switch to all single precision (and the f suffix version of the transcendentals, like powf, sqrtf etc). See how much the performance improves there. If it's still too far from being under 100 %, the next step would be to use the optimised (and approximate) versions of these functions. See here for instructions, the ranges that they have been tested in and expected performance gains and errors.

If your algorithm relies on double-precision operations then I am afraid, it may be beyond the capabilities of the board at this moment.