[Top][All Lists]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[Discuss-gnuradio] Segmentation fault for aligned volk kernel with custo

From: Martin Lülf
Subject: [Discuss-gnuradio] Segmentation fault for aligned volk kernel with custom arrays
Date: Fri, 9 Nov 2012 17:47:15 +0100
User-agent: SquirrelMail/1.4.22

Hi list,

I am trying to speed up my own gnuradio block using volk. Besides using
volk on gnuradios input and output buffers I also want do use it with my
own arrays. I found this Thread in the mailing list archive
which shows how to allocate aligned memory and I also tried using
posix_memalign directly as well (see the code below). Both end in the same
result: If I run my block with the aligned volk_32fc_x2_multiply_32fc_a
kernel my application crashes with a Segmentation fault. I checked with a
debugger and it is the volk call at which the segfault happens. I get no
segfaults for the unaligned version volk_32fc_x2_multiply_32fc_u. My
flowgraph is created with grc and just contains of

Running volk_profile, sse3 is selected for both kernels (and the aligned
version does not segfault here), so there has to be an issue with my code.

I am working on an Intel Xeon X5690 CPU with an 3.2.0-32-generic
#51-Ubuntu SMP Wed Sep 26 21:33:09 UTC 2012 x86_64 x86_64 x86_64 GNU/Linux
and gnuradio-3.6.0

I know that there is a newer version of gnuradio available but before
turning my whole system upside-down I'd like to know if there is anything
wrong with the minimal code example below.

Any help is appreciated.

#include "config.h"

#include <ccsds_fll_cc.h>
#include <gr_io_signature.h>
#include <volk/volk.h>
#include <stdio.h>
#include <cstdlib>
#include <fftw3.h>

ccsds_make_fll_cc ()
    return ccsds_fll_cc_sptr (new ccsds_fll_cc ());

ccsds_fll_cc::ccsds_fll_cc ()
  : gr_block ("ccsds_fll_cc",
        gr_make_io_signature (1, 1, sizeof (gr_complex)),
        gr_make_io_signature (1, 1, sizeof (gr_complex)))
        // nothing

ccsds_fll_cc::~ccsds_fll_cc ()
    // nothing
int  ccsds_fll_cc::general_work (int                     noutput_items,
                                gr_vector_int               &ninput_items,
                                gr_vector_const_void_star   &input_items,
                                gr_vector_void_star         &output_items)
        const gr_complex *in = (const gr_complex *) input_items[0];
        gr_complex *out = (gr_complex *) output_items[0];

        unsigned int num = (noutput_items > ninput_items[0]) ? ninput_items[0] :

        /* use posix_memalign instead of fftwf_malloc
        gr_complex *rot;
        int mem = posix_memalign((void**)&rot, volk_get_alignment(),
        if(mem != 0) {
                fprintf(stderr,"ERROR: allocation of aligned memory failed\n");
                return 0;

        gr_complex *rot = (gr_complex*)fftwf_malloc(sizeof(gr_complex)*num);
        if(rot == 0) {
                fprintf(stderr,"ERROR: allocation of aligned memory failed\n");
                return 0;

        // asign values to rot
        for(size_t i=0;i<num;i++) {
                rot[i] = gr_complex(0.1f,0.0f);

        // invoking the unaligned version does not segfault
        //volk_32fc_x2_multiply_32fc_u(out, in, rot, num);

        if(is_unaligned()) {
                volk_32fc_x2_multiply_32fc_u(out, in, rot, num);
        } else {
                // segfault
                volk_32fc_x2_multiply_32fc_a(out, in, rot, num);

        // use free for posix_memalign

        return num;

reply via email to

[Prev in Thread] Current Thread [Next in Thread]