# Set the version information here

set(VERSION_INFO_MAJOR_VERSION 3)

set(VERSION_INFO_API_COMPAT 7)

include(GrVersion) #setup version info

# Append -O2 optimization flag for Debug builds

# are normally passed to the compiler using the -I flag.

STRIP_FROM_INC_PATH = @CMAKE_SOURCE_DIR@/gnuradio-runtime/include \

@CMAKE_SOURCE_DIR@/gr-analog/include \

@CMAKE_SOURCE_DIR@/gr-atsc/include \

@CMAKE_SOURCE_DIR@/gr-audio/include \

@CMAKE_SOURCE_DIR@/gr-blocks/include \

@CMAKE_SOURCE_DIR@/gr-channels/include \

@CMAKE_SOURCE_DIR@/gr-comedi/include \

@CMAKE_SOURCE_DIR@/gr-digital/include \

@CMAKE_SOURCE_DIR@/gr-fcd/include \

@CMAKE_SOURCE_DIR@/gr-fec/include \

@CMAKE_SOURCE_DIR@/gr-fft/include \

@CMAKE_SOURCE_DIR@/gr-filter/include \

@CMAKE_SOURCE_DIR@/gr-noaa/include \

@CMAKE_SOURCE_DIR@/gr-pager/include \

@CMAKE_SOURCE_DIR@/gr-qtgui/include \

@CMAKE_SOURCE_DIR@/gr-trellis/include \

@CMAKE_SOURCE_DIR@/gr-uhd/include \

@CMAKE_SOURCE_DIR@/gr-video-sdl/include \

@CMAKE_SOURCE_DIR@/gr-vocoder/include \

@CMAKE_SOURCE_DIR@/gr-wxgui/include \

# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter

# (but less readable) file names. This can be useful if your file system

void add_item_tag(unsigned int which_output, const tag_t &tag);

/*!

*

* \param which_input an integer of which input stream to remove the tag from

* \param abs_offset a uint64 number of the absolute item number

}

/*!

*

* \param which_input an integer of which input stream to remove the tag from

* \param tag the tag object to remove

#include <gnuradio/tags.h>

#include <boost/weak_ptr.hpp>

#include <gnuradio/thread/thread.h>

namespace gr {

*/

void prune_tags(uint64_t max_time);

// -------------------------------------------------------------------------

unsigned int d_write_index; // in items [0,d_bufsize)

uint64_t d_abs_write_offset; // num items written since the start

bool d_done;

uint64_t d_last_min_items_read;

unsigned index_add(unsigned a, unsigned b)

//! Return the pmt value that represents double \p x.

PMT_API pmt_t from_double(double x);

/*!

* \brief Convert pmt to double if possible.

*/

PMT_API double to_double(pmt_t x);

/*

* ------------------------------------------------------------------------

* Complex

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <gnuradio/buffer.h>

#include <gnuradio/math.h>

#include "vmcircbuf.h"

buffer::add_item_tag(const tag_t &tag)

{

gr::thread::scoped_lock guard(*mutex());

}

void

buffer::remove_item_tag(const tag_t &tag, long id)

{

gr::thread::scoped_lock guard(*mutex());

}

}

}

If this function is used elsewhere, remember to lock the

buffer's mutex al la the scoped_lock line below.

*/

}

long

buffer_reader::get_tags_in_range(std::vector<tag_t> &v,

uint64_t abs_start,

uint64_t abs_end,

{

gr::thread::scoped_lock guard(*mutex());

v.resize(0);

uint64_t item_time;

if((item_time >= abs_start) && (item_time < abs_end)) {

// If id is not in the vector of marked blocks

t.offset += d_attr_delay;

}

itr++;

}

}

return pmt_t(new pmt_real(x));

}

double

to_double(pmt_t x)

{

throw wrong_type("pmt_to_double", x);

}

////////////////////////////////////////////////////////////////////////////

// Complex

////////////////////////////////////////////////////////////////////////////

CPPUNIT_ASSERT_EQUAL(-1.0, pmt::to_double(m1));

CPPUNIT_ASSERT_EQUAL(1.0, pmt::to_double(p1));

CPPUNIT_ASSERT_EQUAL(1.0, pmt::to_double(pmt::from_long(1)));

}

void

const = 123765

x_pmt = pmt.from_double(const)

x_int = pmt.to_double(x_pmt)

self.assertEqual(x_int, const)

def test03(self):

v = pmt.init_f32vector(3, [11, -22, 33])

bool is_real(pmt_t obj);

pmt_t from_double(double x);

double to_double(pmt_t x);

bool is_complex(pmt_t obj);

pmt_t make_rectangular(double re, double im);

# the Free Software Foundation, Inc., 51 Franklin Street,

# Boston, MA 02110-1301, USA.

add_subdirectory(metadata)

add_subdirectory(tags)

<name>Abs</name>

<key>blocks_abs_xx</key>

<import>from gnuradio import blocks</import>

<param>

<name>IO Type</name>

<key>type</key>

<opt>fcn:ff</opt>

</option>

</param>

<sink>

<name>in</name>

<type>$type</type>

</sink>

<source>

<name>out</name>

<type>$type</type>

</source>

</block>

<source>

<name>pdus</name>

<type>message</type>

</source>

</block>

/*!

* \brief Create an instance of @NAME@

*/

};

} /* namespace blocks */

namespace gr {

namespace blocks {

{

}

: sync_block ("@NAME@",

{

}

@I_TYPE@ *iptr = (@I_TYPE@ *) input_items[0];

@O_TYPE@ *optr = (@O_TYPE@ *) output_items[0];

@I_TYPE@ val = iptr[i];

optr[i] = ((val < ((@I_TYPE@)0)) ? -val : val);

}

class BLOCKS_API @NAME_IMPL@ : public @NAME@

{

public:

int work(int noutput_items,

gr_vector_const_void_star &input_items,

io_signature::make (1, io_signature::IO_INFINITE, itemsize)),

d_itemsize(itemsize), d_blocksize(blocksize), d_current_output(0)

{

set_output_multiple(blocksize);

}

bool

deinterleave_impl::check_topology(int ninputs, int noutputs)

{

d_noutputs = noutputs;

return true;

}

const char *in = (const char*)input_items[0];

char **out = (char**)&output_items[0];

return WORK_CALLED_PRODUCE;

}

unsigned int d_blocksize;

unsigned int d_current_output;

unsigned int d_noutputs;

public:

deinterleave_impl(size_t itemsize, unsigned int blocksize);

bool check_topology(int ninputs, int noutputs);

int general_work(int noutput_items,

#include <gnuradio/blocks/annotator_alltoall.h>

#include <gnuradio/blocks/annotator_1to1.h>

#include <gnuradio/blocks/keep_one_in_n.h>

// ----------------------------------------------------------------

// set to 1 to turn on debug output

// The debug output fully checks that the tags seen are what are expected. While

// that the tags will be coming in this specific order, so it's dangerous to

// rely on this as a test of the tag system working. We would really want to

// tags we know we should see and then test that they all occur once, but in no

// particular order.

#define QA_TAGS_DEBUG 0

void

qa_block_tags::t0()

{

tb->connect(src, 0, head, 0);

tb->connect(head, 0, snk, 0);

CPPUNIT_ASSERT_EQUAL(src->nitems_read(0), (uint64_t)0);

CPPUNIT_ASSERT_EQUAL(src->nitems_written(0), (uint64_t)0);

str1 << ann1->name() << ann1->unique_id();

str2 << ann2->name() << ann2->unique_id();

std::cout << std::endl << "qa_block_tags::t1" << std::endl;

// For annotator 3, we know it gets tags from ann0 and ann1, test this

for(size_t i = 0; i < tags3.size(); i++) {

std::cout << "tags3[" << i << "] = " << tags3[i] << "\t\t" << expected_tags3[i] << std::endl;

}

// For annotator 4, we know it gets tags from ann0 and ann2, test this

std::cout << std::endl;

for(size_t i = 0; i < tags4.size(); i++) {

std::cout << "tags4[" << i << "] = " << tags4[i] << "\t\t" << expected_tags4[i] << std::endl;

}

#endif

}

str0 << ann0->name() << ann0->unique_id();

str1 << ann1->name() << ann1->unique_id();

std::cout << std::endl << "qa_block_tags::t2" << std::endl;

// inconceivable for ann3 to have it wrong.

for(size_t i = 0; i < tags2.size(); i++) {

std::cout << "tags2[" << i << "] = " << tags2[i] << "\t\t" << expected_tags2[i] << std::endl;

}

std::cout << std::endl;

for(size_t i = 0; i < tags4.size(); i++) {

std::cout << "tags2[" << i << "] = " << tags4[i] << "\t\t" << expected_tags4[i] << std::endl;

}

#endif

}

str1 << ann1->name() << ann1->unique_id();

str2 << ann2->name() << ann2->unique_id();

std::cout << std::endl << "qa_block_tags::t3" << std::endl;

// For annotator 3, we know it gets tags from ann0 and ann1, test this

for(size_t i = 0; i < tags3.size(); i++) {

std::cout << "tags3[" << i << "] = " << tags3[i] << "\t\t" << expected_tags3[i] << std::endl;

}

// For annotator 4, we know it gets tags from ann0 and ann2, test this

std::cout << std::endl;

for(size_t i = 0; i < tags4.size(); i++) {

std::cout << "tags4[" << i << "] = " << tags4[i] << "\t\t" << expected_tags4[i] << std::endl;

}

#endif

}

str1 << ann1->name() << ann1->unique_id();

str2 << ann2->name() << ann2->unique_id();

std::cout << std::endl << "qa_block_tags::t5" << std::endl;

std::cout << "tags1.size(): " << tags1.size() << std::endl;

for(size_t i = 0; i < tags1.size(); i++) {

std::cout << "tags1[" << i << "] = " << tags1[i] << "\t\t" << expected_tags1[i] << std::endl;

}

// annotator 2 gets tags from annotators 0 and 1

std::cout << "tags2.size(): " << tags2.size() << std::endl;

for(size_t i = 0; i < tags2.size(); i++) {

std::cout << "tags2[" << i << "] = " << tags2[i] << "\t\t" << expected_tags2[i] << std::endl;

}

#endif

}

/*!

* \param equalizer The equalizer object that will do the actual work

* \param cp_len Length of the cyclic prefix in samples (required to correct the frequency offset)

* \param propagate_channel_state If true, the channel state after the last symbol

* will be added to the first symbol as a tag

*/

static sptr make(

);

};

/* -*- c++ -*- */

*

* This file is part of GNU Radio

*

}

}

if (d_uses_trigger_tag) {

}

return -1;

} /* find_trigger_signal() */

// Copy tags

std::vector<tag_t> tags;

get_tags_in_range(

);

}

} /* copy_n_symbols() */

#define M_TWOPI (2*M_PI)

namespace gr {

namespace digital {

ofdm_frame_equalizer_vcvc::make(

ofdm_equalizer_base::sptr equalizer,

int cp_len,

bool propagate_channel_state,

int fixed_frame_len

)

{

return gnuradio::get_initial_sptr (

new ofdm_frame_equalizer_vcvc_impl(

)

);

}

ofdm_frame_equalizer_vcvc_impl::ofdm_frame_equalizer_vcvc_impl(

ofdm_equalizer_base::sptr equalizer,

int cp_len,

bool propagate_channel_state,

int fixed_frame_len

) : tagged_stream_block("ofdm_frame_equalizer_vcvc",

io_signature::make(1, 1, sizeof (gr_complex) * equalizer->fft_len()),

io_signature::make(1, 1, sizeof (gr_complex) * equalizer->fft_len()),

d_fft_len(equalizer->fft_len()),

d_cp_len(cp_len),

d_eq(equalizer),

d_fixed_frame_len(fixed_frame_len),

d_channel_state(equalizer->fft_len(), gr_complex(1, 0))

{

}

if (d_fixed_frame_len < 0) {

}

if (d_fixed_frame_len) {

}

set_relative_rate(1.0);

}

ofdm_frame_equalizer_vcvc_impl::~ofdm_frame_equalizer_vcvc_impl()

void

ofdm_frame_equalizer_vcvc_impl::parse_length_tags(

if (d_fixed_frame_len) {

} else {

}

}

}

std::vector<tag_t> tags;

for (unsigned i = 0; i < tags.size(); i++) {

}

// Copy the frame and the channel state vector such that the symbols are shifted to the correct position

// Update the channel state regarding the frequency offset

phase_correction = gr_expj(M_TWOPI * carrier_offset * d_cp_len / d_fft_len * frame_len);

for (int k = 0; k < d_fft_len; k++) {

}

// Housekeeping

/* -*- c++ -*- */

*

* This file is part of GNU Radio

*

std::vector<tag_t> tags;

// Packet mode

if (!d_length_tag_key_str.empty()) {

} else {

}

// Copy symbols

int n_out_symbols = 0;

for (int i = 0; i < frame_length; i++) {

}

// Housekeeping

if (d_length_tag_key_str.empty()) {

} else {

}

return n_out_symbols;

]

self.assertEqual(expected_tags_payload, ptags_payload)

def test_002_symbols (self):

"""

Same as before, but operate on symbols

ptag = gr.tag_to_python(tag)

tag_dict[ptag.key] = ptag.value

expected_dict = {

}

self.assertEqual(tag_dict, expected_dict)

noutput_items/(output_multiple() - d_decoder->get_history()) :

innum;

for(int i = 0; i < items; ++i) {

d_decoder->generic_work((void*)(in+(i*d_decoder->get_input_size()*d_input_item_size)),

int consumed = static_cast<int>(items/relative_rate()*(output_multiple() - d_decoder->get_history()) + 0.5);

int returned = items*(output_multiple() - d_decoder->get_history());

consume_each(consumed);

return returned;

char *inbuffer = (char*)input_items[0];

char *outbuffer = (char*)output_items[0];

for(int i = 0; i < noutput_items/output_multiple(); i++) {

(void*)(outbuffer+(i*d_output_size)));

}

consume_each(fixed_rate_noutput_to_ninput(noutput_items));

return noutput_items;

{

bool clocks_locked = true;

for (size_t mboard_index = 0; mboard_index < _dev->get_num_mboards(); mboard_index++) {

std::string sensor_name = "ref_locked";

if (_dev->get_clock_source(mboard_index) == "internal") {

}

}

return clocks_locked;

}

namespace fs = boost::filesystem;

int main(int argc, char *argv[]) {

// Adding program options

boost::program_options::options_description desc("Options");

("tests-regex,R",

boost::program_options::value<std::string>(),

"Run tests matching regular expression.")

;

// Handle the options that were given

bool benchmark_mode;

std::string kernel_regex;

bool store_results = true;

try {

boost::program_options::store(boost::program_options::parse_command_line(argc, argv, desc), vm);

boost::program_options::notify(vm);

return 0;

}

// Run tests

//VOLK_PROFILE(volk_16i_x5_add_quad_16i_x4, 1e-4, 2046, 10000, &results, benchmark_mode, kernel_regex);

//VOLK_PROFILE(volk_16i_branch_4_state_8, 1e-4, 2046, 10000, &results, benchmark_mode, kernel_regex);

VOLK_PROFILE(volk_32f_s32f_multiply_32f, 1e-4, 1.0, 204602, 10000, &results, benchmark_mode, kernel_regex);

VOLK_PROFILE(volk_32f_binary_slicer_32i, 0, 1.0, 204602, 10000, &results, benchmark_mode, kernel_regex);

VOLK_PROFILE(volk_32f_binary_slicer_8i, 0, 1.0, 204602, 10000, &results, benchmark_mode, kernel_regex);

// Until we can update the config on a kernel by kernel basis

// do not overwrite volk_config when using a regex.

#the function name is followed by the preferred architecture.\n\

";

}

config.close();

}

message(STATUS "--==>> -CFLAGS1: ${FULL_C_FLAGS}")

string(REGEX MATCH "${ARCH}" ASM_ARCH "${FULL_C_FLAGS}")

if( ASM_ARCH STREQUAL "armv7" )

message(STATUS "---- Adding ASM files") # we always use ATT syntax

message(STATUS "-- Detected armv7 architecture; enabling ASM")

# setup architecture specific assembler flags

message(STATUS "Adding source file: ${asm_file}")

endforeach(asm_file)

endif()

endforeach(ARCH)

else(${CMAKE_VERSION} VERSION_GREATER "2.8.9")

message(STATUS "Not enabling ASM support. CMake >= 2.8.10 required.")

endif(${CMAKE_VERSION} VERSION_GREATER "2.8.9")

########################################################################

#include <boost/tokenizer.hpp>

#include <boost/xpressive/xpressive.hpp>

#include <iostream>

#include <vector>

#include <list>

#include <ctime>

#include <cmath>

lv_32fc_t scalar,

int vlen,

int iter,

std::string kernel_regex

) {

boost::xpressive::sregex kernel_expression = boost::xpressive::sregex::compile(kernel_regex);

// in this case we have a regex and are only looking to test one kernel

return false;

}

std::cout << "RUN_VOLK_TESTS: " << name << "(" << vlen << "," << iter << ")" << std::endl;

// The multiply and lv_force_cast_hf are work arounds for GNU Radio bugs 582 and 583

end = clock();

double arch_time = 1000.0 * (double)(end-start)/(double)CLOCKS_PER_SEC;

std::cout << arch_list[i] << " completed in " << arch_time << "ms" << std::endl;

profile_times.push_back(arch_time);

}

std::cout << "Best aligned arch: " << best_arch_a << std::endl;

std::cout << "Best unaligned arch: " << best_arch_u << std::endl;

if(puppet_master_name == "NULL") {

}

}

return fail_global;

#include <cstdlib>

#include <string>

#include <vector>

#include <volk/volk.h>

#include <volk/volk_common.h>

float uniform(void);

void random_floats(float *buf, unsigned n);

#define VOLK_PROFILE(func, tol, scalar, len, iter, results, bnmode, kernel_regex) run_volk_tests(func##_get_func_desc(), (void (*)())func##_manual, std::string(#func), tol, scalar, len, iter, results, "NULL", bnmode, kernel_regex)

#define VOLK_PUPPET_PROFILE(func, puppet_master_func, tol, scalar, len, iter, results, bnmode, kernel_regex) run_volk_tests(func##_get_func_desc(), (void (*)())func##_manual, std::string(#func), tol, scalar, len, iter, results, std::string(#puppet_master_func), bnmode, kernel_regex)

typedef void (*volk_fn_1arg)(void *, unsigned int, const char*); //one input, operate in place

VOLK_RUN_TESTS(volk_32f_invsqrt_32f, 1e-2, 0, 20462, 1);

VOLK_RUN_TESTS(volk_32f_binary_slicer_32i, 0, 0, 20462, 1);

VOLK_RUN_TESTS(volk_32f_binary_slicer_8i, 0, 0, 20462, 1);