Зависает часть кода - Visual Studio

bool        FormModel(int profile_id, float FDDS = 0.0, float FADC = 0.0, float FFPGA = 0.0, float FFRRW = 0.0);

bool COrwellR_DSP::FormModel(int profile_id, float fdds, float fadc, float ffpga, float ffrrw)
{
    if (profile_id >= kProfilesNumber || profile_id != m_signals[profile_id].profile.id || profile_id <= 0)
    {
        return false;
    }
 
    float cur_fadc, cur_fdds, cur_ffpga, cur_ffrrw;
    if (fdds > 0.0)
        cur_fdds = fdds*1000000;
    else
        cur_fdds = kFrequencyDDS;
 
    if (fadc > 0.0)
        cur_fadc = fadc*1000000;
    else
        cur_fadc = kFrequencyADC;
 
    if (ffpga > 0.0)
        cur_ffpga = ffpga*1000000;
    else
        cur_ffpga = kFrequencyFPGA;
 
    if (ffrrw > 0.0)
        cur_ffrrw = ffrrw*1000000;
    else
        cur_ffrrw = kFrequencyFRRW;
 
    bool            res=false;
    float           signalModelRe[kOrwrMaxRange];
    float           signalModelIm[kOrwrMaxRange];
    float           window[kOrwrMaxRange];
    float           p;
    int32_t         clc_koeff = static_cast<int32_t>(cur_fadc/cur_ffpga);
    int32_t         freq_koeff = static_cast<int32_t>(cur_fdds/cur_fadc);
    //IPP
    IppStatus       r0 = ippStsNoErr, r1 = ippStsNoErr, r2 = ippStsNoErr;
 
    memset(signalModelRe, 0, kOrwrMaxRange*sizeof(float));//zero desired signal 
    memset(signalModelIm, 0, kOrwrMaxRange*sizeof(float));
 
    if (!m_init_ipp)
    {
        m_init_ipp = true;
        //инициализация ipp
        ippStaticInit();
        int32_t fft_size_ln = static_cast<int> ((log10f(static_cast<float>(kFFTmin))/log10f(2.0f))+0.5f);
        for (int i=0; i<kFFTbuffers; ++i,++fft_size_ln)
        {
            r0 = ippsFFTInitAlloc_C_32f(&m_fft_spec[i], fft_size_ln, IPP_FFT_DIV_BY_SQRTN, ippAlgHintAccurate);  //FFT-2048
            r2 = ippsFFTGetBufSize_C_32f(m_fft_spec[i],&m_ipp_buffer_size[i]);
            m_ipp_buffer[i].reset(new char[m_ipp_buffer_size[i]]);
            if ( r2 != ippStsNoErr || r0 != ippStsNoErr   )
            {
                m_init_ipp = false;
            }
        }
    }   
 
    memset(m_modelsRe[profile_id].get(), 0, m_signals[profile_id].fft_size*sizeof(float));//zero desired spectrum 
    memset(m_modelsIm[profile_id].get(), 0, m_signals[profile_id].fft_size*sizeof(float));
    int pulse_length = clc_koeff*(m_signals[profile_id].profile.dds_stop - m_signals[profile_id].profile.dds_start)/m_signals[profile_id].profile.decimation;
    memset(m_window[profile_id].get(), 0, m_windowsize[profile_id]*sizeof(float));
 
    if (pulse_length>m_windowsize[profile_id])
        pulse_length=m_windowsize[profile_id];
    
    const float     blackman1 = 0.42f;
    const float     blackman2 = 0.5f;
    const float     blackman3 = 0.08f;
 
    for( int i = 0; i < m_windowsize[profile_id]; i++)// окно Блэкмана было m_windowsize[profile_id] вместо pulse_length
    {
        m_window[profile_id][i] = (float)(blackman1 - blackman2 * cos ((2. * M_PI * i) / (m_windowsize[profile_id]-1)) + blackman3 * cos ((4. * M_PI * i) / (m_windowsize[profile_id]-1)));
    }
 
    if ( pulse_length > 0 && pulse_length <= sfera_structures::kModelSize)
    {
        if (m_signals[profile_id].profile.dftw == 0)
        {
            //////////////////////////////////////////////////////////////////////////
            //КИ
            for (int i=0,k=0; i< pulse_length; ++i)
            {
                if ( (i%m_signals[profile_id].profile.decimation)==0 )
                {
                    p=(float)(2.f*M_PI*i*m_signals[profile_id].profile.ftw/(float)(powf(2.f,31.f)));
                    signalModelRe[k]= (float)cos(p);
                    signalModelIm[k]= (float)sin(p);
                    ++k;
                }
            }
        }
        else
        {
            //////////////////////////////////////////////////////////////////////////
            //LFM
            uint32_t pw = 0; 
            uint32_t dfw = m_signals[profile_id].profile.dftw;
            uint32_t ftw = m_signals[profile_id].profile.ftw;
            uint32_t fw = ftw;
 
            for( int i = 0; i < pulse_length; i++)// окно Блэкмана
            {
                window[i] = (float)(blackman1 - blackman2 * cos ((2. * M_PI * i) / (pulse_length-1)) + blackman3 * cos ((4. * M_PI * i) / (pulse_length-1)));
            }
 
            uint32_t step =  static_cast<int>((m_signals[profile_id].profile.dfrrw*cur_fadc/cur_ffrrw)+0.5f);
            if (step == 0 )
            {
                return false;
            }
            for (int i=0,k=0; i< pulse_length; ++i)
            {
                p=(float)(pw>>1);
                p=(float)(p*2*M_PI/(float)(pow(2.,31.)));
                if ( (i%m_signals[profile_id].profile.decimation)==0 )
                {
                    if ( m_window_target == 1)
                    {
                        signalModelRe[k]= window[i]*(float)cos(p);
                        signalModelIm[k]= window[i]*(float)sin(p);
                    }
                    else
                    {
                        signalModelRe[k]= (float)cos(p);
                        signalModelIm[k]= (float)sin(p);
                    }                   
                    ++k;
                }
                for(int j=0; j<freq_koeff; j++)
                {
                    pw+=fw;
                }
                if (((i+1)%step)==0) 
                {fw+=dfw;}
            }
        }
    } 
    else
    {
        return false;
    }
    
    int32_t buff_num = static_cast<int>( static_cast<int>((log10f(static_cast<float>(m_signals[profile_id].fft_size))/log10f(2.0f))+0.5f)- static_cast<int> ((log10f(static_cast<float>(kFFTmin))/log10f(2.0f))+0.5f));
    
    if ( buff_num < kFFTbuffers)
    {
        //получаем спектр эталона
        r1 = ippsFFTFwd_CToC_32f((const Ipp32f*)signalModelRe,
            (const Ipp32f*)signalModelIm, 
            (Ipp32f*)m_modelsRe[profile_id].get(), 
            (Ipp32f*)m_modelsIm[profile_id].get(),
            m_fft_spec[buff_num], 
            (Ipp8u*)m_ipp_buffer[buff_num].get()); 
        (r1 == ippStsNoErr) ?  res=true : res =false;
    }
    
    return res;
}

float qwe[100000];

float           signalModelRe[kOrwrMaxRange];
    float           signalModelIm[kOrwrMaxRange];
    float           window[kOrwrMaxRange];