diff options
| author | Marcus Müller <mmueller@gnuradio.org> | 2019-08-07 21:45:12 +0200 |
|---|---|---|
| committer | Marcus Müller <marcus@hostalia.de> | 2019-08-09 23:04:28 +0200 |
| commit | f7bbf2c1d8d780294f3e016aff239ca35eb6516e (patch) | |
| tree | e09ab6112e02b2215b2d59ac24d3d6ea2edac745 /gnuradio-runtime/lib | |
| parent | 78431dc6941e3acc67c858277dfe4a0ed583643c (diff) | |
Tree: clang-format without the include sorting
Diffstat (limited to 'gnuradio-runtime/lib')
105 files changed, 12029 insertions, 13211 deletions
diff --git a/gnuradio-runtime/lib/basic_block.cc b/gnuradio-runtime/lib/basic_block.cc index 89aa9b8671..60aaa86c46 100644 --- a/gnuradio-runtime/lib/basic_block.cc +++ b/gnuradio-runtime/lib/basic_block.cc @@ -33,18 +33,14 @@ namespace gr { - static long s_next_id = 0; - static long s_ncurrently_allocated = 0; - - long - basic_block_ncurrently_allocated() - { - return s_ncurrently_allocated; - } - - basic_block::basic_block(const std::string &name, - io_signature::sptr input_signature, - io_signature::sptr output_signature) +static long s_next_id = 0; +static long s_ncurrently_allocated = 0; + +long basic_block_ncurrently_allocated() { return s_ncurrently_allocated; } + +basic_block::basic_block(const std::string& name, + io_signature::sptr input_signature, + io_signature::sptr output_signature) : d_name(name), d_input_signature(input_signature), d_output_signature(output_signature), @@ -54,155 +50,147 @@ namespace gr { d_color(WHITE), d_rpc_set(false), d_message_subscribers(pmt::make_dict()) - { +{ s_ncurrently_allocated++; - } +} - basic_block::~basic_block() - { +basic_block::~basic_block() +{ s_ncurrently_allocated--; global_block_registry.block_unregister(this); - } +} - basic_block_sptr - basic_block::to_basic_block() - { - return shared_from_this(); - } +basic_block_sptr basic_block::to_basic_block() { return shared_from_this(); } - void - basic_block::set_block_alias(std::string name) - { +void basic_block::set_block_alias(std::string name) +{ // Only keep one alias'd name around for each block. If we don't // have an alias, add it; if we do, update the entry in the // registry. - if(alias_set()) - global_block_registry.update_symbolic_name(this, name); + if (alias_set()) + global_block_registry.update_symbolic_name(this, name); else - global_block_registry.register_symbolic_name(this, name); + global_block_registry.register_symbolic_name(this, name); // set the block's alias d_symbol_alias = name; update_logger_alias(symbol_name(), d_symbol_alias); - } +} - // ** Message passing interface ** +// ** Message passing interface ** - // - register a new input message port - void - basic_block::message_port_register_in(pmt::pmt_t port_id) - { - if(!pmt::is_symbol(port_id)) { - throw std::runtime_error("message_port_register_in: bad port id"); +// - register a new input message port +void basic_block::message_port_register_in(pmt::pmt_t port_id) +{ + if (!pmt::is_symbol(port_id)) { + throw std::runtime_error("message_port_register_in: bad port id"); } msg_queue[port_id] = msg_queue_t(); - msg_queue_ready[port_id] = boost::shared_ptr<boost::condition_variable>(new boost::condition_variable()); - } + msg_queue_ready[port_id] = + boost::shared_ptr<boost::condition_variable>(new boost::condition_variable()); +} - pmt::pmt_t - basic_block::message_ports_in() - { +pmt::pmt_t basic_block::message_ports_in() +{ pmt::pmt_t port_names = pmt::make_vector(msg_queue.size(), pmt::PMT_NIL); msg_queue_map_itr itr = msg_queue.begin(); - for(size_t i = 0; i < msg_queue.size(); i++) { - pmt::vector_set(port_names, i, (*itr).first); - itr++; + for (size_t i = 0; i < msg_queue.size(); i++) { + pmt::vector_set(port_names, i, (*itr).first); + itr++; } return port_names; - } - - // - register a new output message port - void - basic_block::message_port_register_out(pmt::pmt_t port_id) - { - if(!pmt::is_symbol(port_id)) { - throw std::runtime_error("message_port_register_out: bad port id"); +} + +// - register a new output message port +void basic_block::message_port_register_out(pmt::pmt_t port_id) +{ + if (!pmt::is_symbol(port_id)) { + throw std::runtime_error("message_port_register_out: bad port id"); } - if(pmt::dict_has_key(d_message_subscribers, port_id)) { - throw std::runtime_error("message_port_register_out: port already in use"); + if (pmt::dict_has_key(d_message_subscribers, port_id)) { + throw std::runtime_error("message_port_register_out: port already in use"); } d_message_subscribers = pmt::dict_add(d_message_subscribers, port_id, pmt::PMT_NIL); - } +} - pmt::pmt_t - basic_block::message_ports_out() - { +pmt::pmt_t basic_block::message_ports_out() +{ size_t len = pmt::length(d_message_subscribers); pmt::pmt_t port_names = pmt::make_vector(len, pmt::PMT_NIL); pmt::pmt_t keys = pmt::dict_keys(d_message_subscribers); - for(size_t i = 0; i < len; i++) { - pmt::vector_set(port_names, i, pmt::nth(i, keys)); + for (size_t i = 0; i < len; i++) { + pmt::vector_set(port_names, i, pmt::nth(i, keys)); } return port_names; - } +} - // - publish a message on a message port - void basic_block::message_port_pub(pmt::pmt_t port_id, pmt::pmt_t msg) - { - if(!pmt::dict_has_key(d_message_subscribers, port_id)) { - throw std::runtime_error("port does not exist"); +// - publish a message on a message port +void basic_block::message_port_pub(pmt::pmt_t port_id, pmt::pmt_t msg) +{ + if (!pmt::dict_has_key(d_message_subscribers, port_id)) { + throw std::runtime_error("port does not exist"); } pmt::pmt_t currlist = pmt::dict_ref(d_message_subscribers, port_id, pmt::PMT_NIL); // iterate through subscribers on port - while(pmt::is_pair(currlist)) { - pmt::pmt_t target = pmt::car(currlist); + while (pmt::is_pair(currlist)) { + pmt::pmt_t target = pmt::car(currlist); - pmt::pmt_t block = pmt::car(target); - pmt::pmt_t port = pmt::cdr(target); + pmt::pmt_t block = pmt::car(target); + pmt::pmt_t port = pmt::cdr(target); - currlist = pmt::cdr(currlist); - basic_block_sptr blk = global_block_registry.block_lookup(block); - //blk->post(msg); - blk->post(port, msg); + currlist = pmt::cdr(currlist); + basic_block_sptr blk = global_block_registry.block_lookup(block); + // blk->post(msg); + blk->post(port, msg); } - } - - // - subscribe to a message port - void - basic_block::message_port_sub(pmt::pmt_t port_id, pmt::pmt_t target){ - if(!pmt::dict_has_key(d_message_subscribers, port_id)){ - std::stringstream ss; - ss << "Port does not exist: \"" << pmt::write_string(port_id) << "\" on block: " - << pmt::write_string(target) << std::endl; - throw std::runtime_error(ss.str()); +} + +// - subscribe to a message port +void basic_block::message_port_sub(pmt::pmt_t port_id, pmt::pmt_t target) +{ + if (!pmt::dict_has_key(d_message_subscribers, port_id)) { + std::stringstream ss; + ss << "Port does not exist: \"" << pmt::write_string(port_id) + << "\" on block: " << pmt::write_string(target) << std::endl; + throw std::runtime_error(ss.str()); } - pmt::pmt_t currlist = pmt::dict_ref(d_message_subscribers,port_id,pmt::PMT_NIL); + pmt::pmt_t currlist = pmt::dict_ref(d_message_subscribers, port_id, pmt::PMT_NIL); // ignore re-adds of the same target - if(!pmt::list_has(currlist, target)) - d_message_subscribers = pmt::dict_add(d_message_subscribers,port_id,pmt::list_add(currlist,target)); - } - - void - basic_block::message_port_unsub(pmt::pmt_t port_id, pmt::pmt_t target) - { - if(!pmt::dict_has_key(d_message_subscribers, port_id)) { - std::stringstream ss; - ss << "Port does not exist: \"" << pmt::write_string(port_id) << "\" on block: " - << pmt::write_string(target) << std::endl; - throw std::runtime_error(ss.str()); + if (!pmt::list_has(currlist, target)) + d_message_subscribers = pmt::dict_add( + d_message_subscribers, port_id, pmt::list_add(currlist, target)); +} + +void basic_block::message_port_unsub(pmt::pmt_t port_id, pmt::pmt_t target) +{ + if (!pmt::dict_has_key(d_message_subscribers, port_id)) { + std::stringstream ss; + ss << "Port does not exist: \"" << pmt::write_string(port_id) + << "\" on block: " << pmt::write_string(target) << std::endl; + throw std::runtime_error(ss.str()); } // ignore unsubs of unknown targets - pmt::pmt_t currlist = pmt::dict_ref(d_message_subscribers,port_id,pmt::PMT_NIL); - d_message_subscribers = pmt::dict_add(d_message_subscribers,port_id,pmt::list_rm(currlist,target)); - } + pmt::pmt_t currlist = pmt::dict_ref(d_message_subscribers, port_id, pmt::PMT_NIL); + d_message_subscribers = + pmt::dict_add(d_message_subscribers, port_id, pmt::list_rm(currlist, target)); +} - void - basic_block::_post(pmt::pmt_t which_port, pmt::pmt_t msg) - { +void basic_block::_post(pmt::pmt_t which_port, pmt::pmt_t msg) +{ insert_tail(which_port, msg); - } +} - void - basic_block::insert_tail(pmt::pmt_t which_port, pmt::pmt_t msg) - { +void basic_block::insert_tail(pmt::pmt_t which_port, pmt::pmt_t msg) +{ gr::thread::scoped_lock guard(mutex); - if((msg_queue.find(which_port) == msg_queue.end()) || (msg_queue_ready.find(which_port) == msg_queue_ready.end())) { - std::cout << "target port = " << pmt::symbol_to_string(which_port) << std::endl; - throw std::runtime_error("attempted to insert_tail on invalid queue!"); + if ((msg_queue.find(which_port) == msg_queue.end()) || + (msg_queue_ready.find(which_port) == msg_queue_ready.end())) { + std::cout << "target port = " << pmt::symbol_to_string(which_port) << std::endl; + throw std::runtime_error("attempted to insert_tail on invalid queue!"); } msg_queue[which_port].push_back(msg); @@ -210,28 +198,26 @@ namespace gr { // wake up thread if BLKD_IN or BLKD_OUT global_block_registry.notify_blk(alias()); - } +} - pmt::pmt_t - basic_block::delete_head_nowait(pmt::pmt_t which_port) - { +pmt::pmt_t basic_block::delete_head_nowait(pmt::pmt_t which_port) +{ gr::thread::scoped_lock guard(mutex); - if(empty_p(which_port)) { - return pmt::pmt_t(); + if (empty_p(which_port)) { + return pmt::pmt_t(); } pmt::pmt_t m(msg_queue[which_port].front()); msg_queue[which_port].pop_front(); return m; - } +} - pmt::pmt_t - basic_block::message_subscribers(pmt::pmt_t port) - { - return pmt::dict_ref(d_message_subscribers,port,pmt::PMT_NIL); - } +pmt::pmt_t basic_block::message_subscribers(pmt::pmt_t port) +{ + return pmt::dict_ref(d_message_subscribers, port, pmt::PMT_NIL); +} } /* namespace gr */ diff --git a/gnuradio-runtime/lib/block.cc b/gnuradio-runtime/lib/block.cc index 710e6c7d6c..65399bfc3e 100644 --- a/gnuradio-runtime/lib/block.cc +++ b/gnuradio-runtime/lib/block.cc @@ -34,15 +34,15 @@ namespace gr { - block::block(const std::string &name, - io_signature::sptr input_signature, - io_signature::sptr output_signature) +block::block(const std::string& name, + io_signature::sptr input_signature, + io_signature::sptr output_signature) : basic_block(name, input_signature, output_signature), - d_output_multiple (1), + d_output_multiple(1), d_output_multiple_set(false), d_unaligned(0), d_is_unaligned(false), - d_relative_rate (1.0), + d_relative_rate(1.0), d_mp_relative_rate(1.0), d_history(1), d_attr_delay(0), @@ -54,901 +54,856 @@ namespace gr { d_priority(-1), d_pc_rpc_set(false), d_update_rate(false), - d_max_output_buffer(std::max(output_signature->max_streams(),1), -1), - d_min_output_buffer(std::max(output_signature->max_streams(),1), -1), + d_max_output_buffer(std::max(output_signature->max_streams(), 1), -1), + d_min_output_buffer(std::max(output_signature->max_streams(), 1), -1), d_pmt_done(pmt::intern("done")), d_system_port(pmt::intern("system")) - { +{ global_block_registry.register_primitive(alias(), this); message_port_register_in(d_system_port); set_msg_handler(d_system_port, boost::bind(&block::system_handler, this, _1)); configure_default_loggers(d_logger, d_debug_logger, symbol_name()); - } - - block::~block() - { - global_block_registry.unregister_primitive(symbol_name()); - } - - unsigned - block::history() const - { - return d_history; - } - - void - block::set_history(unsigned history) - { - d_history = history; - } - - void - block::declare_sample_delay(unsigned delay) - { +} + +block::~block() { global_block_registry.unregister_primitive(symbol_name()); } + +unsigned block::history() const { return d_history; } + +void block::set_history(unsigned history) { d_history = history; } + +void block::declare_sample_delay(unsigned delay) +{ d_attr_delay = delay; - if(d_detail) { - unsigned int nins = static_cast<unsigned int>(d_detail->ninputs()); - for(unsigned int n = 0; n < nins; n++) { - d_detail->input(n)->declare_sample_delay(d_attr_delay); - } + if (d_detail) { + unsigned int nins = static_cast<unsigned int>(d_detail->ninputs()); + for (unsigned int n = 0; n < nins; n++) { + d_detail->input(n)->declare_sample_delay(d_attr_delay); + } } - } +} - void - block::declare_sample_delay(int which, unsigned delay) - { +void block::declare_sample_delay(int which, unsigned delay) +{ d_attr_delay = delay; - if(d_detail) { - d_detail->input(which)->declare_sample_delay(d_attr_delay); - } - } - - unsigned - block::sample_delay(int which) const - { - return d_attr_delay; - } - - // stub implementation: 1:1 - - void - block::forecast(int noutput_items, gr_vector_int &ninput_items_required) - { - unsigned ninputs = ninput_items_required.size (); - for(unsigned i = 0; i < ninputs; i++) - ninput_items_required[i] = noutput_items + history() - 1; - } - - // default implementation - - bool - block::start() - { - return true; - } - - bool - block::stop() - { - return true; - } - - void - block::set_output_multiple(int multiple) - { - if(multiple < 1) - throw std::invalid_argument("block::set_output_multiple"); + if (d_detail) { + d_detail->input(which)->declare_sample_delay(d_attr_delay); + } +} + +unsigned block::sample_delay(int which) const { return d_attr_delay; } + +// stub implementation: 1:1 + +void block::forecast(int noutput_items, gr_vector_int& ninput_items_required) +{ + unsigned ninputs = ninput_items_required.size(); + for (unsigned i = 0; i < ninputs; i++) + ninput_items_required[i] = noutput_items + history() - 1; +} + +// default implementation + +bool block::start() { return true; } + +bool block::stop() { return true; } + +void block::set_output_multiple(int multiple) +{ + if (multiple < 1) + throw std::invalid_argument("block::set_output_multiple"); d_output_multiple_set = true; d_output_multiple = multiple; - } +} - void - block::set_alignment(int multiple) - { - if(multiple < 1) - throw std::invalid_argument("block::set_alignment_multiple"); +void block::set_alignment(int multiple) +{ + if (multiple < 1) + throw std::invalid_argument("block::set_alignment_multiple"); d_output_multiple = multiple; - } +} - void - block::set_unaligned(int na) - { +void block::set_unaligned(int na) +{ // unaligned value must be less than 0 and it doesn't make sense // that it's larger than the alignment value. - if((na < 0) || (na > d_output_multiple)) - throw std::invalid_argument("block::set_unaligned"); + if ((na < 0) || (na > d_output_multiple)) + throw std::invalid_argument("block::set_unaligned"); d_unaligned = na; - } +} - void - block::set_is_unaligned(bool u) - { - d_is_unaligned = u; - } +void block::set_is_unaligned(bool u) { d_is_unaligned = u; } - void - block::set_relative_rate(double relative_rate) - { - if(relative_rate <= 0.0) - throw std::invalid_argument("block::set_relative_rate: relative rate must be > 0.0"); +void block::set_relative_rate(double relative_rate) +{ + if (relative_rate <= 0.0) + throw std::invalid_argument( + "block::set_relative_rate: relative rate must be > 0.0"); d_relative_rate = relative_rate; d_mp_relative_rate = mpq_class(relative_rate); - } +} - void - block::set_inverse_relative_rate(double inverse_relative_rate) - { - if(inverse_relative_rate <= 0.0) - throw std::invalid_argument("block::set_inverse_relative_rate: inverse relative rate must be > 0.0"); +void block::set_inverse_relative_rate(double inverse_relative_rate) +{ + if (inverse_relative_rate <= 0.0) + throw std::invalid_argument( + "block::set_inverse_relative_rate: inverse relative rate must be > 0.0"); mpq_class inv_rr_q(inverse_relative_rate); - set_relative_rate((uint64_t) inv_rr_q.get_den().get_ui(), - (uint64_t) inv_rr_q.get_num().get_ui()); - } + set_relative_rate((uint64_t)inv_rr_q.get_den().get_ui(), + (uint64_t)inv_rr_q.get_num().get_ui()); +} - void - block::set_relative_rate(uint64_t interpolation, uint64_t decimation) - { +void block::set_relative_rate(uint64_t interpolation, uint64_t decimation) +{ mpz_class interp, decim; if (interpolation < 1) - throw std::invalid_argument("block::set_relative_rate: interpolation rate cannot be 0"); + throw std::invalid_argument( + "block::set_relative_rate: interpolation rate cannot be 0"); if (decimation < 1) - throw std::invalid_argument("block::set_relative_rate: decimation rate cannot be 0"); + throw std::invalid_argument( + "block::set_relative_rate: decimation rate cannot be 0"); mpz_import(interp.get_mpz_t(), 1, 1, sizeof(interpolation), 0, 0, &interpolation); mpz_import(decim.get_mpz_t(), 1, 1, sizeof(decimation), 0, 0, &decimation); d_mp_relative_rate = mpq_class(interp, decim); d_mp_relative_rate.canonicalize(); d_relative_rate = d_mp_relative_rate.get_d(); - } +} - void - block::consume(int which_input, int how_many_items) - { +void block::consume(int which_input, int how_many_items) +{ d_detail->consume(which_input, how_many_items); - } +} - void - block::consume_each(int how_many_items) - { - d_detail->consume_each(how_many_items); - } +void block::consume_each(int how_many_items) { d_detail->consume_each(how_many_items); } - void - block::produce(int which_output, int how_many_items) - { +void block::produce(int which_output, int how_many_items) +{ d_detail->produce(which_output, how_many_items); - } +} - int - block::fixed_rate_ninput_to_noutput(int ninput) - { +int block::fixed_rate_ninput_to_noutput(int ninput) +{ throw std::runtime_error("Unimplemented"); - } +} - int - block::fixed_rate_noutput_to_ninput(int noutput) - { +int block::fixed_rate_noutput_to_ninput(int noutput) +{ throw std::runtime_error("Unimplemented"); - } +} - uint64_t - block::nitems_read(unsigned int which_input) - { - if(d_detail) { - return d_detail->nitems_read(which_input); - } - else { - //throw std::runtime_error("No block_detail associated with block yet"); - return 0; +uint64_t block::nitems_read(unsigned int which_input) +{ + if (d_detail) { + return d_detail->nitems_read(which_input); + } else { + // throw std::runtime_error("No block_detail associated with block yet"); + return 0; } - } +} - uint64_t - block::nitems_written(unsigned int which_output) - { - if(d_detail) { - return d_detail->nitems_written(which_output); - } - else { - //throw std::runtime_error("No block_detail associated with block yet"); - return 0; +uint64_t block::nitems_written(unsigned int which_output) +{ + if (d_detail) { + return d_detail->nitems_written(which_output); + } else { + // throw std::runtime_error("No block_detail associated with block yet"); + return 0; } - } +} - void - block::add_item_tag(unsigned int which_output, - const tag_t &tag) - { +void block::add_item_tag(unsigned int which_output, const tag_t& tag) +{ d_detail->add_item_tag(which_output, tag); - } +} - void - block::remove_item_tag(unsigned int which_input, - const tag_t &tag) - { +void block::remove_item_tag(unsigned int which_input, const tag_t& tag) +{ d_detail->remove_item_tag(which_input, tag, unique_id()); - } +} - void - block::get_tags_in_range(std::vector<tag_t> &v, - unsigned int which_input, - uint64_t start, uint64_t end) - { +void block::get_tags_in_range(std::vector<tag_t>& v, + unsigned int which_input, + uint64_t start, + uint64_t end) +{ d_detail->get_tags_in_range(v, which_input, start, end, unique_id()); - } - - void - block::get_tags_in_range(std::vector<tag_t> &v, - unsigned int which_input, - uint64_t start, uint64_t end, - const pmt::pmt_t &key) - { +} + +void block::get_tags_in_range(std::vector<tag_t>& v, + unsigned int which_input, + uint64_t start, + uint64_t end, + const pmt::pmt_t& key) +{ d_detail->get_tags_in_range(v, which_input, start, end, key, unique_id()); - } - - void - block::get_tags_in_window(std::vector<tag_t> &v, - unsigned int which_input, - uint64_t start, uint64_t end) - { - d_detail->get_tags_in_range(v, which_input, +} + +void block::get_tags_in_window(std::vector<tag_t>& v, + unsigned int which_input, + uint64_t start, + uint64_t end) +{ + d_detail->get_tags_in_range(v, + which_input, nitems_read(which_input) + start, nitems_read(which_input) + end, unique_id()); - } - - void - block::get_tags_in_window(std::vector<tag_t> &v, - unsigned int which_input, - uint64_t start, uint64_t end, - const pmt::pmt_t &key) - { - d_detail->get_tags_in_range(v, which_input, +} + +void block::get_tags_in_window(std::vector<tag_t>& v, + unsigned int which_input, + uint64_t start, + uint64_t end, + const pmt::pmt_t& key) +{ + d_detail->get_tags_in_range(v, + which_input, nitems_read(which_input) + start, nitems_read(which_input) + end, - key, unique_id()); - } + key, + unique_id()); +} - block::tag_propagation_policy_t - block::tag_propagation_policy() - { +block::tag_propagation_policy_t block::tag_propagation_policy() +{ return d_tag_propagation_policy; - } +} - void - block::set_tag_propagation_policy(tag_propagation_policy_t p) - { +void block::set_tag_propagation_policy(tag_propagation_policy_t p) +{ d_tag_propagation_policy = p; - } +} - int - block::max_noutput_items() - { - return d_max_noutput_items; - } +int block::max_noutput_items() { return d_max_noutput_items; } - void - block::set_max_noutput_items(int m) - { - if(m <= 0) - throw std::runtime_error("block::set_max_noutput_items: value for max_noutput_items must be greater than 0.\n"); +void block::set_max_noutput_items(int m) +{ + if (m <= 0) + throw std::runtime_error("block::set_max_noutput_items: value for " + "max_noutput_items must be greater than 0.\n"); d_max_noutput_items = m; d_max_noutput_items_set = true; - } - - void - block::unset_max_noutput_items() - { - d_max_noutput_items_set = false; - } - - bool - block::is_set_max_noutput_items() - { - return d_max_noutput_items_set; - } - - void - block::set_processor_affinity(const std::vector<int> &mask) - { +} + +void block::unset_max_noutput_items() { d_max_noutput_items_set = false; } + +bool block::is_set_max_noutput_items() { return d_max_noutput_items_set; } + +void block::set_processor_affinity(const std::vector<int>& mask) +{ d_affinity = mask; - if(d_detail) { - d_detail->set_processor_affinity(d_affinity); + if (d_detail) { + d_detail->set_processor_affinity(d_affinity); } - } +} - void - block::unset_processor_affinity() - { +void block::unset_processor_affinity() +{ d_affinity.clear(); - if(d_detail) { - d_detail->unset_processor_affinity(); + if (d_detail) { + d_detail->unset_processor_affinity(); } - } +} - int - block::active_thread_priority() - { - if(d_detail) { - return d_detail->thread_priority(); +int block::active_thread_priority() +{ + if (d_detail) { + return d_detail->thread_priority(); } return -1; - } +} - int - block::thread_priority() - { - return d_priority; - } +int block::thread_priority() { return d_priority; } - int - block::set_thread_priority(int priority) - { +int block::set_thread_priority(int priority) +{ d_priority = priority; - if(d_detail) { - return d_detail->set_thread_priority(priority); + if (d_detail) { + return d_detail->set_thread_priority(priority); } return d_priority; - } - - void - block::expand_minmax_buffer(int port) - { - if((size_t)port >= d_max_output_buffer.size()) - set_max_output_buffer(port, -1); - if((size_t)port >= d_min_output_buffer.size()) - set_min_output_buffer(port, -1); - } - - long - block::max_output_buffer(size_t i) - { - if(i >= d_max_output_buffer.size()) - throw std::invalid_argument("basic_block::max_output_buffer: port out of range."); +} + +void block::expand_minmax_buffer(int port) +{ + if ((size_t)port >= d_max_output_buffer.size()) + set_max_output_buffer(port, -1); + if ((size_t)port >= d_min_output_buffer.size()) + set_min_output_buffer(port, -1); +} + +long block::max_output_buffer(size_t i) +{ + if (i >= d_max_output_buffer.size()) + throw std::invalid_argument("basic_block::max_output_buffer: port out of range."); return d_max_output_buffer[i]; - } +} - void - block::set_max_output_buffer(long max_output_buffer) - { - for(int i = 0; i < output_signature()->max_streams(); i++) { - set_max_output_buffer(i, max_output_buffer); +void block::set_max_output_buffer(long max_output_buffer) +{ + for (int i = 0; i < output_signature()->max_streams(); i++) { + set_max_output_buffer(i, max_output_buffer); } - } +} - void - block::set_max_output_buffer(int port, long max_output_buffer) - { - if((size_t)port >= d_max_output_buffer.size()) - d_max_output_buffer.push_back(max_output_buffer); +void block::set_max_output_buffer(int port, long max_output_buffer) +{ + if ((size_t)port >= d_max_output_buffer.size()) + d_max_output_buffer.push_back(max_output_buffer); else - d_max_output_buffer[port] = max_output_buffer; - } - - long - block::min_output_buffer(size_t i) - { - if(i >= d_min_output_buffer.size()) - throw std::invalid_argument("basic_block::min_output_buffer: port out of range."); + d_max_output_buffer[port] = max_output_buffer; +} + +long block::min_output_buffer(size_t i) +{ + if (i >= d_min_output_buffer.size()) + throw std::invalid_argument("basic_block::min_output_buffer: port out of range."); return d_min_output_buffer[i]; - } - - void - block::set_min_output_buffer(long min_output_buffer) - { - std::cout << "set_min_output_buffer on block " << unique_id() << " to " << min_output_buffer << std::endl; - for(int i=0; i<output_signature()->max_streams(); i++) { - set_min_output_buffer(i, min_output_buffer); - } - } - - void - block::set_min_output_buffer(int port, long min_output_buffer) - { - if((size_t)port >= d_min_output_buffer.size()) - d_min_output_buffer.push_back(min_output_buffer); +} + +void block::set_min_output_buffer(long min_output_buffer) +{ + std::cout << "set_min_output_buffer on block " << unique_id() << " to " + << min_output_buffer << std::endl; + for (int i = 0; i < output_signature()->max_streams(); i++) { + set_min_output_buffer(i, min_output_buffer); + } +} + +void block::set_min_output_buffer(int port, long min_output_buffer) +{ + if ((size_t)port >= d_min_output_buffer.size()) + d_min_output_buffer.push_back(min_output_buffer); else - d_min_output_buffer[port] = min_output_buffer; - } + d_min_output_buffer[port] = min_output_buffer; +} - bool - block::update_rate() const - { - return d_update_rate; - } +bool block::update_rate() const { return d_update_rate; } - void - block::enable_update_rate(bool en) - { - d_update_rate = en; - } +void block::enable_update_rate(bool en) { d_update_rate = en; } - float - block::pc_noutput_items() - { - if(d_detail) { - return d_detail->pc_noutput_items(); - } - else { - return 0; +float block::pc_noutput_items() +{ + if (d_detail) { + return d_detail->pc_noutput_items(); + } else { + return 0; } - } +} - float - block::pc_noutput_items_avg() - { - if(d_detail) { - return d_detail->pc_noutput_items_avg(); - } - else { - return 0; +float block::pc_noutput_items_avg() +{ + if (d_detail) { + return d_detail->pc_noutput_items_avg(); + } else { + return 0; } - } +} - float - block::pc_noutput_items_var() - { - if(d_detail) { - return d_detail->pc_noutput_items_var(); - } - else { - return 0; +float block::pc_noutput_items_var() +{ + if (d_detail) { + return d_detail->pc_noutput_items_var(); + } else { + return 0; } - } +} - float - block::pc_nproduced() - { - if(d_detail) { - return d_detail->pc_nproduced(); - } - else { - return 0; +float block::pc_nproduced() +{ + if (d_detail) { + return d_detail->pc_nproduced(); + } else { + return 0; } - } +} - float - block::pc_nproduced_avg() - { - if(d_detail) { - return d_detail->pc_nproduced_avg(); - } - else { - return 0; +float block::pc_nproduced_avg() +{ + if (d_detail) { + return d_detail->pc_nproduced_avg(); + } else { + return 0; } - } +} - float - block::pc_nproduced_var() - { - if(d_detail) { - return d_detail->pc_nproduced_var(); - } - else { - return 0; +float block::pc_nproduced_var() +{ + if (d_detail) { + return d_detail->pc_nproduced_var(); + } else { + return 0; } - } +} - float - block::pc_input_buffers_full(int which) - { - if(d_detail) { - return d_detail->pc_input_buffers_full(static_cast<size_t>(which)); - } - else { - return 0; +float block::pc_input_buffers_full(int which) +{ + if (d_detail) { + return d_detail->pc_input_buffers_full(static_cast<size_t>(which)); + } else { + return 0; } - } +} - float - block::pc_input_buffers_full_avg(int which) - { - if(d_detail) { - return d_detail->pc_input_buffers_full_avg(static_cast<size_t>(which)); - } - else { - return 0; +float block::pc_input_buffers_full_avg(int which) +{ + if (d_detail) { + return d_detail->pc_input_buffers_full_avg(static_cast<size_t>(which)); + } else { + return 0; } - } +} - float - block::pc_input_buffers_full_var(int which) - { - if(d_detail) { - return d_detail->pc_input_buffers_full_var(static_cast<size_t>(which)); - } - else { - return 0; +float block::pc_input_buffers_full_var(int which) +{ + if (d_detail) { + return d_detail->pc_input_buffers_full_var(static_cast<size_t>(which)); + } else { + return 0; } - } +} - std::vector<float> - block::pc_input_buffers_full() - { - if(d_detail) { - return d_detail->pc_input_buffers_full(); - } - else { - return std::vector<float>(1,0); +std::vector<float> block::pc_input_buffers_full() +{ + if (d_detail) { + return d_detail->pc_input_buffers_full(); + } else { + return std::vector<float>(1, 0); } - } +} - std::vector<float> - block::pc_input_buffers_full_avg() - { - if(d_detail) { - return d_detail->pc_input_buffers_full_avg(); - } - else { - return std::vector<float>(1,0); +std::vector<float> block::pc_input_buffers_full_avg() +{ + if (d_detail) { + return d_detail->pc_input_buffers_full_avg(); + } else { + return std::vector<float>(1, 0); } - } +} - std::vector<float> - block::pc_input_buffers_full_var() - { - if(d_detail) { - return d_detail->pc_input_buffers_full_var(); - } - else { - return std::vector<float>(1,0); +std::vector<float> block::pc_input_buffers_full_var() +{ + if (d_detail) { + return d_detail->pc_input_buffers_full_var(); + } else { + return std::vector<float>(1, 0); } - } +} - float - block::pc_output_buffers_full(int which) - { - if(d_detail) { - return d_detail->pc_output_buffers_full(static_cast<size_t>(which)); - } - else { - return 0; +float block::pc_output_buffers_full(int which) +{ + if (d_detail) { + return d_detail->pc_output_buffers_full(static_cast<size_t>(which)); + } else { + return 0; } - } +} - float - block::pc_output_buffers_full_avg(int which) - { - if(d_detail) { - return d_detail->pc_output_buffers_full_avg(static_cast<size_t>(which)); - } - else { - return 0; +float block::pc_output_buffers_full_avg(int which) +{ + if (d_detail) { + return d_detail->pc_output_buffers_full_avg(static_cast<size_t>(which)); + } else { + return 0; } - } +} - float - block::pc_output_buffers_full_var(int which) - { - if(d_detail) { - return d_detail->pc_output_buffers_full_var(static_cast<size_t>(which)); - } - else { - return 0; +float block::pc_output_buffers_full_var(int which) +{ + if (d_detail) { + return d_detail->pc_output_buffers_full_var(static_cast<size_t>(which)); + } else { + return 0; } - } +} - std::vector<float> - block::pc_output_buffers_full() - { - if(d_detail) { - return d_detail->pc_output_buffers_full(); - } - else { - return std::vector<float>(1,0); +std::vector<float> block::pc_output_buffers_full() +{ + if (d_detail) { + return d_detail->pc_output_buffers_full(); + } else { + return std::vector<float>(1, 0); } - } +} - std::vector<float> - block::pc_output_buffers_full_avg() - { - if(d_detail) { - return d_detail->pc_output_buffers_full_avg(); - } - else { - return std::vector<float>(1,0); +std::vector<float> block::pc_output_buffers_full_avg() +{ + if (d_detail) { + return d_detail->pc_output_buffers_full_avg(); + } else { + return std::vector<float>(1, 0); } - } +} - std::vector<float> - block::pc_output_buffers_full_var() - { - if(d_detail) { - return d_detail->pc_output_buffers_full_var(); - } - else { - return std::vector<float>(1,0); +std::vector<float> block::pc_output_buffers_full_var() +{ + if (d_detail) { + return d_detail->pc_output_buffers_full_var(); + } else { + return std::vector<float>(1, 0); } - } +} - float - block::pc_work_time() - { - if(d_detail) { - return d_detail->pc_work_time(); - } - else { - return 0; +float block::pc_work_time() +{ + if (d_detail) { + return d_detail->pc_work_time(); + } else { + return 0; } - } +} - float - block::pc_work_time_avg() - { - if(d_detail) { - return d_detail->pc_work_time_avg(); - } - else { - return 0; +float block::pc_work_time_avg() +{ + if (d_detail) { + return d_detail->pc_work_time_avg(); + } else { + return 0; } - } +} - float - block::pc_work_time_var() - { - if(d_detail) { - return d_detail->pc_work_time_var(); - } - else { - return 0; +float block::pc_work_time_var() +{ + if (d_detail) { + return d_detail->pc_work_time_var(); + } else { + return 0; } - } +} - float - block::pc_work_time_total() - { - if(d_detail) { - return d_detail->pc_work_time_total(); - } - else { - return 0; +float block::pc_work_time_total() +{ + if (d_detail) { + return d_detail->pc_work_time_total(); + } else { + return 0; } - } +} - float - block::pc_throughput_avg() { - if(d_detail) { - return d_detail->pc_throughput_avg(); - } - else { - return 0; +float block::pc_throughput_avg() +{ + if (d_detail) { + return d_detail->pc_throughput_avg(); + } else { + return 0; } - } +} - void - block::reset_perf_counters() - { - if(d_detail) { - d_detail->reset_perf_counters(); +void block::reset_perf_counters() +{ + if (d_detail) { + d_detail->reset_perf_counters(); } - } +} - void - block::system_handler(pmt::pmt_t msg) - { - //std::cout << "system_handler " << msg << "\n"; +void block::system_handler(pmt::pmt_t msg) +{ + // std::cout << "system_handler " << msg << "\n"; pmt::pmt_t op = pmt::car(msg); - if(pmt::eqv(op, d_pmt_done)){ + if (pmt::eqv(op, d_pmt_done)) { d_finished = pmt::to_long(pmt::cdr(msg)); global_block_registry.notify_blk(alias()); } else { std::cout << "WARNING: bad message op on system port!\n"; pmt::print(msg); } - } +} - void - block::set_log_level(std::string level) - { - logger_set_level(d_logger, level); - } +void block::set_log_level(std::string level) { logger_set_level(d_logger, level); } - std::string - block::log_level() - { +std::string block::log_level() +{ std::string level; logger_get_level(d_logger, level); return level; - } +} - void - block::notify_msg_neighbors() - { +void block::notify_msg_neighbors() +{ size_t len = pmt::length(d_message_subscribers); pmt::pmt_t port_names = pmt::make_vector(len, pmt::PMT_NIL); pmt::pmt_t keys = pmt::dict_keys(d_message_subscribers); - for(size_t i = 0; i < len; i++) { - // for each output port - pmt::pmt_t oport = pmt::nth(i,keys); + for (size_t i = 0; i < len; i++) { + // for each output port + pmt::pmt_t oport = pmt::nth(i, keys); - // for each subscriber on this port - pmt::pmt_t currlist = pmt::dict_ref(d_message_subscribers, oport, pmt::PMT_NIL); + // for each subscriber on this port + pmt::pmt_t currlist = pmt::dict_ref(d_message_subscribers, oport, pmt::PMT_NIL); - // iterate through subscribers on port - while(pmt::is_pair(currlist)) { - pmt::pmt_t target = pmt::car(currlist); + // iterate through subscribers on port + while (pmt::is_pair(currlist)) { + pmt::pmt_t target = pmt::car(currlist); - pmt::pmt_t block = pmt::car(target); + pmt::pmt_t block = pmt::car(target); - currlist = pmt::cdr(currlist); - basic_block_sptr blk = global_block_registry.block_lookup(block); - blk->post(d_system_port, pmt::cons(d_pmt_done, pmt::mp(true))); + currlist = pmt::cdr(currlist); + basic_block_sptr blk = global_block_registry.block_lookup(block); + blk->post(d_system_port, pmt::cons(d_pmt_done, pmt::mp(true))); } } - } +} - bool - block::finished() - { - if(detail()->ninputs() != 0) - return false; +bool block::finished() +{ + if (detail()->ninputs() != 0) + return false; else - return d_finished; - } - + return d_finished; +} - void - block::setup_pc_rpc() - { +void block::setup_pc_rpc() +{ d_pc_rpc_set = true; #if defined(GR_CTRLPORT) && defined(GR_PERFORMANCE_COUNTERS) #include <gnuradio/rpcregisterhelpers.h> - d_rpc_vars.push_back( - rpcbasic_sptr(new rpcbasic_register_trigger<block>( - alias(), "reset_perf_counters", &block::reset_perf_counters, - "Reset the Performance Counters", RPC_PRIVLVL_MIN))); - - d_rpc_vars.push_back( - rpcbasic_sptr(new rpcbasic_register_get<block, float>( - alias(), "noutput_items", &block::pc_noutput_items, - pmt::mp(0), pmt::mp(32768), pmt::mp(0), - "", "noutput items", RPC_PRIVLVL_MIN, - DISPTIME | DISPOPTSTRIP))); - - d_rpc_vars.push_back( - rpcbasic_sptr(new rpcbasic_register_get<block, float>( - alias(), "avg noutput_items", &block::pc_noutput_items_avg, - pmt::mp(0), pmt::mp(32768), pmt::mp(0), - "", "Average noutput items", RPC_PRIVLVL_MIN, - DISPTIME | DISPOPTSTRIP))); - - d_rpc_vars.push_back( - rpcbasic_sptr(new rpcbasic_register_get<block, float>( - alias(), "var noutput_items", &block::pc_noutput_items_var, - pmt::mp(0), pmt::mp(32768), pmt::mp(0), - "", "Var. noutput items", RPC_PRIVLVL_MIN, - DISPTIME | DISPOPTSTRIP))); - - d_rpc_vars.push_back( - rpcbasic_sptr(new rpcbasic_register_get<block, float>( - alias(), "nproduced", &block::pc_nproduced, - pmt::mp(0), pmt::mp(32768), pmt::mp(0), - "", "items produced", RPC_PRIVLVL_MIN, - DISPTIME | DISPOPTSTRIP))); - - d_rpc_vars.push_back( - rpcbasic_sptr(new rpcbasic_register_get<block, float>( - alias(), "avg nproduced", &block::pc_nproduced_avg, - pmt::mp(0), pmt::mp(32768), pmt::mp(0), - "", "Average items produced", RPC_PRIVLVL_MIN, - DISPTIME | DISPOPTSTRIP))); - - d_rpc_vars.push_back( - rpcbasic_sptr(new rpcbasic_register_get<block, float>( - alias(), "var nproduced", &block::pc_nproduced_var, - pmt::mp(0), pmt::mp(32768), pmt::mp(0), - "", "Var. items produced", RPC_PRIVLVL_MIN, - DISPTIME | DISPOPTSTRIP))); + d_rpc_vars.push_back(rpcbasic_sptr( + new rpcbasic_register_trigger<block>(alias(), + "reset_perf_counters", + &block::reset_perf_counters, + "Reset the Performance Counters", + RPC_PRIVLVL_MIN))); d_rpc_vars.push_back( - rpcbasic_sptr(new rpcbasic_register_get<block, float>( - alias(), "work time", &block::pc_work_time, - pmt::mp(0), pmt::mp(1e9), pmt::mp(0), - "", "clock cycles in call to work", RPC_PRIVLVL_MIN, - DISPTIME | DISPOPTSTRIP))); + rpcbasic_sptr(new rpcbasic_register_get<block, float>(alias(), + "noutput_items", + &block::pc_noutput_items, + pmt::mp(0), + pmt::mp(32768), + pmt::mp(0), + "", + "noutput items", + RPC_PRIVLVL_MIN, + DISPTIME | DISPOPTSTRIP))); + + d_rpc_vars.push_back(rpcbasic_sptr( + new rpcbasic_register_get<block, float>(alias(), + "avg noutput_items", + &block::pc_noutput_items_avg, + pmt::mp(0), + pmt::mp(32768), + pmt::mp(0), + "", + "Average noutput items", + RPC_PRIVLVL_MIN, + DISPTIME | DISPOPTSTRIP))); + + d_rpc_vars.push_back(rpcbasic_sptr( + new rpcbasic_register_get<block, float>(alias(), + "var noutput_items", + &block::pc_noutput_items_var, + pmt::mp(0), + pmt::mp(32768), + pmt::mp(0), + "", + "Var. noutput items", + RPC_PRIVLVL_MIN, + DISPTIME | DISPOPTSTRIP))); d_rpc_vars.push_back( - rpcbasic_sptr(new rpcbasic_register_get<block, float>( - alias(), "avg work time", &block::pc_work_time_avg, - pmt::mp(0), pmt::mp(1e9), pmt::mp(0), - "", "Average clock cycles in call to work", RPC_PRIVLVL_MIN, - DISPTIME | DISPOPTSTRIP))); + rpcbasic_sptr(new rpcbasic_register_get<block, float>(alias(), + "nproduced", + &block::pc_nproduced, + pmt::mp(0), + pmt::mp(32768), + pmt::mp(0), + "", + "items produced", + RPC_PRIVLVL_MIN, + DISPTIME | DISPOPTSTRIP))); d_rpc_vars.push_back( - rpcbasic_sptr(new rpcbasic_register_get<block, float>( - alias(), "var work time", &block::pc_work_time_var, - pmt::mp(0), pmt::mp(1e9), pmt::mp(0), - "", "Var. clock cycles in call to work", RPC_PRIVLVL_MIN, - DISPTIME | DISPOPTSTRIP))); + rpcbasic_sptr(new rpcbasic_register_get<block, float>(alias(), + "avg nproduced", + &block::pc_nproduced_avg, + pmt::mp(0), + pmt::mp(32768), + pmt::mp(0), + "", + "Average items produced", + RPC_PRIVLVL_MIN, + DISPTIME | DISPOPTSTRIP))); d_rpc_vars.push_back( - rpcbasic_sptr(new rpcbasic_register_get<block, float>( - alias(), "total work time", &block::pc_work_time_total, - pmt::mp(0), pmt::mp(1e9), pmt::mp(0), - "", "Total clock cycles in calls to work", RPC_PRIVLVL_MIN, + rpcbasic_sptr(new rpcbasic_register_get<block, float>(alias(), + "var nproduced", + &block::pc_nproduced_var, + pmt::mp(0), + pmt::mp(32768), + pmt::mp(0), + "", + "Var. items produced", + RPC_PRIVLVL_MIN, + DISPTIME | DISPOPTSTRIP))); + + d_rpc_vars.push_back(rpcbasic_sptr( + new rpcbasic_register_get<block, float>(alias(), + "work time", + &block::pc_work_time, + pmt::mp(0), + pmt::mp(1e9), + pmt::mp(0), + "", + "clock cycles in call to work", + RPC_PRIVLVL_MIN, + DISPTIME | DISPOPTSTRIP))); + + d_rpc_vars.push_back(rpcbasic_sptr( + new rpcbasic_register_get<block, float>(alias(), + "avg work time", + &block::pc_work_time_avg, + pmt::mp(0), + pmt::mp(1e9), + pmt::mp(0), + "", + "Average clock cycles in call to work", + RPC_PRIVLVL_MIN, + DISPTIME | DISPOPTSTRIP))); + + d_rpc_vars.push_back(rpcbasic_sptr( + new rpcbasic_register_get<block, float>(alias(), + "var work time", + &block::pc_work_time_var, + pmt::mp(0), + pmt::mp(1e9), + pmt::mp(0), + "", + "Var. clock cycles in call to work", + RPC_PRIVLVL_MIN, + DISPTIME | DISPOPTSTRIP))); + + d_rpc_vars.push_back(rpcbasic_sptr( + new rpcbasic_register_get<block, float>(alias(), + "total work time", + &block::pc_work_time_total, + pmt::mp(0), + pmt::mp(1e9), + pmt::mp(0), + "", + "Total clock cycles in calls to work", + RPC_PRIVLVL_MIN, + DISPTIME | DISPOPTSTRIP))); + + d_rpc_vars.push_back(rpcbasic_sptr(new rpcbasic_register_get<block, float>( + alias(), + "avg throughput", + &block::pc_throughput_avg, + pmt::mp(0), + pmt::mp(1e9), + pmt::mp(0), + "items/s", + "Average items throughput in call to work", + RPC_PRIVLVL_MIN, DISPTIME | DISPOPTSTRIP))); d_rpc_vars.push_back( - rpcbasic_sptr(new rpcbasic_register_get<block, float>( - alias(), "avg throughput", &block::pc_throughput_avg, - pmt::mp(0), pmt::mp(1e9), pmt::mp(0), - "items/s", "Average items throughput in call to work", RPC_PRIVLVL_MIN, - DISPTIME | DISPOPTSTRIP))); + rpcbasic_sptr(new rpcbasic_register_get<block, std::vector<float>>( + alias(), + "input \% full", + &block::pc_input_buffers_full, + pmt::make_f32vector(0, 0), + pmt::make_f32vector(0, 1), + pmt::make_f32vector(0, 0), + "", + "how full input buffers are", + RPC_PRIVLVL_MIN, + DISPTIME | DISPOPTSTRIP))); d_rpc_vars.push_back( - rpcbasic_sptr(new rpcbasic_register_get<block, std::vector<float> >( - alias(), "input \% full", &block::pc_input_buffers_full, - pmt::make_f32vector(0,0), pmt::make_f32vector(0,1), pmt::make_f32vector(0,0), - "", "how full input buffers are", RPC_PRIVLVL_MIN, - DISPTIME | DISPOPTSTRIP))); + rpcbasic_sptr(new rpcbasic_register_get<block, std::vector<float>>( + alias(), + "avg input \% full", + &block::pc_input_buffers_full_avg, + pmt::make_f32vector(0, 0), + pmt::make_f32vector(0, 1), + pmt::make_f32vector(0, 0), + "", + "Average of how full input buffers are", + RPC_PRIVLVL_MIN, + DISPTIME | DISPOPTSTRIP))); d_rpc_vars.push_back( - rpcbasic_sptr(new rpcbasic_register_get<block, std::vector<float> >( - alias(), "avg input \% full", &block::pc_input_buffers_full_avg, - pmt::make_f32vector(0,0), pmt::make_f32vector(0,1), pmt::make_f32vector(0,0), - "", "Average of how full input buffers are", RPC_PRIVLVL_MIN, - DISPTIME | DISPOPTSTRIP))); + rpcbasic_sptr(new rpcbasic_register_get<block, std::vector<float>>( + alias(), + "var input \% full", + &block::pc_input_buffers_full_var, + pmt::make_f32vector(0, 0), + pmt::make_f32vector(0, 1), + pmt::make_f32vector(0, 0), + "", + "Var. of how full input buffers are", + RPC_PRIVLVL_MIN, + DISPTIME | DISPOPTSTRIP))); d_rpc_vars.push_back( - rpcbasic_sptr(new rpcbasic_register_get<block, std::vector<float> >( - alias(), "var input \% full", &block::pc_input_buffers_full_var, - pmt::make_f32vector(0,0), pmt::make_f32vector(0,1), pmt::make_f32vector(0,0), - "", "Var. of how full input buffers are", RPC_PRIVLVL_MIN, - DISPTIME | DISPOPTSTRIP))); + rpcbasic_sptr(new rpcbasic_register_get<block, std::vector<float>>( + alias(), + "output \% full", + &block::pc_output_buffers_full, + pmt::make_f32vector(0, 0), + pmt::make_f32vector(0, 1), + pmt::make_f32vector(0, 0), + "", + "how full output buffers are", + RPC_PRIVLVL_MIN, + DISPTIME | DISPOPTSTRIP))); d_rpc_vars.push_back( - rpcbasic_sptr(new rpcbasic_register_get<block, std::vector<float> >( - alias(), "output \% full", &block::pc_output_buffers_full, - pmt::make_f32vector(0,0), pmt::make_f32vector(0,1), pmt::make_f32vector(0,0), - "", "how full output buffers are", RPC_PRIVLVL_MIN, - DISPTIME | DISPOPTSTRIP))); - - d_rpc_vars.push_back( - rpcbasic_sptr(new rpcbasic_register_get<block, std::vector<float> >( - alias(), "avg output \% full", &block::pc_output_buffers_full_avg, - pmt::make_f32vector(0,0), pmt::make_f32vector(0,1), pmt::make_f32vector(0,0), - "", "Average of how full output buffers are", RPC_PRIVLVL_MIN, - DISPTIME | DISPOPTSTRIP))); + rpcbasic_sptr(new rpcbasic_register_get<block, std::vector<float>>( + alias(), + "avg output \% full", + &block::pc_output_buffers_full_avg, + pmt::make_f32vector(0, 0), + pmt::make_f32vector(0, 1), + pmt::make_f32vector(0, 0), + "", + "Average of how full output buffers are", + RPC_PRIVLVL_MIN, + DISPTIME | DISPOPTSTRIP))); d_rpc_vars.push_back( - rpcbasic_sptr(new rpcbasic_register_get<block, std::vector<float> >( - alias(), "var output \% full", &block::pc_output_buffers_full_var, - pmt::make_f32vector(0,0), pmt::make_f32vector(0,1), pmt::make_f32vector(0,0), - "", "Var. of how full output buffers are", RPC_PRIVLVL_MIN, - DISPTIME | DISPOPTSTRIP))); + rpcbasic_sptr(new rpcbasic_register_get<block, std::vector<float>>( + alias(), + "var output \% full", + &block::pc_output_buffers_full_var, + pmt::make_f32vector(0, 0), + pmt::make_f32vector(0, 1), + pmt::make_f32vector(0, 0), + "", + "Var. of how full output buffers are", + RPC_PRIVLVL_MIN, + DISPTIME | DISPOPTSTRIP))); #endif /* defined(GR_CTRLPORT) && defined(GR_PERFORMANCE_COUNTERS) */ - } +} - std::string block::identifier() const { +std::string block::identifier() const +{ return d_name + "(" + std::to_string(d_unique_id) + ")"; - } +} - std::ostream& - operator << (std::ostream& os, const block *m) - { +std::ostream& operator<<(std::ostream& os, const block* m) +{ os << "<block " << m->identifier() << ">"; return os; - } - - int - block::general_work(int noutput_items, - gr_vector_int &ninput_items, - gr_vector_const_void_star &input_items, - gr_vector_void_star &output_items) - { +} + +int block::general_work(int noutput_items, + gr_vector_int& ninput_items, + gr_vector_const_void_star& input_items, + gr_vector_void_star& output_items) +{ throw std::runtime_error("block::general_work() not implemented"); return 0; - } +} } /* namespace gr */ diff --git a/gnuradio-runtime/lib/block_detail.cc b/gnuradio-runtime/lib/block_detail.cc index 3da150ed8f..fb90995343 100644 --- a/gnuradio-runtime/lib/block_detail.cc +++ b/gnuradio-runtime/lib/block_detail.cc @@ -30,18 +30,16 @@ namespace gr { - static long s_ncurrently_allocated = 0; +static long s_ncurrently_allocated = 0; - long - block_detail_ncurrently_allocated() - { - return s_ncurrently_allocated; - } +long block_detail_ncurrently_allocated() { return s_ncurrently_allocated; } - block_detail::block_detail(unsigned int ninputs, unsigned int noutputs) +block_detail::block_detail(unsigned int ninputs, unsigned int noutputs) : d_produce_or(0), - d_ninputs(ninputs), d_noutputs(noutputs), - d_input(ninputs), d_output(noutputs), + d_ninputs(ninputs), + d_noutputs(noutputs), + d_input(ninputs), + d_output(noutputs), d_done(false), d_ins_noutput_items(0), d_avg_noutput_items(0), @@ -61,177 +59,155 @@ namespace gr { d_var_work_time(0), d_avg_throughput(0), d_pc_counter(0) - { +{ s_ncurrently_allocated++; d_pc_start_time = gr::high_res_timer_now(); - } +} - block_detail::~block_detail() - { +block_detail::~block_detail() +{ // should take care of itself s_ncurrently_allocated--; - } +} - void - block_detail::set_input(unsigned int which, buffer_reader_sptr reader) - { - if(which >= d_ninputs) - throw std::invalid_argument("block_detail::set_input"); +void block_detail::set_input(unsigned int which, buffer_reader_sptr reader) +{ + if (which >= d_ninputs) + throw std::invalid_argument("block_detail::set_input"); d_input[which] = reader; - } +} - void - block_detail::set_output(unsigned int which, buffer_sptr buffer) - { - if(which >= d_noutputs) - throw std::invalid_argument("block_detail::set_output"); +void block_detail::set_output(unsigned int which, buffer_sptr buffer) +{ + if (which >= d_noutputs) + throw std::invalid_argument("block_detail::set_output"); d_output[which] = buffer; - } +} - block_detail_sptr - make_block_detail(unsigned int ninputs, unsigned int noutputs) - { - return block_detail_sptr (new block_detail(ninputs, noutputs)); - } +block_detail_sptr make_block_detail(unsigned int ninputs, unsigned int noutputs) +{ + return block_detail_sptr(new block_detail(ninputs, noutputs)); +} - void - block_detail::set_done(bool done) - { +void block_detail::set_done(bool done) +{ d_done = done; - for(unsigned int i = 0; i < d_noutputs; i++) - d_output[i]->set_done(done); + for (unsigned int i = 0; i < d_noutputs; i++) + d_output[i]->set_done(done); - for(unsigned int i = 0; i < d_ninputs; i++) - d_input[i]->set_done(done); - } + for (unsigned int i = 0; i < d_ninputs; i++) + d_input[i]->set_done(done); +} - void - block_detail::consume(int which_input, int how_many_items) - { +void block_detail::consume(int which_input, int how_many_items) +{ d_consumed = how_many_items; - if(how_many_items > 0) { - input(which_input)->update_read_pointer(how_many_items); + if (how_many_items > 0) { + input(which_input)->update_read_pointer(how_many_items); } - } +} - int - block_detail::consumed() const - { - return d_consumed; - } +int block_detail::consumed() const { return d_consumed; } - void - block_detail::consume_each(int how_many_items) - { +void block_detail::consume_each(int how_many_items) +{ d_consumed = how_many_items; - if(how_many_items > 0) { - for(int i = 0; i < ninputs (); i++) { - d_input[i]->update_read_pointer(how_many_items); - } + if (how_many_items > 0) { + for (int i = 0; i < ninputs(); i++) { + d_input[i]->update_read_pointer(how_many_items); + } } - } - - void - block_detail::produce(int which_output, int how_many_items) - { - if(how_many_items > 0) { - d_output[which_output]->update_write_pointer(how_many_items); - d_produce_or |= how_many_items; +} + +void block_detail::produce(int which_output, int how_many_items) +{ + if (how_many_items > 0) { + d_output[which_output]->update_write_pointer(how_many_items); + d_produce_or |= how_many_items; } - } - - void - block_detail::produce_each(int how_many_items) - { - if(how_many_items > 0) { - for(int i = 0; i < noutputs (); i++) { - d_output[i]->update_write_pointer (how_many_items); - } - d_produce_or |= how_many_items; +} + +void block_detail::produce_each(int how_many_items) +{ + if (how_many_items > 0) { + for (int i = 0; i < noutputs(); i++) { + d_output[i]->update_write_pointer(how_many_items); + } + d_produce_or |= how_many_items; } - } +} - uint64_t - block_detail::nitems_read(unsigned int which_input) - { - if(which_input >= d_ninputs) - throw std::invalid_argument ("block_detail::n_input_items"); +uint64_t block_detail::nitems_read(unsigned int which_input) +{ + if (which_input >= d_ninputs) + throw std::invalid_argument("block_detail::n_input_items"); return d_input[which_input]->nitems_read(); - } +} - uint64_t - block_detail::nitems_written(unsigned int which_output) - { - if(which_output >= d_noutputs) - throw std::invalid_argument ("block_detail::n_output_items"); +uint64_t block_detail::nitems_written(unsigned int which_output) +{ + if (which_output >= d_noutputs) + throw std::invalid_argument("block_detail::n_output_items"); return d_output[which_output]->nitems_written(); - } +} - void - block_detail::reset_nitem_counters() - { - for(unsigned int i = 0; i < d_ninputs; i++) { - d_input[i]->reset_nitem_counter(); - } - for(unsigned int o = 0; o < d_noutputs; o++) { - d_output[o]->reset_nitem_counter(); +void block_detail::reset_nitem_counters() +{ + for (unsigned int i = 0; i < d_ninputs; i++) { + d_input[i]->reset_nitem_counter(); } - } - - void - block_detail::clear_tags() - { - for(unsigned int i = 0; i < d_ninputs; i++) { - uint64_t max_time = 0xFFFFFFFFFFFFFFFF; // from now to the end of time - d_input[i]->buffer()->prune_tags(max_time); + for (unsigned int o = 0; o < d_noutputs; o++) { + d_output[o]->reset_nitem_counter(); } - } +} - void - block_detail::add_item_tag(unsigned int which_output, const tag_t &tag) - { - if(!pmt::is_symbol(tag.key)) { - throw pmt::wrong_type("block_detail::add_item_tag key", tag.key); +void block_detail::clear_tags() +{ + for (unsigned int i = 0; i < d_ninputs; i++) { + uint64_t max_time = 0xFFFFFFFFFFFFFFFF; // from now to the end of time + d_input[i]->buffer()->prune_tags(max_time); } - else { - // Add tag to gr_buffer's deque tags - d_output[which_output]->add_item_tag(tag); +} + +void block_detail::add_item_tag(unsigned int which_output, const tag_t& tag) +{ + if (!pmt::is_symbol(tag.key)) { + throw pmt::wrong_type("block_detail::add_item_tag key", tag.key); + } else { + // Add tag to gr_buffer's deque tags + d_output[which_output]->add_item_tag(tag); } - } - - void - block_detail::remove_item_tag(unsigned int which_input, const tag_t &tag, long id) - { - if(!pmt::is_symbol(tag.key)) { - throw pmt::wrong_type("block_detail::add_item_tag key", tag.key); +} + +void block_detail::remove_item_tag(unsigned int which_input, const tag_t& tag, long id) +{ + if (!pmt::is_symbol(tag.key)) { + throw pmt::wrong_type("block_detail::add_item_tag key", tag.key); + } else { + // Add tag to gr_buffer's deque tags + d_input[which_input]->buffer()->remove_item_tag(tag, id); } - else { - // Add tag to gr_buffer's deque tags - d_input[which_input]->buffer()->remove_item_tag(tag, id); - } - } - - void - block_detail::get_tags_in_range(std::vector<tag_t> &v, - unsigned int which_input, - uint64_t abs_start, - uint64_t abs_end, - long id) - { +} + +void block_detail::get_tags_in_range(std::vector<tag_t>& v, + unsigned int which_input, + uint64_t abs_start, + uint64_t abs_end, + long id) +{ // get from gr_buffer_reader's deque of tags d_input[which_input]->get_tags_in_range(v, abs_start, abs_end, id); - } - - void - block_detail::get_tags_in_range(std::vector<tag_t> &v, - unsigned int which_input, - uint64_t abs_start, - uint64_t abs_end, - const pmt::pmt_t &key, - long id) - { +} + +void block_detail::get_tags_in_range(std::vector<tag_t>& v, + unsigned int which_input, + uint64_t abs_start, + uint64_t abs_end, + const pmt::pmt_t& key, + long id) +{ std::vector<tag_t> found_items; v.resize(0); @@ -242,308 +218,249 @@ namespace gr { // Filter further by key name pmt::pmt_t itemkey; std::vector<tag_t>::iterator itr; - for(itr = found_items.begin(); itr != found_items.end(); itr++) { - itemkey = (*itr).key; - if(pmt::eqv(key, itemkey)) { - v.push_back(*itr); - } + for (itr = found_items.begin(); itr != found_items.end(); itr++) { + itemkey = (*itr).key; + if (pmt::eqv(key, itemkey)) { + v.push_back(*itr); + } } - } - - void - block_detail::set_processor_affinity(const std::vector<int> &mask) - { - if(threaded) { - try { - gr::thread::thread_bind_to_processor(thread, mask); - } - catch (std::runtime_error e) { - std::cerr << "set_processor_affinity: invalid mask." << std::endl;; - } +} + +void block_detail::set_processor_affinity(const std::vector<int>& mask) +{ + if (threaded) { + try { + gr::thread::thread_bind_to_processor(thread, mask); + } catch (std::runtime_error e) { + std::cerr << "set_processor_affinity: invalid mask." << std::endl; + ; + } } - } +} - void - block_detail::unset_processor_affinity() - { - if(threaded) { - gr::thread::thread_unbind(thread); +void block_detail::unset_processor_affinity() +{ + if (threaded) { + gr::thread::thread_unbind(thread); } - } +} - int - block_detail::thread_priority(){ - if(threaded) { - return gr::thread::thread_priority(thread); +int block_detail::thread_priority() +{ + if (threaded) { + return gr::thread::thread_priority(thread); } return -1; - } +} - int - block_detail::set_thread_priority(int priority){ - if(threaded) { - return gr::thread::set_thread_priority(thread,priority); +int block_detail::set_thread_priority(int priority) +{ + if (threaded) { + return gr::thread::set_thread_priority(thread, priority); } return -1; - } +} - void - block_detail::start_perf_counters() - { +void block_detail::start_perf_counters() +{ d_start_of_work = gr::high_res_timer_now_perfmon(); - } +} - void - block_detail::stop_perf_counters(int noutput_items, int nproduced) - { +void block_detail::stop_perf_counters(int noutput_items, int nproduced) +{ d_end_of_work = gr::high_res_timer_now_perfmon(); gr::high_res_timer_type diff = d_end_of_work - d_start_of_work; - if(d_pc_counter == 0) { - d_ins_work_time = diff; - d_avg_work_time = diff; - d_var_work_time = 0; - d_total_work_time = diff; - d_ins_nproduced = nproduced; - d_avg_nproduced = nproduced; - d_var_nproduced = 0; - d_ins_noutput_items = noutput_items; - d_avg_noutput_items = noutput_items; - d_var_noutput_items = 0; - d_total_noutput_items = noutput_items; - d_pc_start_time = (float)gr::high_res_timer_now(); - for(size_t i=0; i < d_input.size(); i++) { - buffer_reader_sptr in_buf = d_input[i]; - gr::thread::scoped_lock guard(*in_buf->mutex()); - float pfull = static_cast<float>(in_buf->items_available()) / - static_cast<float>(in_buf->max_possible_items_available()); - d_ins_input_buffers_full[i] = pfull; - d_avg_input_buffers_full[i] = pfull; - d_var_input_buffers_full[i] = 0; - } - for(size_t i=0; i < d_output.size(); i++) { - buffer_sptr out_buf = d_output[i]; - gr::thread::scoped_lock guard(*out_buf->mutex()); - float pfull = 1.0f - static_cast<float>(out_buf->space_available()) / - static_cast<float>(out_buf->bufsize()); - d_ins_output_buffers_full[i] = pfull; - d_avg_output_buffers_full[i] = pfull; - d_var_output_buffers_full[i] = 0; - } - } - else { - float d = diff - d_avg_work_time; - d_ins_work_time = diff; - d_avg_work_time = d_avg_work_time + d/d_pc_counter; - d_var_work_time = d_var_work_time + d*d; - d_total_work_time += diff; - - d = nproduced - d_avg_nproduced; - d_ins_nproduced = nproduced; - d_avg_nproduced = d_avg_nproduced + d/d_pc_counter; - d_var_nproduced = d_var_nproduced + d*d; - - d = noutput_items - d_avg_noutput_items; - d_ins_noutput_items = noutput_items; - d_avg_noutput_items = d_avg_noutput_items + d/d_pc_counter; - d_var_noutput_items = d_var_noutput_items + d*d; - d_total_noutput_items += noutput_items; - d_pc_last_work_time = gr::high_res_timer_now(); - float monitor_time = (float)(d_pc_last_work_time - d_pc_start_time) / (float)gr::high_res_timer_tps(); - d_avg_throughput = d_total_noutput_items / monitor_time; - - for(size_t i=0; i < d_input.size(); i++) { - buffer_reader_sptr in_buf = d_input[i]; - gr::thread::scoped_lock guard(*in_buf->mutex()); - float pfull = static_cast<float>(in_buf->items_available()) / - static_cast<float>(in_buf->max_possible_items_available()); - - d = pfull - d_avg_input_buffers_full[i]; - d_ins_input_buffers_full[i] = pfull; - d_avg_input_buffers_full[i] = d_avg_input_buffers_full[i] + d/d_pc_counter; - d_var_input_buffers_full[i] = d_var_input_buffers_full[i] + d*d; - } - - for(size_t i=0; i < d_output.size(); i++) { - buffer_sptr out_buf = d_output[i]; - gr::thread::scoped_lock guard(*out_buf->mutex()); - float pfull = 1.0f - static_cast<float>(out_buf->space_available()) / - static_cast<float>(out_buf->bufsize()); - - d = pfull - d_avg_output_buffers_full[i]; - d_ins_output_buffers_full[i] = pfull; - d_avg_output_buffers_full[i] = d_avg_output_buffers_full[i] + d/d_pc_counter; - d_var_output_buffers_full[i] = d_var_output_buffers_full[i] + d*d; - } + if (d_pc_counter == 0) { + d_ins_work_time = diff; + d_avg_work_time = diff; + d_var_work_time = 0; + d_total_work_time = diff; + d_ins_nproduced = nproduced; + d_avg_nproduced = nproduced; + d_var_nproduced = 0; + d_ins_noutput_items = noutput_items; + d_avg_noutput_items = noutput_items; + d_var_noutput_items = 0; + d_total_noutput_items = noutput_items; + d_pc_start_time = (float)gr::high_res_timer_now(); + for (size_t i = 0; i < d_input.size(); i++) { + buffer_reader_sptr in_buf = d_input[i]; + gr::thread::scoped_lock guard(*in_buf->mutex()); + float pfull = static_cast<float>(in_buf->items_available()) / + static_cast<float>(in_buf->max_possible_items_available()); + d_ins_input_buffers_full[i] = pfull; + d_avg_input_buffers_full[i] = pfull; + d_var_input_buffers_full[i] = 0; + } + for (size_t i = 0; i < d_output.size(); i++) { + buffer_sptr out_buf = d_output[i]; + gr::thread::scoped_lock guard(*out_buf->mutex()); + float pfull = 1.0f - static_cast<float>(out_buf->space_available()) / + static_cast<float>(out_buf->bufsize()); + d_ins_output_buffers_full[i] = pfull; + d_avg_output_buffers_full[i] = pfull; + d_var_output_buffers_full[i] = 0; + } + } else { + float d = diff - d_avg_work_time; + d_ins_work_time = diff; + d_avg_work_time = d_avg_work_time + d / d_pc_counter; + d_var_work_time = d_var_work_time + d * d; + d_total_work_time += diff; + + d = nproduced - d_avg_nproduced; + d_ins_nproduced = nproduced; + d_avg_nproduced = d_avg_nproduced + d / d_pc_counter; + d_var_nproduced = d_var_nproduced + d * d; + + d = noutput_items - d_avg_noutput_items; + d_ins_noutput_items = noutput_items; + d_avg_noutput_items = d_avg_noutput_items + d / d_pc_counter; + d_var_noutput_items = d_var_noutput_items + d * d; + d_total_noutput_items += noutput_items; + d_pc_last_work_time = gr::high_res_timer_now(); + float monitor_time = (float)(d_pc_last_work_time - d_pc_start_time) / + (float)gr::high_res_timer_tps(); + d_avg_throughput = d_total_noutput_items / monitor_time; + + for (size_t i = 0; i < d_input.size(); i++) { + buffer_reader_sptr in_buf = d_input[i]; + gr::thread::scoped_lock guard(*in_buf->mutex()); + float pfull = static_cast<float>(in_buf->items_available()) / + static_cast<float>(in_buf->max_possible_items_available()); + + d = pfull - d_avg_input_buffers_full[i]; + d_ins_input_buffers_full[i] = pfull; + d_avg_input_buffers_full[i] = d_avg_input_buffers_full[i] + d / d_pc_counter; + d_var_input_buffers_full[i] = d_var_input_buffers_full[i] + d * d; + } + + for (size_t i = 0; i < d_output.size(); i++) { + buffer_sptr out_buf = d_output[i]; + gr::thread::scoped_lock guard(*out_buf->mutex()); + float pfull = 1.0f - static_cast<float>(out_buf->space_available()) / + static_cast<float>(out_buf->bufsize()); + + d = pfull - d_avg_output_buffers_full[i]; + d_ins_output_buffers_full[i] = pfull; + d_avg_output_buffers_full[i] = + d_avg_output_buffers_full[i] + d / d_pc_counter; + d_var_output_buffers_full[i] = d_var_output_buffers_full[i] + d * d; + } } d_pc_counter++; - } - - void - block_detail::reset_perf_counters() - { - d_pc_counter = 0; - } - - float - block_detail::pc_noutput_items() - { - return d_ins_noutput_items; - } - - float - block_detail::pc_nproduced() - { - return d_ins_nproduced; - } - - float - block_detail::pc_input_buffers_full(size_t which) - { - if(which < d_ins_input_buffers_full.size()) - return d_ins_input_buffers_full[which]; +} + +void block_detail::reset_perf_counters() { d_pc_counter = 0; } + +float block_detail::pc_noutput_items() { return d_ins_noutput_items; } + +float block_detail::pc_nproduced() { return d_ins_nproduced; } + +float block_detail::pc_input_buffers_full(size_t which) +{ + if (which < d_ins_input_buffers_full.size()) + return d_ins_input_buffers_full[which]; else - return 0; - } + return 0; +} - std::vector<float> - block_detail::pc_input_buffers_full() - { +std::vector<float> block_detail::pc_input_buffers_full() +{ return d_ins_input_buffers_full; - } +} - float - block_detail::pc_output_buffers_full(size_t which) - { - if(which < d_ins_output_buffers_full.size()) - return d_ins_output_buffers_full[which]; +float block_detail::pc_output_buffers_full(size_t which) +{ + if (which < d_ins_output_buffers_full.size()) + return d_ins_output_buffers_full[which]; else - return 0; - } + return 0; +} - std::vector<float> - block_detail::pc_output_buffers_full() - { +std::vector<float> block_detail::pc_output_buffers_full() +{ return d_ins_output_buffers_full; - } - - float - block_detail::pc_work_time() - { - return d_ins_work_time; - } - - float - block_detail::pc_noutput_items_avg() - { - return d_avg_noutput_items; - } - - float - block_detail::pc_nproduced_avg() - { - return d_avg_nproduced; - } - - float - block_detail::pc_input_buffers_full_avg(size_t which) - { - if(which < d_avg_input_buffers_full.size()) - return d_avg_input_buffers_full[which]; +} + +float block_detail::pc_work_time() { return d_ins_work_time; } + +float block_detail::pc_noutput_items_avg() { return d_avg_noutput_items; } + +float block_detail::pc_nproduced_avg() { return d_avg_nproduced; } + +float block_detail::pc_input_buffers_full_avg(size_t which) +{ + if (which < d_avg_input_buffers_full.size()) + return d_avg_input_buffers_full[which]; else - return 0; - } + return 0; +} - std::vector<float> - block_detail::pc_input_buffers_full_avg() - { +std::vector<float> block_detail::pc_input_buffers_full_avg() +{ return d_avg_input_buffers_full; - } +} - float - block_detail::pc_output_buffers_full_avg(size_t which) - { - if(which < d_avg_output_buffers_full.size()) - return d_avg_output_buffers_full[which]; +float block_detail::pc_output_buffers_full_avg(size_t which) +{ + if (which < d_avg_output_buffers_full.size()) + return d_avg_output_buffers_full[which]; else - return 0; - } + return 0; +} - std::vector<float> - block_detail::pc_output_buffers_full_avg() - { +std::vector<float> block_detail::pc_output_buffers_full_avg() +{ return d_avg_output_buffers_full; - } - - float - block_detail::pc_work_time_avg() - { - return d_avg_work_time; - } - - float - block_detail::pc_noutput_items_var() - { - return d_var_noutput_items/(d_pc_counter-1); - } - - float - block_detail::pc_nproduced_var() - { - return d_var_nproduced/(d_pc_counter-1); - } - - float - block_detail::pc_input_buffers_full_var(size_t which) - { - if(which < d_avg_input_buffers_full.size()) - return d_var_input_buffers_full[which]/(d_pc_counter-1); +} + +float block_detail::pc_work_time_avg() { return d_avg_work_time; } + +float block_detail::pc_noutput_items_var() +{ + return d_var_noutput_items / (d_pc_counter - 1); +} + +float block_detail::pc_nproduced_var() { return d_var_nproduced / (d_pc_counter - 1); } + +float block_detail::pc_input_buffers_full_var(size_t which) +{ + if (which < d_avg_input_buffers_full.size()) + return d_var_input_buffers_full[which] / (d_pc_counter - 1); else - return 0; - } + return 0; +} - std::vector<float> - block_detail::pc_input_buffers_full_var() - { +std::vector<float> block_detail::pc_input_buffers_full_var() +{ std::vector<float> var(d_avg_input_buffers_full.size(), 0); - for(size_t i = 0; i < d_avg_input_buffers_full.size(); i++) - var[i] = d_avg_input_buffers_full[i]/(d_pc_counter-1); + for (size_t i = 0; i < d_avg_input_buffers_full.size(); i++) + var[i] = d_avg_input_buffers_full[i] / (d_pc_counter - 1); return var; - } +} - float - block_detail::pc_output_buffers_full_var(size_t which) - { - if(which < d_avg_output_buffers_full.size()) - return d_var_output_buffers_full[which]/(d_pc_counter-1); +float block_detail::pc_output_buffers_full_var(size_t which) +{ + if (which < d_avg_output_buffers_full.size()) + return d_var_output_buffers_full[which] / (d_pc_counter - 1); else - return 0; - } + return 0; +} - std::vector<float> - block_detail::pc_output_buffers_full_var() - { +std::vector<float> block_detail::pc_output_buffers_full_var() +{ std::vector<float> var(d_avg_output_buffers_full.size(), 0); - for(size_t i = 0; i < d_avg_output_buffers_full.size(); i++) - var[i] = d_avg_output_buffers_full[i]/(d_pc_counter-1); + for (size_t i = 0; i < d_avg_output_buffers_full.size(); i++) + var[i] = d_avg_output_buffers_full[i] / (d_pc_counter - 1); return var; - } - - float - block_detail::pc_work_time_var() - { - return d_var_work_time/(d_pc_counter-1); - } - - float - block_detail::pc_work_time_total() - { - return d_total_work_time; - } - - float - block_detail::pc_throughput_avg() { - return d_avg_throughput; - } +} + +float block_detail::pc_work_time_var() { return d_var_work_time / (d_pc_counter - 1); } + +float block_detail::pc_work_time_total() { return d_total_work_time; } + +float block_detail::pc_throughput_avg() { return d_avg_throughput; } } /* namespace gr */ diff --git a/gnuradio-runtime/lib/block_executor.cc b/gnuradio-runtime/lib/block_executor.cc index 40521e10b5..9f0d7ded5e 100644 --- a/gnuradio-runtime/lib/block_executor.cc +++ b/gnuradio-runtime/lib/block_executor.cc @@ -42,529 +42,543 @@ namespace gr { #define ENABLE_LOGGING 0 #if (ENABLE_LOGGING) -#define LOG(x) do { x; } while(0) +#define LOG(x) \ + do { \ + x; \ + } while (0) #else -#define LOG(x) do {;} while(0) +#define LOG(x) \ + do { \ + ; \ + } while (0) #endif - static int which_scheduler = 0; +static int which_scheduler = 0; - inline static unsigned int - round_up(unsigned int n, unsigned int multiple) - { +inline static unsigned int round_up(unsigned int n, unsigned int multiple) +{ return ((n + multiple - 1) / multiple) * multiple; - } +} - inline static unsigned int - round_down(unsigned int n, unsigned int multiple) - { +inline static unsigned int round_down(unsigned int n, unsigned int multiple) +{ return (n / multiple) * multiple; - } - - // - // Return minimum available write space in all our downstream - // buffers or -1 if we're output blocked and the output we're - // blocked on is done. - // - static int - min_available_space(block_detail *d, int output_multiple, int min_noutput_items) - { +} + +// +// Return minimum available write space in all our downstream +// buffers or -1 if we're output blocked and the output we're +// blocked on is done. +// +static int +min_available_space(block_detail* d, int output_multiple, int min_noutput_items) +{ int min_space = std::numeric_limits<int>::max(); - if(min_noutput_items == 0) - min_noutput_items = 1; - for(int i = 0; i < d->noutputs (); i++) { - buffer_sptr out_buf = d->output(i); - gr::thread::scoped_lock guard(*out_buf->mutex()); - int avail_n = round_down(out_buf->space_available(), output_multiple); - int best_n = round_down(out_buf->bufsize()/2, output_multiple); - if(best_n < min_noutput_items) - throw std::runtime_error("Buffer too small for min_noutput_items"); - int n = std::min(avail_n, best_n); - if(n < min_noutput_items){ // We're blocked on output. - if(out_buf->done()){ // Downstream is done, therefore we're done. - return -1; + if (min_noutput_items == 0) + min_noutput_items = 1; + for (int i = 0; i < d->noutputs(); i++) { + buffer_sptr out_buf = d->output(i); + gr::thread::scoped_lock guard(*out_buf->mutex()); + int avail_n = round_down(out_buf->space_available(), output_multiple); + int best_n = round_down(out_buf->bufsize() / 2, output_multiple); + if (best_n < min_noutput_items) + throw std::runtime_error("Buffer too small for min_noutput_items"); + int n = std::min(avail_n, best_n); + if (n < min_noutput_items) { // We're blocked on output. + if (out_buf->done()) { // Downstream is done, therefore we're done. + return -1; + } + return 0; } - return 0; - } - min_space = std::min(min_space, n); + min_space = std::min(min_space, n); } return min_space; - } - - static bool - propagate_tags(block::tag_propagation_policy_t policy, block_detail *d, - const std::vector<uint64_t> &start_nitems_read, double rrate, - mpq_class &mp_rrate, bool use_fp_rrate, - std::vector<tag_t> &rtags, long block_id) - { +} + +static bool propagate_tags(block::tag_propagation_policy_t policy, + block_detail* d, + const std::vector<uint64_t>& start_nitems_read, + double rrate, + mpq_class& mp_rrate, + bool use_fp_rrate, + std::vector<tag_t>& rtags, + long block_id) +{ static const mpq_class one_half(1, 2); // Move tags downstream // if a sink, we don't need to move downstream - if(d->sink_p()) { - return true; + if (d->sink_p()) { + return true; } - switch(policy) { + switch (policy) { case block::TPP_DONT: case block::TPP_CUSTOM: - return true; - case block::TPP_ALL_TO_ALL: - { - // every tag on every input propagates to everyone downstream - std::vector<buffer_sptr> out_buf; - - for(int i = 0; i < d->ninputs(); i++) { - d->get_tags_in_range(rtags, i, start_nitems_read[i], - d->nitems_read(i), block_id); - - if (rtags.size() == 0) - continue; - - if (out_buf.size() == 0) { - out_buf.reserve(d->noutputs()); - for(int o = 0; o < d->noutputs(); o++) - out_buf.push_back(d->output(o)); - } + return true; + case block::TPP_ALL_TO_ALL: { + // every tag on every input propagates to everyone downstream + std::vector<buffer_sptr> out_buf; + + for (int i = 0; i < d->ninputs(); i++) { + d->get_tags_in_range( + rtags, i, start_nitems_read[i], d->nitems_read(i), block_id); + + if (rtags.size() == 0) + continue; + + if (out_buf.size() == 0) { + out_buf.reserve(d->noutputs()); + for (int o = 0; o < d->noutputs(); o++) + out_buf.push_back(d->output(o)); + } - std::vector<tag_t>::iterator t; - if(rrate == 1.0) { - for(t = rtags.begin(); t != rtags.end(); t++) { - for(int o = 0; o < d->noutputs(); o++) - out_buf[o]->add_item_tag(*t); - } - } - else if(use_fp_rrate) { - for(t = rtags.begin(); t != rtags.end(); t++) { - tag_t new_tag = *t; - new_tag.offset = ((double)new_tag.offset * rrate) + 0.5; - for(int o = 0; o < d->noutputs(); o++) - out_buf[o]->add_item_tag(new_tag); - } - } - else { - mpz_class offset; - for(t = rtags.begin(); t != rtags.end(); t++) { - tag_t new_tag = *t; - mpz_import(offset.get_mpz_t(), 1, 1, sizeof(new_tag.offset), 0, 0, &new_tag.offset); - offset = offset * mp_rrate + one_half; - new_tag.offset = offset.get_ui(); - for(int o = 0; o < d->noutputs(); o++) - out_buf[o]->add_item_tag(new_tag); - } + std::vector<tag_t>::iterator t; + if (rrate == 1.0) { + for (t = rtags.begin(); t != rtags.end(); t++) { + for (int o = 0; o < d->noutputs(); o++) + out_buf[o]->add_item_tag(*t); + } + } else if (use_fp_rrate) { + for (t = rtags.begin(); t != rtags.end(); t++) { + tag_t new_tag = *t; + new_tag.offset = ((double)new_tag.offset * rrate) + 0.5; + for (int o = 0; o < d->noutputs(); o++) + out_buf[o]->add_item_tag(new_tag); + } + } else { + mpz_class offset; + for (t = rtags.begin(); t != rtags.end(); t++) { + tag_t new_tag = *t; + mpz_import(offset.get_mpz_t(), + 1, + 1, + sizeof(new_tag.offset), + 0, + 0, + &new_tag.offset); + offset = offset * mp_rrate + one_half; + new_tag.offset = offset.get_ui(); + for (int o = 0; o < d->noutputs(); o++) + out_buf[o]->add_item_tag(new_tag); + } + } } - } - } - break; + } break; case block::TPP_ONE_TO_ONE: - // tags from input i only go to output i - // this requires d->ninputs() == d->noutputs; this is checked when this - // type of tag-propagation system is selected in block_detail - if(d->ninputs() == d->noutputs()) { - buffer_sptr out_buf; - - for(int i = 0; i < d->ninputs(); i++) { - d->get_tags_in_range(rtags, i, start_nitems_read[i], - d->nitems_read(i), block_id); - - if (rtags.size() == 0) - continue; - - out_buf = d->output(i); - - std::vector<tag_t>::iterator t; - if(rrate == 1.0) { - for(t = rtags.begin(); t != rtags.end(); t++) { - out_buf->add_item_tag(*t); - } - } - else if(use_fp_rrate) { - for(t = rtags.begin(); t != rtags.end(); t++) { - tag_t new_tag = *t; - new_tag.offset = ((double)new_tag.offset * rrate) + 0.5; - out_buf->add_item_tag(new_tag); + // tags from input i only go to output i + // this requires d->ninputs() == d->noutputs; this is checked when this + // type of tag-propagation system is selected in block_detail + if (d->ninputs() == d->noutputs()) { + buffer_sptr out_buf; + + for (int i = 0; i < d->ninputs(); i++) { + d->get_tags_in_range( + rtags, i, start_nitems_read[i], d->nitems_read(i), block_id); + + if (rtags.size() == 0) + continue; + + out_buf = d->output(i); + + std::vector<tag_t>::iterator t; + if (rrate == 1.0) { + for (t = rtags.begin(); t != rtags.end(); t++) { + out_buf->add_item_tag(*t); + } + } else if (use_fp_rrate) { + for (t = rtags.begin(); t != rtags.end(); t++) { + tag_t new_tag = *t; + new_tag.offset = ((double)new_tag.offset * rrate) + 0.5; + out_buf->add_item_tag(new_tag); + } + } else { + mpz_class offset; + for (t = rtags.begin(); t != rtags.end(); t++) { + tag_t new_tag = *t; + mpz_import(offset.get_mpz_t(), + 1, + 1, + sizeof(new_tag.offset), + 0, + 0, + &new_tag.offset); + offset = offset * mp_rrate + one_half; + new_tag.offset = offset.get_ui(); + out_buf->add_item_tag(new_tag); + } + } } - } - else { - mpz_class offset; - for(t = rtags.begin(); t != rtags.end(); t++) { - tag_t new_tag = *t; - mpz_import(offset.get_mpz_t(), 1, 1, sizeof(new_tag.offset), 0, 0, &new_tag.offset); - offset = offset * mp_rrate + one_half; - new_tag.offset = offset.get_ui(); - out_buf->add_item_tag(new_tag); - } - } + } else { + std::cerr << "Error: block_executor: propagation_policy 'ONE-TO-ONE' " + "requires ninputs == noutputs" + << std::endl; + return false; } - } - else { - std::cerr << "Error: block_executor: propagation_policy 'ONE-TO-ONE' requires ninputs == noutputs" << std::endl; - return false; - } - break; + break; default: - return true; + return true; } return true; - } +} - block_executor::block_executor(block_sptr block, int max_noutput_items) +block_executor::block_executor(block_sptr block, int max_noutput_items) : d_block(block), d_log(0), d_max_noutput_items(max_noutput_items) - { - if(ENABLE_LOGGING) { - std::string name = str(boost::format("sst-%03d.log") % which_scheduler++); - d_log = new std::ofstream(name.c_str()); - std::unitbuf(*d_log); // make it unbuffered... - *d_log << "block_executor: " - << d_block << std::endl; +{ + if (ENABLE_LOGGING) { + std::string name = str(boost::format("sst-%03d.log") % which_scheduler++); + d_log = new std::ofstream(name.c_str()); + std::unitbuf(*d_log); // make it unbuffered... + *d_log << "block_executor: " << d_block << std::endl; } #ifdef GR_PERFORMANCE_COUNTERS - prefs *prefs = prefs::singleton(); + prefs* prefs = prefs::singleton(); d_use_pc = prefs->get_bool("PerfCounters", "on", false); #endif /* GR_PERFORMANCE_COUNTERS */ - d_block->start(); // enable any drivers, etc. - } + d_block->start(); // enable any drivers, etc. +} - block_executor::~block_executor() - { - if(ENABLE_LOGGING) - delete d_log; +block_executor::~block_executor() +{ + if (ENABLE_LOGGING) + delete d_log; - d_block->stop(); // stop any drivers, etc. - } + d_block->stop(); // stop any drivers, etc. +} - block_executor::state - block_executor::run_one_iteration() - { +block_executor::state block_executor::run_one_iteration() +{ int noutput_items; int max_items_avail; int max_noutput_items; int new_alignment = 0; int alignment_state = -1; - block *m = d_block.get(); - block_detail *d = m->detail().get(); + block* m = d_block.get(); + block_detail* d = m->detail().get(); LOG(*d_log << std::endl << m); max_noutput_items = round_down(d_max_noutput_items, m->output_multiple()); - if(d->done()){ - assert(0); - return DONE; + if (d->done()) { + assert(0); + return DONE; } - if(d->source_p ()) { - d_ninput_items_required.resize(0); - d_ninput_items.resize(0); - d_input_items.resize(0); - d_input_done.resize(0); - d_output_items.resize(d->noutputs()); - d_start_nitems_read.resize(0); - - // determine the minimum available output space - noutput_items = min_available_space(d, m->output_multiple (), m->min_noutput_items ()); - noutput_items = std::min(noutput_items, max_noutput_items); - LOG(*d_log << " source\n noutput_items = " << noutput_items << std::endl); - if(noutput_items == -1) // we're done - goto were_done; - - if(noutput_items == 0){ // we're output blocked - LOG(*d_log << " BLKD_OUT\n"); - return BLKD_OUT; - } - - goto setup_call_to_work; // jump to common code + if (d->source_p()) { + d_ninput_items_required.resize(0); + d_ninput_items.resize(0); + d_input_items.resize(0); + d_input_done.resize(0); + d_output_items.resize(d->noutputs()); + d_start_nitems_read.resize(0); + + // determine the minimum available output space + noutput_items = + min_available_space(d, m->output_multiple(), m->min_noutput_items()); + noutput_items = std::min(noutput_items, max_noutput_items); + LOG(*d_log << " source\n noutput_items = " << noutput_items << std::endl); + if (noutput_items == -1) // we're done + goto were_done; + + if (noutput_items == 0) { // we're output blocked + LOG(*d_log << " BLKD_OUT\n"); + return BLKD_OUT; + } + + goto setup_call_to_work; // jump to common code } - else if(d->sink_p ()) { - d_ninput_items_required.resize(d->ninputs ()); - d_ninput_items.resize(d->ninputs ()); - d_input_items.resize(d->ninputs ()); - d_input_done.resize(d->ninputs()); - d_output_items.resize (0); - d_start_nitems_read.resize(d->ninputs()); - LOG(*d_log << " sink\n"); - - max_items_avail = 0; - for(int i = 0; i < d->ninputs (); i++) { - { - /* - * Acquire the mutex and grab local copies of items_available and done. - */ - buffer_reader_sptr in_buf = d->input(i); - gr::thread::scoped_lock guard(*in_buf->mutex()); - d_ninput_items[i] = in_buf->items_available(); - d_input_done[i] = in_buf->done(); - } + else if (d->sink_p()) { + d_ninput_items_required.resize(d->ninputs()); + d_ninput_items.resize(d->ninputs()); + d_input_items.resize(d->ninputs()); + d_input_done.resize(d->ninputs()); + d_output_items.resize(0); + d_start_nitems_read.resize(d->ninputs()); + LOG(*d_log << " sink\n"); + + max_items_avail = 0; + for (int i = 0; i < d->ninputs(); i++) { + { + /* + * Acquire the mutex and grab local copies of items_available and done. + */ + buffer_reader_sptr in_buf = d->input(i); + gr::thread::scoped_lock guard(*in_buf->mutex()); + d_ninput_items[i] = in_buf->items_available(); + d_input_done[i] = in_buf->done(); + } - LOG(*d_log << " d_ninput_items[" << i << "] = " << d_ninput_items[i] << std::endl); - LOG(*d_log << " d_input_done[" << i << "] = " << d_input_done[i] << std::endl); + LOG(*d_log << " d_ninput_items[" << i << "] = " << d_ninput_items[i] + << std::endl); + LOG(*d_log << " d_input_done[" << i << "] = " << d_input_done[i] + << std::endl); - if (d_ninput_items[i] < m->output_multiple() && d_input_done[i]) - goto were_done; + if (d_ninput_items[i] < m->output_multiple() && d_input_done[i]) + goto were_done; - max_items_avail = std::max (max_items_avail, d_ninput_items[i]); - } + max_items_avail = std::max(max_items_avail, d_ninput_items[i]); + } - // take a swag at how much output we can sink - noutput_items = (int)(max_items_avail * m->relative_rate ()); - noutput_items = round_down(noutput_items, m->output_multiple ()); - noutput_items = std::min(noutput_items, max_noutput_items); - LOG(*d_log << " max_items_avail = " << max_items_avail << std::endl); - LOG(*d_log << " noutput_items = " << noutput_items << std::endl); + // take a swag at how much output we can sink + noutput_items = (int)(max_items_avail * m->relative_rate()); + noutput_items = round_down(noutput_items, m->output_multiple()); + noutput_items = std::min(noutput_items, max_noutput_items); + LOG(*d_log << " max_items_avail = " << max_items_avail << std::endl); + LOG(*d_log << " noutput_items = " << noutput_items << std::endl); - if(noutput_items == 0) { // we're blocked on input - LOG(*d_log << " BLKD_IN\n"); - return BLKD_IN; - } + if (noutput_items == 0) { // we're blocked on input + LOG(*d_log << " BLKD_IN\n"); + return BLKD_IN; + } - goto try_again; // Jump to code shared with regular case. + goto try_again; // Jump to code shared with regular case. } else { - // do the regular thing - d_ninput_items_required.resize (d->ninputs ()); - d_ninput_items.resize (d->ninputs ()); - d_input_items.resize (d->ninputs ()); - d_input_done.resize(d->ninputs()); - d_output_items.resize (d->noutputs ()); - d_start_nitems_read.resize(d->ninputs()); - - max_items_avail = 0; - for(int i = 0; i < d->ninputs (); i++) { - { - /* - * Acquire the mutex and grab local copies of items_available and done. - */ - buffer_reader_sptr in_buf = d->input(i); - gr::thread::scoped_lock guard(*in_buf->mutex()); - d_ninput_items[i] = in_buf->items_available (); - d_input_done[i] = in_buf->done(); + // do the regular thing + d_ninput_items_required.resize(d->ninputs()); + d_ninput_items.resize(d->ninputs()); + d_input_items.resize(d->ninputs()); + d_input_done.resize(d->ninputs()); + d_output_items.resize(d->noutputs()); + d_start_nitems_read.resize(d->ninputs()); + + max_items_avail = 0; + for (int i = 0; i < d->ninputs(); i++) { + { + /* + * Acquire the mutex and grab local copies of items_available and done. + */ + buffer_reader_sptr in_buf = d->input(i); + gr::thread::scoped_lock guard(*in_buf->mutex()); + d_ninput_items[i] = in_buf->items_available(); + d_input_done[i] = in_buf->done(); + } + max_items_avail = std::max(max_items_avail, d_ninput_items[i]); } - max_items_avail = std::max(max_items_avail, d_ninput_items[i]); - } - - // determine the minimum available output space - noutput_items = min_available_space(d, m->output_multiple(), m->min_noutput_items()); - if(ENABLE_LOGGING) { - *d_log << " regular "; - *d_log << m->relative_rate_i() << ":" - << m->relative_rate_d() << std::endl; - *d_log << " max_items_avail = " << max_items_avail << std::endl; - *d_log << " noutput_items = " << noutput_items << std::endl; - } - if(noutput_items == -1) // we're done - goto were_done; - - if(noutput_items == 0) { // we're output blocked - LOG(*d_log << " BLKD_OUT\n"); - return BLKD_OUT; - } - try_again: - if(m->fixed_rate()) { - // try to work it forward starting with max_items_avail. - // We want to try to consume all the input we've got. - int reqd_noutput_items = m->fixed_rate_ninput_to_noutput(max_items_avail); - - // only test this if we specifically set the output_multiple - if(m->output_multiple_set()) - reqd_noutput_items = round_down(reqd_noutput_items, m->output_multiple()); - - if(reqd_noutput_items > 0 && reqd_noutput_items <= noutput_items) - noutput_items = reqd_noutput_items; - - // if we need this many outputs, overrule the max_noutput_items setting - max_noutput_items = std::max(m->output_multiple(), max_noutput_items); - } - noutput_items = std::min(noutput_items, max_noutput_items); - - // Check if we're still unaligned; use up items until we're - // aligned again. Otherwise, make sure we set the alignment - // requirement. - if(!m->output_multiple_set()) { - if(m->is_unaligned()) { - // When unaligned, don't just set noutput_items to the remaining - // samples to meet alignment; this causes too much overhead in - // requiring a premature call back here. Set the maximum amount - // of samples to handle unalignment and get us back aligned. - if(noutput_items >= m->unaligned()) { - noutput_items = round_up(noutput_items, m->alignment()) \ - - (m->alignment() - m->unaligned()); - new_alignment = 0; - } - else { - new_alignment = m->unaligned() - noutput_items; - } - alignment_state = 0; + // determine the minimum available output space + noutput_items = + min_available_space(d, m->output_multiple(), m->min_noutput_items()); + if (ENABLE_LOGGING) { + *d_log << " regular "; + *d_log << m->relative_rate_i() << ":" << m->relative_rate_d() << std::endl; + *d_log << " max_items_avail = " << max_items_avail << std::endl; + *d_log << " noutput_items = " << noutput_items << std::endl; } - else if(noutput_items < m->alignment()) { - // if we don't have enough for an aligned call, keep track of - // misalignment, set unaligned flag, and proceed. - new_alignment = m->alignment() - noutput_items; - m->set_unaligned(new_alignment); - m->set_is_unaligned(true); - alignment_state = 1; + if (noutput_items == -1) // we're done + goto were_done; + + if (noutput_items == 0) { // we're output blocked + LOG(*d_log << " BLKD_OUT\n"); + return BLKD_OUT; } - else { - // enough to round down to the nearest alignment and process. - noutput_items = round_down(noutput_items, m->alignment()); - m->set_is_unaligned(false); - alignment_state = 2; + + try_again: + if (m->fixed_rate()) { + // try to work it forward starting with max_items_avail. + // We want to try to consume all the input we've got. + int reqd_noutput_items = m->fixed_rate_ninput_to_noutput(max_items_avail); + + // only test this if we specifically set the output_multiple + if (m->output_multiple_set()) + reqd_noutput_items = round_down(reqd_noutput_items, m->output_multiple()); + + if (reqd_noutput_items > 0 && reqd_noutput_items <= noutput_items) + noutput_items = reqd_noutput_items; + + // if we need this many outputs, overrule the max_noutput_items setting + max_noutput_items = std::max(m->output_multiple(), max_noutput_items); } - } - - // ask the block how much input they need to produce noutput_items - m->forecast (noutput_items, d_ninput_items_required); - - // See if we've got sufficient input available and make sure we - // didn't overflow on the input. - int i; - for(i = 0; i < d->ninputs (); i++) { - if(d_ninput_items_required[i] > d_ninput_items[i]) // not enough - break; - - if(d_ninput_items_required[i] < 0) { - std::cerr << "\nsched: <block " << m->name() - << " (" << m->unique_id() << ")>" - << " thinks its ninput_items required is " - << d_ninput_items_required[i] - << " and cannot be negative.\n" - << "Some parameterization is wrong. " - << "Too large a decimation value?\n\n"; - goto were_done; + noutput_items = std::min(noutput_items, max_noutput_items); + + // Check if we're still unaligned; use up items until we're + // aligned again. Otherwise, make sure we set the alignment + // requirement. + if (!m->output_multiple_set()) { + if (m->is_unaligned()) { + // When unaligned, don't just set noutput_items to the remaining + // samples to meet alignment; this causes too much overhead in + // requiring a premature call back here. Set the maximum amount + // of samples to handle unalignment and get us back aligned. + if (noutput_items >= m->unaligned()) { + noutput_items = round_up(noutput_items, m->alignment()) - + (m->alignment() - m->unaligned()); + new_alignment = 0; + } else { + new_alignment = m->unaligned() - noutput_items; + } + alignment_state = 0; + } else if (noutput_items < m->alignment()) { + // if we don't have enough for an aligned call, keep track of + // misalignment, set unaligned flag, and proceed. + new_alignment = m->alignment() - noutput_items; + m->set_unaligned(new_alignment); + m->set_is_unaligned(true); + alignment_state = 1; + } else { + // enough to round down to the nearest alignment and process. + noutput_items = round_down(noutput_items, m->alignment()); + m->set_is_unaligned(false); + alignment_state = 2; + } } - } - - if(i < d->ninputs()) { // not enough input on input[i] - // if we can, try reducing the size of our output request - if(noutput_items > m->output_multiple()) { - noutput_items /= 2; - noutput_items = round_up(noutput_items, m->output_multiple()); - goto try_again; + + // ask the block how much input they need to produce noutput_items + m->forecast(noutput_items, d_ninput_items_required); + + // See if we've got sufficient input available and make sure we + // didn't overflow on the input. + int i; + for (i = 0; i < d->ninputs(); i++) { + if (d_ninput_items_required[i] > d_ninput_items[i]) // not enough + break; + + if (d_ninput_items_required[i] < 0) { + std::cerr << "\nsched: <block " << m->name() << " (" << m->unique_id() + << ")>" + << " thinks its ninput_items required is " + << d_ninput_items_required[i] << " and cannot be negative.\n" + << "Some parameterization is wrong. " + << "Too large a decimation value?\n\n"; + goto were_done; + } } - // We're blocked on input - LOG(*d_log << " BLKD_IN\n"); - if(d_input_done[i]) // If the upstream block is done, we're done - goto were_done; + if (i < d->ninputs()) { // not enough input on input[i] + // if we can, try reducing the size of our output request + if (noutput_items > m->output_multiple()) { + noutput_items /= 2; + noutput_items = round_up(noutput_items, m->output_multiple()); + goto try_again; + } - // Is it possible to ever fulfill this request? - buffer_reader_sptr in_buf = d->input(i); - if(d_ninput_items_required[i] > in_buf->max_possible_items_available()) { - // Nope, never going to happen... - std::cerr << "\nsched: <block " << m->name() - << " (" << m->unique_id() << ")>" + // We're blocked on input + LOG(*d_log << " BLKD_IN\n"); + if (d_input_done[i]) // If the upstream block is done, we're done + goto were_done; + + // Is it possible to ever fulfill this request? + buffer_reader_sptr in_buf = d->input(i); + if (d_ninput_items_required[i] > in_buf->max_possible_items_available()) { + // Nope, never going to happen... + std::cerr + << "\nsched: <block " << m->name() << " (" << m->unique_id() << ")>" << " is requesting more input data\n" << " than we can provide.\n" - << " ninput_items_required = " - << d_ninput_items_required[i] << "\n" + << " ninput_items_required = " << d_ninput_items_required[i] << "\n" << " max_possible_items_available = " << in_buf->max_possible_items_available() << "\n" << " If this is a filter, consider reducing the number of taps.\n"; - goto were_done; - } + goto were_done; + } - // If we were made unaligned in this round but return here without - // processing; reset the unalignment claim before next entry. - if(alignment_state == 1) { - m->set_unaligned(0); - m->set_is_unaligned(false); + // If we were made unaligned in this round but return here without + // processing; reset the unalignment claim before next entry. + if (alignment_state == 1) { + m->set_unaligned(0); + m->set_is_unaligned(false); + } + return BLKD_IN; } - return BLKD_IN; - } - // We've got enough data on each input to produce noutput_items. - // Finish setting up the call to work. - for(int i = 0; i < d->ninputs (); i++) - d_input_items[i] = d->input(i)->read_pointer(); + // We've got enough data on each input to produce noutput_items. + // Finish setting up the call to work. + for (int i = 0; i < d->ninputs(); i++) + d_input_items[i] = d->input(i)->read_pointer(); setup_call_to_work: - d->d_produce_or = 0; - for(int i = 0; i < d->noutputs (); i++) - d_output_items[i] = d->output(i)->write_pointer(); + d->d_produce_or = 0; + for (int i = 0; i < d->noutputs(); i++) + d_output_items[i] = d->output(i)->write_pointer(); - // determine where to start looking for new tags - for(int i = 0; i < d->ninputs(); i++) - d_start_nitems_read[i] = d->nitems_read(i); + // determine where to start looking for new tags + for (int i = 0; i < d->ninputs(); i++) + d_start_nitems_read[i] = d->nitems_read(i); #ifdef GR_PERFORMANCE_COUNTERS - if(d_use_pc) - d->start_perf_counters(); + if (d_use_pc) + d->start_perf_counters(); #endif /* GR_PERFORMANCE_COUNTERS */ - // Do the actual work of the block - int n = m->general_work(noutput_items, d_ninput_items, - d_input_items, d_output_items); + // Do the actual work of the block + int n = + m->general_work(noutput_items, d_ninput_items, d_input_items, d_output_items); #ifdef GR_PERFORMANCE_COUNTERS - if(d_use_pc) - d->stop_perf_counters(noutput_items, n); + if (d_use_pc) + d->stop_perf_counters(noutput_items, n); #endif /* GR_PERFORMANCE_COUNTERS */ - LOG(*d_log << " general_work: noutput_items = " << noutput_items - << " result = " << n << std::endl); - - // Adjust number of unaligned items left to process - if(m->is_unaligned()) { - m->set_unaligned(new_alignment); - m->set_is_unaligned(m->unaligned() != 0); - } - - // Now propagate the tags based on the new relative rate - if(!propagate_tags(m->tag_propagation_policy(), d, - d_start_nitems_read, m->relative_rate(), - m->mp_relative_rate(), m->update_rate(), - d_returned_tags, m->unique_id())) - goto were_done; - - if(n == block::WORK_DONE) - goto were_done; - - if(n != block::WORK_CALLED_PRODUCE) - d->produce_each(n); // advance write pointers - - // For some blocks that can change their produce/consume ratio - // (the relative_rate), we might want to automatically update - // based on the amount of items written/read. - // In the block constructor, use enable_update_rate(true). - if(m->update_rate()) { - //rrate = ((double)(m->nitems_written(0))) / ((double)m->nitems_read(0)); - //if(rrate > 0.0) - // m->set_relative_rate(rrate); - if((n > 0) && (d->consumed() > 0)) - m->set_relative_rate((uint64_t)n, (uint64_t)d->consumed()); - } - - if(d->d_produce_or > 0) // block produced something - return READY; - - // We didn't produce any output even though we called general_work. - // We have (most likely) consumed some input. - - /* - // If this is a source, it's broken. - if(d->source_p()) { - std::cerr << "block_executor: source " << m - << " produced no output. We're marking it DONE.\n"; - // FIXME maybe we ought to raise an exception... - goto were_done; - } - */ - - // Have the caller try again... - return READY_NO_OUTPUT; + LOG(*d_log << " general_work: noutput_items = " << noutput_items + << " result = " << n << std::endl); + + // Adjust number of unaligned items left to process + if (m->is_unaligned()) { + m->set_unaligned(new_alignment); + m->set_is_unaligned(m->unaligned() != 0); + } + + // Now propagate the tags based on the new relative rate + if (!propagate_tags(m->tag_propagation_policy(), + d, + d_start_nitems_read, + m->relative_rate(), + m->mp_relative_rate(), + m->update_rate(), + d_returned_tags, + m->unique_id())) + goto were_done; + + if (n == block::WORK_DONE) + goto were_done; + + if (n != block::WORK_CALLED_PRODUCE) + d->produce_each(n); // advance write pointers + + // For some blocks that can change their produce/consume ratio + // (the relative_rate), we might want to automatically update + // based on the amount of items written/read. + // In the block constructor, use enable_update_rate(true). + if (m->update_rate()) { + // rrate = ((double)(m->nitems_written(0))) / ((double)m->nitems_read(0)); + // if(rrate > 0.0) + // m->set_relative_rate(rrate); + if ((n > 0) && (d->consumed() > 0)) + m->set_relative_rate((uint64_t)n, (uint64_t)d->consumed()); + } + + if (d->d_produce_or > 0) // block produced something + return READY; + + // We didn't produce any output even though we called general_work. + // We have (most likely) consumed some input. + + /* + // If this is a source, it's broken. + if(d->source_p()) { + std::cerr << "block_executor: source " << m + << " produced no output. We're marking it DONE.\n"; + // FIXME maybe we ought to raise an exception... + goto were_done; + } + */ + + // Have the caller try again... + return READY_NO_OUTPUT; } assert(0); - were_done: +were_done: LOG(*d_log << " were_done\n"); - d->set_done (true); + d->set_done(true); return DONE; - } +} } /* namespace gr */ diff --git a/gnuradio-runtime/lib/block_executor.h b/gnuradio-runtime/lib/block_executor.h index 4e1d2f1602..0214bf90aa 100644 --- a/gnuradio-runtime/lib/block_executor.h +++ b/gnuradio-runtime/lib/block_executor.h @@ -30,48 +30,48 @@ namespace gr { - /*! - * \brief Manage the execution of a single block. - * \ingroup internal - */ - class GR_RUNTIME_API block_executor - { - protected: - block_sptr d_block; // The block we're trying to run - std::ofstream *d_log; +/*! + * \brief Manage the execution of a single block. + * \ingroup internal + */ +class GR_RUNTIME_API block_executor +{ +protected: + block_sptr d_block; // The block we're trying to run + std::ofstream* d_log; // These are allocated here so we don't have to on each iteration - gr_vector_int d_ninput_items_required; - gr_vector_int d_ninput_items; - gr_vector_const_void_star d_input_items; - std::vector<bool> d_input_done; - gr_vector_void_star d_output_items; - std::vector<uint64_t> d_start_nitems_read; //stores where tag counts are before work - std::vector<tag_t> d_returned_tags; - int d_max_noutput_items; + gr_vector_int d_ninput_items_required; + gr_vector_int d_ninput_items; + gr_vector_const_void_star d_input_items; + std::vector<bool> d_input_done; + gr_vector_void_star d_output_items; + std::vector<uint64_t> d_start_nitems_read; // stores where tag counts are before work + std::vector<tag_t> d_returned_tags; + int d_max_noutput_items; #ifdef GR_PERFORMANCE_COUNTERS bool d_use_pc; #endif /* GR_PERFORMANCE_COUNTERS */ - public: - block_executor(block_sptr block, int max_noutput_items=100000); +public: + block_executor(block_sptr block, int max_noutput_items = 100000); ~block_executor(); enum state { - READY, // We made progress; everything's cool. - READY_NO_OUTPUT, // We consumed some input, but produced no output. - BLKD_IN, // no progress; we're blocked waiting for input data. - BLKD_OUT, // no progress; we're blocked waiting for output buffer space. - DONE, // we're done; don't call me again. + READY, // We made progress; everything's cool. + READY_NO_OUTPUT, // We consumed some input, but produced no output. + BLKD_IN, // no progress; we're blocked waiting for input data. + BLKD_OUT, // no progress; we're blocked waiting for output buffer space. + DONE, // we're done; don't call me again. }; /* * \brief Run one iteration. */ state run_one_iteration(); - }; +}; } /* namespace gr */ diff --git a/gnuradio-runtime/lib/block_gateway_impl.cc b/gnuradio-runtime/lib/block_gateway_impl.cc index 535e4f74ca..67f9990c4a 100644 --- a/gnuradio-runtime/lib/block_gateway_impl.cc +++ b/gnuradio-runtime/lib/block_gateway_impl.cc @@ -26,161 +26,144 @@ namespace gr { - /*********************************************************************** - * Helper routines - **********************************************************************/ - template <typename OutType, typename InType> - void - copy_pointers(OutType &out, const InType &in) - { +/*********************************************************************** + * Helper routines + **********************************************************************/ +template <typename OutType, typename InType> +void copy_pointers(OutType& out, const InType& in) +{ out.resize(in.size()); - for(size_t i = 0; i < in.size(); i++) { - out[i] = (void *)(in[i]); + for (size_t i = 0; i < in.size(); i++) { + out[i] = (void*)(in[i]); } - } - - - block_gateway::sptr - block_gateway::make(feval_ll *handler, - const std::string &name, - gr::io_signature::sptr in_sig, - gr::io_signature::sptr out_sig, - const block_gw_work_type work_type, - const unsigned factor) - { - return block_gateway::sptr - (new block_gateway_impl(handler, name, in_sig, out_sig, - work_type, factor)); - } - - block_gateway_impl::block_gateway_impl(feval_ll *handler, - const std::string &name, - gr::io_signature::sptr in_sig, - gr::io_signature::sptr out_sig, - const block_gw_work_type work_type, - const unsigned factor) - : block(name, in_sig, out_sig), - _handler(handler), - _work_type(work_type) - { - switch(_work_type) { +} + + +block_gateway::sptr block_gateway::make(feval_ll* handler, + const std::string& name, + gr::io_signature::sptr in_sig, + gr::io_signature::sptr out_sig, + const block_gw_work_type work_type, + const unsigned factor) +{ + return block_gateway::sptr( + new block_gateway_impl(handler, name, in_sig, out_sig, work_type, factor)); +} + +block_gateway_impl::block_gateway_impl(feval_ll* handler, + const std::string& name, + gr::io_signature::sptr in_sig, + gr::io_signature::sptr out_sig, + const block_gw_work_type work_type, + const unsigned factor) + : block(name, in_sig, out_sig), _handler(handler), _work_type(work_type) +{ + switch (_work_type) { case GR_BLOCK_GW_WORK_GENERAL: - _decim = 1; //not relevant, but set anyway - _interp = 1; //not relevant, but set anyway - break; + _decim = 1; // not relevant, but set anyway + _interp = 1; // not relevant, but set anyway + break; case GR_BLOCK_GW_WORK_SYNC: - _decim = 1; - _interp = 1; - this->set_fixed_rate(true); - break; + _decim = 1; + _interp = 1; + this->set_fixed_rate(true); + break; case GR_BLOCK_GW_WORK_DECIM: - _decim = factor; - _interp = 1; - break; + _decim = factor; + _interp = 1; + break; case GR_BLOCK_GW_WORK_INTERP: - _decim = 1; - _interp = factor; - this->set_output_multiple(_interp); - break; + _decim = 1; + _interp = factor; + this->set_output_multiple(_interp); + break; } - } +} - void - block_gateway_impl::forecast(int noutput_items, - gr_vector_int &ninput_items_required) - { - switch(_work_type) { +void block_gateway_impl::forecast(int noutput_items, gr_vector_int& ninput_items_required) +{ + switch (_work_type) { case GR_BLOCK_GW_WORK_GENERAL: - _message.action = block_gw_message_type::ACTION_FORECAST; - _message.forecast_args_noutput_items = noutput_items; - _message.forecast_args_ninput_items_required = ninput_items_required; - _handler->calleval(0); - ninput_items_required = _message.forecast_args_ninput_items_required; - return; + _message.action = block_gw_message_type::ACTION_FORECAST; + _message.forecast_args_noutput_items = noutput_items; + _message.forecast_args_ninput_items_required = ninput_items_required; + _handler->calleval(0); + ninput_items_required = _message.forecast_args_ninput_items_required; + return; default: - unsigned ninputs = ninput_items_required.size(); - for(unsigned i = 0; i < ninputs; i++) - ninput_items_required[i] = fixed_rate_noutput_to_ninput(noutput_items); - return; + unsigned ninputs = ninput_items_required.size(); + for (unsigned i = 0; i < ninputs; i++) + ninput_items_required[i] = fixed_rate_noutput_to_ninput(noutput_items); + return; } - } - - int - block_gateway_impl::general_work(int noutput_items, - gr_vector_int &ninput_items, - gr_vector_const_void_star &input_items, - gr_vector_void_star &output_items) - { - switch(_work_type) { +} + +int block_gateway_impl::general_work(int noutput_items, + gr_vector_int& ninput_items, + gr_vector_const_void_star& input_items, + gr_vector_void_star& output_items) +{ + switch (_work_type) { case GR_BLOCK_GW_WORK_GENERAL: - _message.action = block_gw_message_type::ACTION_GENERAL_WORK; - _message.general_work_args_noutput_items = noutput_items; - _message.general_work_args_ninput_items = ninput_items; - copy_pointers(_message.general_work_args_input_items, input_items); - _message.general_work_args_output_items = output_items; - _handler->calleval(0); - return _message.general_work_args_return_value; + _message.action = block_gw_message_type::ACTION_GENERAL_WORK; + _message.general_work_args_noutput_items = noutput_items; + _message.general_work_args_ninput_items = ninput_items; + copy_pointers(_message.general_work_args_input_items, input_items); + _message.general_work_args_output_items = output_items; + _handler->calleval(0); + return _message.general_work_args_return_value; default: - int r = work (noutput_items, input_items, output_items); - if(r > 0) - consume_each(r*_decim/_interp); - return r; + int r = work(noutput_items, input_items, output_items); + if (r > 0) + consume_each(r * _decim / _interp); + return r; } - } +} - int - block_gateway_impl::work(int noutput_items, - gr_vector_const_void_star &input_items, - gr_vector_void_star &output_items) - { +int block_gateway_impl::work(int noutput_items, + gr_vector_const_void_star& input_items, + gr_vector_void_star& output_items) +{ _message.action = block_gw_message_type::ACTION_WORK; _message.work_args_ninput_items = fixed_rate_noutput_to_ninput(noutput_items); - if(_message.work_args_ninput_items == 0) - return -1; + if (_message.work_args_ninput_items == 0) + return -1; _message.work_args_noutput_items = noutput_items; copy_pointers(_message.work_args_input_items, input_items); _message.work_args_output_items = output_items; _handler->calleval(0); return _message.work_args_return_value; - } - - int - block_gateway_impl::fixed_rate_noutput_to_ninput(int noutput_items) - { - return (noutput_items*_decim/_interp) + history() - 1; - } - - int - block_gateway_impl::fixed_rate_ninput_to_noutput(int ninput_items) - { - return std::max(0, ninput_items - (int)history() + 1)*_interp/_decim; - } - - bool - block_gateway_impl::start(void) - { +} + +int block_gateway_impl::fixed_rate_noutput_to_ninput(int noutput_items) +{ + return (noutput_items * _decim / _interp) + history() - 1; +} + +int block_gateway_impl::fixed_rate_ninput_to_noutput(int ninput_items) +{ + return std::max(0, ninput_items - (int)history() + 1) * _interp / _decim; +} + +bool block_gateway_impl::start(void) +{ _message.action = block_gw_message_type::ACTION_START; _handler->calleval(0); return _message.start_args_return_value; - } +} - bool - block_gateway_impl::stop(void) - { +bool block_gateway_impl::stop(void) +{ _message.action = block_gw_message_type::ACTION_STOP; _handler->calleval(0); return _message.stop_args_return_value; - } +} - block_gw_message_type& - block_gateway_impl::block_message(void) - { - return _message; - } +block_gw_message_type& block_gateway_impl::block_message(void) { return _message; } } /* namespace gr */ diff --git a/gnuradio-runtime/lib/block_gateway_impl.h b/gnuradio-runtime/lib/block_gateway_impl.h index 1707ecf1c8..b90b54d7a5 100644 --- a/gnuradio-runtime/lib/block_gateway_impl.h +++ b/gnuradio-runtime/lib/block_gateway_impl.h @@ -27,14 +27,14 @@ namespace gr { - /*********************************************************************** - * The gr::block gateway implementation class - **********************************************************************/ - class block_gateway_impl : public block_gateway - { - public: - block_gateway_impl(feval_ll *handler, - const std::string &name, +/*********************************************************************** + * The gr::block gateway implementation class + **********************************************************************/ +class block_gateway_impl : public block_gateway +{ +public: + block_gateway_impl(feval_ll* handler, + const std::string& name, gr::io_signature::sptr in_sig, gr::io_signature::sptr out_sig, const block_gw_work_type work_type, @@ -43,17 +43,16 @@ namespace gr { /******************************************************************* * Overloads for various scheduler-called functions ******************************************************************/ - void forecast(int noutput_items, - gr_vector_int &ninput_items_required); + void forecast(int noutput_items, gr_vector_int& ninput_items_required); int general_work(int noutput_items, - gr_vector_int &ninput_items, - gr_vector_const_void_star &input_items, - gr_vector_void_star &output_items); + gr_vector_int& ninput_items, + gr_vector_const_void_star& input_items, + gr_vector_void_star& output_items); int work(int noutput_items, - gr_vector_const_void_star &input_items, - gr_vector_void_star &output_items); + gr_vector_const_void_star& input_items, + gr_vector_void_star& output_items); int fixed_rate_noutput_to_ninput(int noutput_items); int fixed_rate_ninput_to_noutput(int ninput_items); @@ -63,12 +62,12 @@ namespace gr { block_gw_message_type& block_message(void); - private: - feval_ll *_handler; +private: + feval_ll* _handler; block_gw_message_type _message; const block_gw_work_type _work_type; unsigned _decim, _interp; - }; +}; } /* namespace gr */ diff --git a/gnuradio-runtime/lib/block_registry.cc b/gnuradio-runtime/lib/block_registry.cc index 5241ef9922..f25ad25b86 100644 --- a/gnuradio-runtime/lib/block_registry.cc +++ b/gnuradio-runtime/lib/block_registry.cc @@ -31,124 +31,111 @@ gr::block_registry global_block_registry; namespace gr { - block_registry::block_registry() - { - d_ref_map = pmt::make_dict(); - } - - long - block_registry::block_register(basic_block* block) - { +block_registry::block_registry() { d_ref_map = pmt::make_dict(); } + +long block_registry::block_register(basic_block* block) +{ gr::thread::scoped_lock guard(d_mutex); - if(d_map.find(block->name()) == d_map.end()) { - d_map[block->name()] = blocksubmap_t(); - d_map[block->name()][0] = block; - return 0; - } - else { - for(size_t i=0; i<=d_map[block->name()].size(); i++){ - if(d_map[block->name()].find(i) == d_map[block->name()].end()){ - d_map[block->name()][i] = block; - return i; + if (d_map.find(block->name()) == d_map.end()) { + d_map[block->name()] = blocksubmap_t(); + d_map[block->name()][0] = block; + return 0; + } else { + for (size_t i = 0; i <= d_map[block->name()].size(); i++) { + if (d_map[block->name()].find(i) == d_map[block->name()].end()) { + d_map[block->name()][i] = block; + return i; + } } - } } throw std::runtime_error("should not reach this"); - } +} - void - block_registry::block_unregister(basic_block* block) - { +void block_registry::block_unregister(basic_block* block) +{ gr::thread::scoped_lock guard(d_mutex); - d_map[block->name()].erase( d_map[block->name()].find(block->symbolic_id())); + d_map[block->name()].erase(d_map[block->name()].find(block->symbolic_id())); d_ref_map = pmt::dict_delete(d_ref_map, pmt::intern(block->symbol_name())); - if(block->alias_set()) { - d_ref_map = pmt::dict_delete(d_ref_map, pmt::intern(block->alias())); + if (block->alias_set()) { + d_ref_map = pmt::dict_delete(d_ref_map, pmt::intern(block->alias())); } - } +} - std::string - block_registry::register_symbolic_name(basic_block* block) - { +std::string block_registry::register_symbolic_name(basic_block* block) +{ std::stringstream ss; ss << block->name() << block->symbolic_id(); - //std::cout << "register_symbolic_name: " << ss.str() << std::endl; + // std::cout << "register_symbolic_name: " << ss.str() << std::endl; register_symbolic_name(block, ss.str()); return ss.str(); - } +} - void - block_registry::register_symbolic_name(basic_block* block, std::string name) - { +void block_registry::register_symbolic_name(basic_block* block, std::string name) +{ gr::thread::scoped_lock guard(d_mutex); - if(pmt::dict_has_key(d_ref_map, pmt::intern(name))) { - throw std::runtime_error("symbol already exists, can not re-use!"); + if (pmt::dict_has_key(d_ref_map, pmt::intern(name))) { + throw std::runtime_error("symbol already exists, can not re-use!"); } d_ref_map = pmt::dict_add(d_ref_map, pmt::intern(name), pmt::make_any(block)); - } +} - void - block_registry::update_symbolic_name(basic_block* block, std::string name) - { +void block_registry::update_symbolic_name(basic_block* block, std::string name) +{ gr::thread::scoped_lock guard(d_mutex); - if(pmt::dict_has_key(d_ref_map, pmt::intern(name))) { - throw std::runtime_error("symbol already exists, can not re-use!"); + if (pmt::dict_has_key(d_ref_map, pmt::intern(name))) { + throw std::runtime_error("symbol already exists, can not re-use!"); } // If we don't already have an alias, don't try and delete it. - if(block->alias_set()) { - // And make sure that the registry has the alias key. - // We test both in case the block's and registry ever get out of sync. - if(pmt::dict_has_key(d_ref_map, block->alias_pmt())) { - d_ref_map = pmt::dict_delete(d_ref_map, block->alias_pmt()); - } + if (block->alias_set()) { + // And make sure that the registry has the alias key. + // We test both in case the block's and registry ever get out of sync. + if (pmt::dict_has_key(d_ref_map, block->alias_pmt())) { + d_ref_map = pmt::dict_delete(d_ref_map, block->alias_pmt()); + } } d_ref_map = pmt::dict_add(d_ref_map, pmt::intern(name), pmt::make_any(block)); - } +} - basic_block_sptr - block_registry::block_lookup(pmt::pmt_t symbol) - { +basic_block_sptr block_registry::block_lookup(pmt::pmt_t symbol) +{ gr::thread::scoped_lock guard(d_mutex); pmt::pmt_t ref = pmt::dict_ref(d_ref_map, symbol, pmt::PMT_NIL); - if(pmt::eq(ref, pmt::PMT_NIL)) { - throw std::runtime_error("block lookup failed! block not found!"); + if (pmt::eq(ref, pmt::PMT_NIL)) { + throw std::runtime_error("block lookup failed! block not found!"); } basic_block* blk = boost::any_cast<basic_block*>(pmt::any_ref(ref)); return blk->shared_from_this(); - } +} - void - block_registry::register_primitive(std::string blk, block* ref) - { +void block_registry::register_primitive(std::string blk, block* ref) +{ gr::thread::scoped_lock guard(d_mutex); primitive_map[blk] = ref; - } +} - void - block_registry::unregister_primitive(std::string blk) - { +void block_registry::unregister_primitive(std::string blk) +{ gr::thread::scoped_lock guard(d_mutex); primitive_map.erase(primitive_map.find(blk)); - } +} - void - block_registry::notify_blk(std::string blk) - { +void block_registry::notify_blk(std::string blk) +{ gr::thread::scoped_lock guard(d_mutex); - if(primitive_map.find(blk) == primitive_map.end()) { - return; + if (primitive_map.find(blk) == primitive_map.end()) { + return; } - if(primitive_map[blk]->detail().get()) - primitive_map[blk]->detail()->d_tpb.notify_msg(); - } + if (primitive_map[blk]->detail().get()) + primitive_map[blk]->detail()->d_tpb.notify_msg(); +} } /* namespace gr */ diff --git a/gnuradio-runtime/lib/buffer.cc b/gnuradio-runtime/lib/buffer.cc index 1681c12763..e66e9ed6c6 100644 --- a/gnuradio-runtime/lib/buffer.cc +++ b/gnuradio-runtime/lib/buffer.cc @@ -44,217 +44,212 @@ namespace gr { - static long s_buffer_count = 0; // counts for debugging storage mgmt - static long s_buffer_reader_count = 0; - - /* ---------------------------------------------------------------------------- - Notes on storage management - - Pretty much all the fundamental classes are now using the - shared_ptr stuff for automatic reference counting. To ensure that - no mistakes are made, we make the constructors for classes private, - and then provide a free factory function that returns a smart - pointer to the desired class. - - gr::buffer and gr::buffer_reader are no exceptions. However, they - both want pointers to each other, and unless we do something, we'll - never delete any of them because of the circular structure. - They'll always have a reference count of at least one. We could - use boost::weak_ptr's from gr::buffer to gr::buffer_reader but that - introduces it's own problems. (gr::buffer_reader's destructor needs - to call gr::buffer::drop_reader, but has no easy way to get a - shared_ptr to itself.) - - Instead, we solve this problem by having gr::buffer hold a raw - pointer to gr::buffer_reader in its d_reader vector. - gr::buffer_reader's destructor calls gr::buffer::drop_reader, so - we're never left with an dangling pointer. gr::buffer_reader still - has a shared_ptr to the buffer ensuring that the buffer doesn't go - away under it. However, when the reference count of a - gr::buffer_reader goes to zero, we can successfully reclaim it. - ---------------------------------------------------------------------------- */ - - /* - * Compute the minimum number of buffer items that work (i.e., - * address space wrap-around works). To work is to satisfy this - * constraint for integer buffer_size and k: - * - * type_size * nitems == k * page_size - */ - static long - minimum_buffer_items(long type_size, long page_size) - { +static long s_buffer_count = 0; // counts for debugging storage mgmt +static long s_buffer_reader_count = 0; + +/* ---------------------------------------------------------------------------- + Notes on storage management + + Pretty much all the fundamental classes are now using the + shared_ptr stuff for automatic reference counting. To ensure that + no mistakes are made, we make the constructors for classes private, + and then provide a free factory function that returns a smart + pointer to the desired class. + + gr::buffer and gr::buffer_reader are no exceptions. However, they + both want pointers to each other, and unless we do something, we'll + never delete any of them because of the circular structure. + They'll always have a reference count of at least one. We could + use boost::weak_ptr's from gr::buffer to gr::buffer_reader but that + introduces it's own problems. (gr::buffer_reader's destructor needs + to call gr::buffer::drop_reader, but has no easy way to get a + shared_ptr to itself.) + + Instead, we solve this problem by having gr::buffer hold a raw + pointer to gr::buffer_reader in its d_reader vector. + gr::buffer_reader's destructor calls gr::buffer::drop_reader, so + we're never left with an dangling pointer. gr::buffer_reader still + has a shared_ptr to the buffer ensuring that the buffer doesn't go + away under it. However, when the reference count of a + gr::buffer_reader goes to zero, we can successfully reclaim it. + ---------------------------------------------------------------------------- */ + +/* + * Compute the minimum number of buffer items that work (i.e., + * address space wrap-around works). To work is to satisfy this + * constraint for integer buffer_size and k: + * + * type_size * nitems == k * page_size + */ +static long minimum_buffer_items(long type_size, long page_size) +{ #if (BOOST_VERSION < 105800) - return page_size / boost::math::gcd (type_size, page_size); + return page_size / boost::math::gcd(type_size, page_size); #else - return page_size / boost::integer::gcd (type_size, page_size); + return page_size / boost::integer::gcd(type_size, page_size); #endif - } - - - buffer::buffer(int nitems, size_t sizeof_item, block_sptr link) - : d_base(0), d_bufsize(0), d_max_reader_delay(0), d_vmcircbuf(0), - d_sizeof_item(sizeof_item), d_link(link), - d_write_index(0), d_abs_write_offset(0), d_done(false), +} + + +buffer::buffer(int nitems, size_t sizeof_item, block_sptr link) + : d_base(0), + d_bufsize(0), + d_max_reader_delay(0), + d_vmcircbuf(0), + d_sizeof_item(sizeof_item), + d_link(link), + d_write_index(0), + d_abs_write_offset(0), + d_done(false), d_last_min_items_read(0) - { - if(!allocate_buffer (nitems, sizeof_item)) - throw std::bad_alloc (); +{ + if (!allocate_buffer(nitems, sizeof_item)) + throw std::bad_alloc(); s_buffer_count++; - } +} - buffer_sptr - make_buffer(int nitems, size_t sizeof_item, block_sptr link) - { +buffer_sptr make_buffer(int nitems, size_t sizeof_item, block_sptr link) +{ return buffer_sptr(new buffer(nitems, sizeof_item, link)); - } +} - buffer::~buffer() - { +buffer::~buffer() +{ delete d_vmcircbuf; assert(d_readers.size() == 0); s_buffer_count--; - } - - /*! - * sets d_vmcircbuf, d_base, d_bufsize. - * returns true iff successful. - */ - bool - buffer::allocate_buffer(int nitems, size_t sizeof_item) - { +} + +/*! + * sets d_vmcircbuf, d_base, d_bufsize. + * returns true iff successful. + */ +bool buffer::allocate_buffer(int nitems, size_t sizeof_item) +{ int orig_nitems = nitems; // Any buffersize we come up with must be a multiple of min_nitems. int granularity = gr::vmcircbuf_sysconfig::granularity(); - int min_nitems = minimum_buffer_items(sizeof_item, granularity); + int min_nitems = minimum_buffer_items(sizeof_item, granularity); // Round-up nitems to a multiple of min_nitems. - if(nitems % min_nitems != 0) - nitems = ((nitems / min_nitems) + 1) * min_nitems; + if (nitems % min_nitems != 0) + nitems = ((nitems / min_nitems) + 1) * min_nitems; // If we rounded-up a whole bunch, give the user a heads up. // This only happens if sizeof_item is not a power of two. - if(nitems > 2 * orig_nitems && nitems * (int) sizeof_item > granularity){ - std::cerr << "gr::buffer::allocate_buffer: warning: tried to allocate\n" - << " " << orig_nitems << " items of size " - << sizeof_item << ". Due to alignment requirements\n" - << " " << nitems << " were allocated. If this isn't OK, consider padding\n" - << " your structure to a power-of-two bytes.\n" - << " On this platform, our allocation granularity is " << granularity << " bytes.\n"; + if (nitems > 2 * orig_nitems && nitems * (int)sizeof_item > granularity) { + std::cerr << "gr::buffer::allocate_buffer: warning: tried to allocate\n" + << " " << orig_nitems << " items of size " << sizeof_item + << ". Due to alignment requirements\n" + << " " << nitems + << " were allocated. If this isn't OK, consider padding\n" + << " your structure to a power-of-two bytes.\n" + << " On this platform, our allocation granularity is " << granularity + << " bytes.\n"; } d_bufsize = nitems; d_vmcircbuf = gr::vmcircbuf_sysconfig::make(d_bufsize * d_sizeof_item); - if(d_vmcircbuf == 0){ - std::cerr << "gr::buffer::allocate_buffer: failed to allocate buffer of size " - << d_bufsize * d_sizeof_item / 1024 << " KB\n"; - return false; + if (d_vmcircbuf == 0) { + std::cerr << "gr::buffer::allocate_buffer: failed to allocate buffer of size " + << d_bufsize * d_sizeof_item / 1024 << " KB\n"; + return false; } d_base = (char*)d_vmcircbuf->pointer_to_first_copy(); return true; - } +} - int - buffer::space_available() - { - if(d_readers.empty()) - return d_bufsize - 1; // See comment below +int buffer::space_available() +{ + if (d_readers.empty()) + return d_bufsize - 1; // See comment below else { - // Find out the maximum amount of data available to our readers - - int most_data = d_readers[0]->items_available(); - uint64_t min_items_read = d_readers[0]->nitems_read(); - for(size_t i = 1; i < d_readers.size (); i++) { - most_data = std::max(most_data, d_readers[i]->items_available()); - min_items_read = std::min(min_items_read, d_readers[i]->nitems_read()); - } - - if(min_items_read != d_last_min_items_read) { - prune_tags(d_last_min_items_read); - d_last_min_items_read = min_items_read; - } - - // The -1 ensures that the case d_write_index == d_read_index is - // unambiguous. It indicates that there is no data for the reader - return d_bufsize - most_data - 1; + // Find out the maximum amount of data available to our readers + + int most_data = d_readers[0]->items_available(); + uint64_t min_items_read = d_readers[0]->nitems_read(); + for (size_t i = 1; i < d_readers.size(); i++) { + most_data = std::max(most_data, d_readers[i]->items_available()); + min_items_read = std::min(min_items_read, d_readers[i]->nitems_read()); + } + + if (min_items_read != d_last_min_items_read) { + prune_tags(d_last_min_items_read); + d_last_min_items_read = min_items_read; + } + + // The -1 ensures that the case d_write_index == d_read_index is + // unambiguous. It indicates that there is no data for the reader + return d_bufsize - most_data - 1; } - } +} - void * - buffer::write_pointer() - { - return &d_base[d_write_index * d_sizeof_item]; - } +void* buffer::write_pointer() { return &d_base[d_write_index * d_sizeof_item]; } - void - buffer::update_write_pointer(int nitems) - { +void buffer::update_write_pointer(int nitems) +{ gr::thread::scoped_lock guard(*mutex()); d_write_index = index_add(d_write_index, nitems); d_abs_write_offset += nitems; - } +} - void - buffer::set_done(bool done) - { +void buffer::set_done(bool done) +{ gr::thread::scoped_lock guard(*mutex()); d_done = done; - } - - buffer_reader_sptr - buffer_add_reader(buffer_sptr buf, int nzero_preload, block_sptr link, int delay) - { - if(nzero_preload < 0) - throw std::invalid_argument("buffer_add_reader: nzero_preload must be >= 0"); - - buffer_reader_sptr r(new buffer_reader(buf, - buf->index_sub(buf->d_write_index, - nzero_preload), - link)); +} + +buffer_reader_sptr +buffer_add_reader(buffer_sptr buf, int nzero_preload, block_sptr link, int delay) +{ + if (nzero_preload < 0) + throw std::invalid_argument("buffer_add_reader: nzero_preload must be >= 0"); + + buffer_reader_sptr r( + new buffer_reader(buf, buf->index_sub(buf->d_write_index, nzero_preload), link)); r->declare_sample_delay(delay); - buf->d_readers.push_back(r.get ()); + buf->d_readers.push_back(r.get()); return r; - } +} - void - buffer::drop_reader(buffer_reader *reader) - { - std::vector<buffer_reader *>::iterator result = - std::find(d_readers.begin(), d_readers.end(), reader); +void buffer::drop_reader(buffer_reader* reader) +{ + std::vector<buffer_reader*>::iterator result = + std::find(d_readers.begin(), d_readers.end(), reader); - if(result == d_readers.end()) - throw std::invalid_argument("buffer::drop_reader"); // we didn't find it... + if (result == d_readers.end()) + throw std::invalid_argument("buffer::drop_reader"); // we didn't find it... d_readers.erase(result); - } +} - void - buffer::add_item_tag(const tag_t &tag) - { +void buffer::add_item_tag(const tag_t& tag) +{ gr::thread::scoped_lock guard(*mutex()); - d_item_tags.insert(std::pair<uint64_t,tag_t>(tag.offset,tag)); - } + d_item_tags.insert(std::pair<uint64_t, tag_t>(tag.offset, tag)); +} - void - buffer::remove_item_tag(const tag_t &tag, long id) - { +void buffer::remove_item_tag(const tag_t& tag, long id) +{ gr::thread::scoped_lock guard(*mutex()); - for(std::multimap<uint64_t,tag_t>::iterator it = d_item_tags.lower_bound(tag.offset); it != d_item_tags.upper_bound(tag.offset); ++it) { - if((*it).second == tag) { - (*it).second.marked_deleted.push_back(id); - } + for (std::multimap<uint64_t, tag_t>::iterator it = + d_item_tags.lower_bound(tag.offset); + it != d_item_tags.upper_bound(tag.offset); + ++it) { + if ((*it).second == tag) { + (*it).second.marked_deleted.push_back(id); + } } - } +} - void - buffer::prune_tags(uint64_t max_time) - { +void buffer::prune_tags(uint64_t max_time) +{ /* NOTE: this function _should_ lock the mutex before editing d_item_tags. In practice, this function is only called at runtime by min_available_space in block_executor.cc, which @@ -276,115 +271,101 @@ namespace gr { */ uint64_t item_time; - std::multimap<uint64_t,tag_t>::iterator itr(d_item_tags.begin()), tmp; - while(itr != d_item_tags.end()) { - item_time = (*itr).second.offset; - if(item_time+d_max_reader_delay + bufsize() < max_time) { - tmp = itr; - itr++; - d_item_tags.erase(tmp); - } - else { - // d_item_tags is a map sorted by offset, so when the if - // condition above fails, all future tags in the map must also - // fail. So just break here. - break; - } + std::multimap<uint64_t, tag_t>::iterator itr(d_item_tags.begin()), tmp; + while (itr != d_item_tags.end()) { + item_time = (*itr).second.offset; + if (item_time + d_max_reader_delay + bufsize() < max_time) { + tmp = itr; + itr++; + d_item_tags.erase(tmp); + } else { + // d_item_tags is a map sorted by offset, so when the if + // condition above fails, all future tags in the map must also + // fail. So just break here. + break; + } } - } +} - long - buffer_ncurrently_allocated() - { - return s_buffer_count; - } +long buffer_ncurrently_allocated() { return s_buffer_count; } - // ---------------------------------------------------------------------------- +// ---------------------------------------------------------------------------- - buffer_reader::buffer_reader(buffer_sptr buffer, unsigned int read_index, - block_sptr link) - : d_buffer(buffer), d_read_index(read_index), d_abs_read_offset(0), d_link(link), +buffer_reader::buffer_reader(buffer_sptr buffer, unsigned int read_index, block_sptr link) + : d_buffer(buffer), + d_read_index(read_index), + d_abs_read_offset(0), + d_link(link), d_attr_delay(0) - { +{ s_buffer_reader_count++; buffer->d_max_reader_delay = 0; - } +} - buffer_reader::~buffer_reader() - { +buffer_reader::~buffer_reader() +{ d_buffer->drop_reader(this); s_buffer_reader_count--; - } +} - void - buffer_reader::declare_sample_delay(unsigned delay) - { +void buffer_reader::declare_sample_delay(unsigned delay) +{ d_attr_delay = delay; - d_buffer->d_max_reader_delay = std::max(d_attr_delay, - d_buffer->d_max_reader_delay); - } - - unsigned - buffer_reader::sample_delay() const - { - return d_attr_delay; - } - - int - buffer_reader::items_available() const - { + d_buffer->d_max_reader_delay = std::max(d_attr_delay, d_buffer->d_max_reader_delay); +} + +unsigned buffer_reader::sample_delay() const { return d_attr_delay; } + +int buffer_reader::items_available() const +{ return d_buffer->index_sub(d_buffer->d_write_index, d_read_index); - } +} - const void * - buffer_reader::read_pointer() - { +const void* buffer_reader::read_pointer() +{ return &d_buffer->d_base[d_read_index * d_buffer->d_sizeof_item]; - } +} - void - buffer_reader::update_read_pointer(int nitems) - { +void buffer_reader::update_read_pointer(int nitems) +{ gr::thread::scoped_lock guard(*mutex()); - d_read_index = d_buffer->index_add (d_read_index, nitems); + d_read_index = d_buffer->index_add(d_read_index, nitems); d_abs_read_offset += nitems; - } - - void - buffer_reader::get_tags_in_range(std::vector<tag_t> &v, - uint64_t abs_start, - uint64_t abs_end, - long id) - { +} + +void buffer_reader::get_tags_in_range(std::vector<tag_t>& v, + uint64_t abs_start, + uint64_t abs_end, + long id) +{ gr::thread::scoped_lock guard(*mutex()); v.clear(); - std::multimap<uint64_t,tag_t>::iterator itr = d_buffer->get_tags_lower_bound(std::min(abs_start, abs_start - d_attr_delay)); - std::multimap<uint64_t,tag_t>::iterator itr_end = d_buffer->get_tags_upper_bound(std::min(abs_end, abs_end - d_attr_delay)); + std::multimap<uint64_t, tag_t>::iterator itr = + d_buffer->get_tags_lower_bound(std::min(abs_start, abs_start - d_attr_delay)); + std::multimap<uint64_t, tag_t>::iterator itr_end = + d_buffer->get_tags_upper_bound(std::min(abs_end, abs_end - d_attr_delay)); uint64_t item_time; - while(itr != itr_end) { - item_time = (*itr).second.offset + d_attr_delay; - if((item_time >= abs_start) && (item_time < abs_end)) { - std::vector<long>::iterator id_itr; - id_itr = std::find(itr->second.marked_deleted.begin(), itr->second.marked_deleted.end(), id); - // If id is not in the vector of marked blocks - if(id_itr == itr->second.marked_deleted.end()) { - tag_t t = (*itr).second; - t.offset += d_attr_delay; - v.push_back(t); - v.back().marked_deleted.clear(); + while (itr != itr_end) { + item_time = (*itr).second.offset + d_attr_delay; + if ((item_time >= abs_start) && (item_time < abs_end)) { + std::vector<long>::iterator id_itr; + id_itr = std::find( + itr->second.marked_deleted.begin(), itr->second.marked_deleted.end(), id); + // If id is not in the vector of marked blocks + if (id_itr == itr->second.marked_deleted.end()) { + tag_t t = (*itr).second; + t.offset += d_attr_delay; + v.push_back(t); + v.back().marked_deleted.clear(); + } } - } - itr++; + itr++; } - } +} - long - buffer_reader_ncurrently_allocated() - { - return s_buffer_reader_count; - } +long buffer_reader_ncurrently_allocated() { return s_buffer_reader_count; } } /* namespace gr */ diff --git a/gnuradio-runtime/lib/circular_file.cc b/gnuradio-runtime/lib/circular_file.cc index 9cef419426..3569baf280 100644 --- a/gnuradio-runtime/lib/circular_file.cc +++ b/gnuradio-runtime/lib/circular_file.cc @@ -49,64 +49,62 @@ namespace gr { - static const int HEADER_SIZE = 4096; - static const int HEADER_MAGIC = 0xEB021026; +static const int HEADER_SIZE = 4096; +static const int HEADER_MAGIC = 0xEB021026; - static const int HD_MAGIC = 0; - static const int HD_HEADER_SIZE = 1; // integer offsets into header - static const int HD_BUFFER_SIZE = 2; - static const int HD_BUFFER_BASE = 3; - static const int HD_BUFFER_CURRENT = 4; +static const int HD_MAGIC = 0; +static const int HD_HEADER_SIZE = 1; // integer offsets into header +static const int HD_BUFFER_SIZE = 2; +static const int HD_BUFFER_BASE = 3; +static const int HD_BUFFER_CURRENT = 4; - circular_file::circular_file(const char *filename, - bool writable, int size) +circular_file::circular_file(const char* filename, bool writable, int size) : d_fd(-1), d_header(0), d_buffer(0), d_mapped_size(0), d_bytes_read(0) - { +{ int mm_prot; - if(writable) { + if (writable) { #ifdef HAVE_MMAP - mm_prot = PROT_READ | PROT_WRITE; + mm_prot = PROT_READ | PROT_WRITE; #endif - d_fd = open(filename, O_CREAT | O_RDWR | O_TRUNC, 0664); - if(d_fd < 0) { - perror(filename); - exit(1); - } -#ifdef HAVE_MMAP /* FIXME */ - if(ftruncate(d_fd, size + HEADER_SIZE) != 0) { - perror(filename); - exit(1); - } + d_fd = open(filename, O_CREAT | O_RDWR | O_TRUNC, 0664); + if (d_fd < 0) { + perror(filename); + exit(1); + } +#ifdef HAVE_MMAP /* FIXME */ + if (ftruncate(d_fd, size + HEADER_SIZE) != 0) { + perror(filename); + exit(1); + } #endif - } - else { + } else { #ifdef HAVE_MMAP - mm_prot = PROT_READ; + mm_prot = PROT_READ; #endif - d_fd = open (filename, O_RDONLY); - if(d_fd < 0) { - perror(filename); - exit(1); - } + d_fd = open(filename, O_RDONLY); + if (d_fd < 0) { + perror(filename); + exit(1); + } } struct stat statbuf; - if(fstat (d_fd, &statbuf) < 0) { - perror(filename); - exit(1); + if (fstat(d_fd, &statbuf) < 0) { + perror(filename); + exit(1); } - if(statbuf.st_size < HEADER_SIZE) { - fprintf(stderr, "%s: file too small to be circular buffer\n", filename); - exit(1); + if (statbuf.st_size < HEADER_SIZE) { + fprintf(stderr, "%s: file too small to be circular buffer\n", filename); + exit(1); } d_mapped_size = statbuf.st_size; #ifdef HAVE_MMAP - void *p = mmap (0, d_mapped_size, mm_prot, MAP_SHARED, d_fd, 0); - if(p == MAP_FAILED) { - perror("gr::circular_file: mmap failed"); - exit(1); + void* p = mmap(0, d_mapped_size, mm_prot, MAP_SHARED, d_fd, 0); + if (p == MAP_FAILED) { + perror("gr::circular_file: mmap failed"); + exit(1); } d_header = (int*)p; @@ -115,18 +113,18 @@ namespace gr { exit(1); #endif - if(writable) { // init header + if (writable) { // init header - if(size < 0) { - fprintf(stderr, "gr::circular_buffer: size must be > 0 when writable\n"); - exit(1); - } + if (size < 0) { + fprintf(stderr, "gr::circular_buffer: size must be > 0 when writable\n"); + exit(1); + } - d_header[HD_MAGIC] = HEADER_MAGIC; - d_header[HD_HEADER_SIZE] = HEADER_SIZE; - d_header[HD_BUFFER_SIZE] = size; - d_header[HD_BUFFER_BASE] = HEADER_SIZE; // right after header - d_header[HD_BUFFER_CURRENT] = 0; + d_header[HD_MAGIC] = HEADER_MAGIC; + d_header[HD_HEADER_SIZE] = HEADER_SIZE; + d_header[HD_BUFFER_SIZE] = size; + d_header[HD_BUFFER_BASE] = HEADER_SIZE; // right after header + d_header[HD_BUFFER_CURRENT] = 0; } // sanity check (the asserts are a bit unforgiving...) @@ -137,72 +135,66 @@ namespace gr { assert(d_header[HD_BUFFER_BASE] >= d_header[HD_HEADER_SIZE]); assert(d_header[HD_BUFFER_BASE] + d_header[HD_BUFFER_SIZE] <= d_mapped_size); assert(d_header[HD_BUFFER_CURRENT] >= 0 && - d_header[HD_BUFFER_CURRENT] < d_header[HD_BUFFER_SIZE]); + d_header[HD_BUFFER_CURRENT] < d_header[HD_BUFFER_SIZE]); d_bytes_read = 0; d_buffer = (unsigned char*)d_header + d_header[HD_BUFFER_BASE]; - } +} - circular_file::~circular_file() - { +circular_file::~circular_file() +{ #ifdef HAVE_MMAP - if(munmap ((char *) d_header, d_mapped_size) < 0) { - perror("gr::circular_file: munmap"); - exit(1); + if (munmap((char*)d_header, d_mapped_size) < 0) { + perror("gr::circular_file: munmap"); + exit(1); } #endif close(d_fd); - } +} - bool - circular_file::write(void *vdata, int nbytes) - { - unsigned char *data = (unsigned char*)vdata; +bool circular_file::write(void* vdata, int nbytes) +{ + unsigned char* data = (unsigned char*)vdata; int buffer_size = d_header[HD_BUFFER_SIZE]; int buffer_current = d_header[HD_BUFFER_CURRENT]; - while(nbytes > 0) { - int n = std::min(nbytes, buffer_size - buffer_current); - memcpy(d_buffer + buffer_current, data, n); + while (nbytes > 0) { + int n = std::min(nbytes, buffer_size - buffer_current); + memcpy(d_buffer + buffer_current, data, n); - buffer_current += n; - if(buffer_current >= buffer_size) - buffer_current = 0; + buffer_current += n; + if (buffer_current >= buffer_size) + buffer_current = 0; - data += n; - nbytes -= n; + data += n; + nbytes -= n; } d_header[HD_BUFFER_CURRENT] = buffer_current; return true; - } +} - int - circular_file::read(void *vdata, int nbytes) - { - unsigned char *data = (unsigned char *) vdata; +int circular_file::read(void* vdata, int nbytes) +{ + unsigned char* data = (unsigned char*)vdata; int buffer_current = d_header[HD_BUFFER_CURRENT]; int buffer_size = d_header[HD_BUFFER_SIZE]; int total = 0; nbytes = std::min(nbytes, buffer_size - d_bytes_read); - while(nbytes > 0) { - int offset = (buffer_current + d_bytes_read) % buffer_size; - int n = std::min (nbytes, buffer_size - offset); - memcpy(data, d_buffer + offset, n); - data += n; - d_bytes_read += n; - total += n; - nbytes -= n; + while (nbytes > 0) { + int offset = (buffer_current + d_bytes_read) % buffer_size; + int n = std::min(nbytes, buffer_size - offset); + memcpy(data, d_buffer + offset, n); + data += n; + d_bytes_read += n; + total += n; + nbytes -= n; } return total; - } +} - void - circular_file::reset_read_pointer() - { - d_bytes_read = 0; - } +void circular_file::reset_read_pointer() { d_bytes_read = 0; } } /* namespace gr */ diff --git a/gnuradio-runtime/lib/circular_file.h b/gnuradio-runtime/lib/circular_file.h index 1dc431d69a..69cb82c81c 100644 --- a/gnuradio-runtime/lib/circular_file.h +++ b/gnuradio-runtime/lib/circular_file.h @@ -27,38 +27,38 @@ namespace gr { - /* - * writes input data into a circular buffer on disk. - * - * the file contains a fixed header: - * 0x0000: int32 magic (0xEB021026) - * 0x0004: int32 size in bytes of header (constant 4096) - * 0x0008: int32 size in bytes of circular buffer (not including header) - * 0x000C: int32 file offset to beginning of circular buffer - * 0x0010: int32 byte offset from beginning of circular buffer to - * current start of data - */ - class GR_RUNTIME_API circular_file - { - private: - int d_fd; - int *d_header; - unsigned char *d_buffer; +/* + * writes input data into a circular buffer on disk. + * + * the file contains a fixed header: + * 0x0000: int32 magic (0xEB021026) + * 0x0004: int32 size in bytes of header (constant 4096) + * 0x0008: int32 size in bytes of circular buffer (not including header) + * 0x000C: int32 file offset to beginning of circular buffer + * 0x0010: int32 byte offset from beginning of circular buffer to + * current start of data + */ +class GR_RUNTIME_API circular_file +{ +private: + int d_fd; + int* d_header; + unsigned char* d_buffer; int d_mapped_size; int d_bytes_read; - public: - circular_file(const char *filename, bool writable = false, int size = 0); +public: + circular_file(const char* filename, bool writable = false, int size = 0); ~circular_file(); - bool write(void *data, int nbytes); + bool write(void* data, int nbytes); // returns # of bytes actually read or 0 if end of buffer, or -1 on error. - int read(void *data, int nbytes); + int read(void* data, int nbytes); // reset read pointer to beginning of buffer. void reset_read_pointer(); - }; +}; } /* namespace gr */ diff --git a/gnuradio-runtime/lib/controlport/rpcmanager.cc b/gnuradio-runtime/lib/controlport/rpcmanager.cc index fee255498e..aa9fc08cde 100644 --- a/gnuradio-runtime/lib/controlport/rpcmanager.cc +++ b/gnuradio-runtime/lib/controlport/rpcmanager.cc @@ -24,40 +24,36 @@ #include <iostream> #include <stdexcept> -rpcmanager::rpcmanager() {;} +rpcmanager::rpcmanager() { ; } -rpcmanager::~rpcmanager() {;} +rpcmanager::~rpcmanager() { ; } -rpcserver_booter_base* -rpcmanager::get() +rpcserver_booter_base* rpcmanager::get() { - if(aggregator_registered) { - return aggregator.get(); - } - else if(booter_registered) { + if (aggregator_registered) { + return aggregator.get(); + } else if (booter_registered) { + return boot.get(); + } + assert(booter_registered || aggregator_registered); return boot.get(); - } - assert(booter_registered || aggregator_registered); - return boot.get(); } -void -rpcmanager::register_booter(rpcserver_booter_base* booter) +void rpcmanager::register_booter(rpcserver_booter_base* booter) { - if(make_aggregator && !aggregator_registered) { - aggregator.reset(new rpcserver_booter_aggregator()); - aggregator_registered = true; - } + if (make_aggregator && !aggregator_registered) { + aggregator.reset(new rpcserver_booter_aggregator()); + aggregator_registered = true; + } - if(aggregator_registered) { - rpcmanager::rpcserver_booter_base_sptr bootreg(booter); - aggregator->agg()->registerServer(bootreg); - } - else if(!booter_registered) { - boot.reset(booter); - booter_registered = true; - } - else { - throw std::runtime_error("rpcmanager: Aggregator not in use, and a rpc booter is already registered\n"); - } + if (aggregator_registered) { + rpcmanager::rpcserver_booter_base_sptr bootreg(booter); + aggregator->agg()->registerServer(bootreg); + } else if (!booter_registered) { + boot.reset(booter); + booter_registered = true; + } else { + throw std::runtime_error("rpcmanager: Aggregator not in use, and a rpc booter is " + "already registered\n"); + } } diff --git a/gnuradio-runtime/lib/controlport/rpcserver_aggregator.cc b/gnuradio-runtime/lib/controlport/rpcserver_aggregator.cc index e81a899626..6a2f6c80e4 100644 --- a/gnuradio-runtime/lib/controlport/rpcserver_aggregator.cc +++ b/gnuradio-runtime/lib/controlport/rpcserver_aggregator.cc @@ -26,87 +26,83 @@ #include <sstream> #include <stdexcept> -rpcserver_aggregator::rpcserver_aggregator() - : d_type(std::string("aggregator")) -{;} +rpcserver_aggregator::rpcserver_aggregator() : d_type(std::string("aggregator")) { ; } -rpcserver_aggregator::~rpcserver_aggregator() -{;} +rpcserver_aggregator::~rpcserver_aggregator() { ; } -const std::string& -rpcserver_aggregator::type() -{ - return d_type; -} +const std::string& rpcserver_aggregator::type() { return d_type; } -const std::vector<std::string>& -rpcserver_aggregator::registeredServers() +const std::vector<std::string>& rpcserver_aggregator::registeredServers() { - return d_registeredServers; + return d_registeredServers; } -void -rpcserver_aggregator::registerConfigureCallback(const std::string &id, - const configureCallback_t callback) +void rpcserver_aggregator::registerConfigureCallback(const std::string& id, + const configureCallback_t callback) { - std::for_each(d_serverlist.begin(), d_serverlist.end(), - registerConfigureCallback_f<rpcmanager_base::rpcserver_booter_base_sptr, configureCallback_t>(id, callback)); + std::for_each(d_serverlist.begin(), + d_serverlist.end(), + registerConfigureCallback_f<rpcmanager_base::rpcserver_booter_base_sptr, + configureCallback_t>(id, callback)); } -void -rpcserver_aggregator::unregisterConfigureCallback(const std::string &id) +void rpcserver_aggregator::unregisterConfigureCallback(const std::string& id) { - std::for_each(d_serverlist.begin(), d_serverlist.end(), - unregisterConfigureCallback_f<rpcmanager_base::rpcserver_booter_base_sptr, configureCallback_t>(id)); + std::for_each( + d_serverlist.begin(), + d_serverlist.end(), + unregisterConfigureCallback_f<rpcmanager_base::rpcserver_booter_base_sptr, + configureCallback_t>(id)); } -void -rpcserver_aggregator::registerQueryCallback(const std::string &id, const queryCallback_t callback) +void rpcserver_aggregator::registerQueryCallback(const std::string& id, + const queryCallback_t callback) { - std::for_each(d_serverlist.begin(), d_serverlist.end(), - registerQueryCallback_f<rpcmanager_base::rpcserver_booter_base_sptr, queryCallback_t>(id, callback)); + std::for_each(d_serverlist.begin(), + d_serverlist.end(), + registerQueryCallback_f<rpcmanager_base::rpcserver_booter_base_sptr, + queryCallback_t>(id, callback)); } -void -rpcserver_aggregator::unregisterQueryCallback(const std::string &id) +void rpcserver_aggregator::unregisterQueryCallback(const std::string& id) { - std::for_each(d_serverlist.begin(), d_serverlist.end(), - unregisterQueryCallback_f<rpcmanager_base::rpcserver_booter_base_sptr, queryCallback_t>(id)); + std::for_each(d_serverlist.begin(), + d_serverlist.end(), + unregisterQueryCallback_f<rpcmanager_base::rpcserver_booter_base_sptr, + queryCallback_t>(id)); } - -void -rpcserver_aggregator::registerHandlerCallback(const std::string &id, - const handlerCallback_t callback) +void rpcserver_aggregator::registerHandlerCallback(const std::string& id, + const handlerCallback_t callback) { - std::for_each(d_serverlist.begin(), d_serverlist.end(), - registerHandlerCallback_f<rpcmanager_base::rpcserver_booter_base_sptr, handlerCallback_t>(id, callback)); + std::for_each(d_serverlist.begin(), + d_serverlist.end(), + registerHandlerCallback_f<rpcmanager_base::rpcserver_booter_base_sptr, + handlerCallback_t>(id, callback)); } -void -rpcserver_aggregator::unregisterHandlerCallback(const std::string &id) +void rpcserver_aggregator::unregisterHandlerCallback(const std::string& id) { - std::for_each(d_serverlist.begin(), d_serverlist.end(), - unregisterHandlerCallback_f<rpcmanager_base::rpcserver_booter_base_sptr, handlerCallback_t>(id)); + std::for_each(d_serverlist.begin(), + d_serverlist.end(), + unregisterHandlerCallback_f<rpcmanager_base::rpcserver_booter_base_sptr, + handlerCallback_t>(id)); } - -void -rpcserver_aggregator::registerServer(rpcmanager_base::rpcserver_booter_base_sptr server) +void rpcserver_aggregator::registerServer( + rpcmanager_base::rpcserver_booter_base_sptr server) { - std::vector<std::string>::iterator it(std::find(d_registeredServers.begin(), - d_registeredServers.end(), - server->type())); - if(it != d_registeredServers.end()) { - d_serverlist.push_back(server); - d_registeredServers.push_back(server->type()); - } - else { - std::stringstream s; - s << "rpcserver_aggregator::registerServer: server of type " - << server->type() << " already registered" << std::endl; - throw std::runtime_error(s.str().c_str()); - } + std::vector<std::string>::iterator it(std::find( + d_registeredServers.begin(), d_registeredServers.end(), server->type())); + if (it != d_registeredServers.end()) { + d_serverlist.push_back(server); + d_registeredServers.push_back(server->type()); + } else { + std::stringstream s; + s << "rpcserver_aggregator::registerServer: server of type " << server->type() + << " already registered" << std::endl; + throw std::runtime_error(s.str().c_str()); + } } diff --git a/gnuradio-runtime/lib/controlport/rpcserver_booter_aggregator.cc b/gnuradio-runtime/lib/controlport/rpcserver_booter_aggregator.cc index a1983b4ac5..de83f7af7c 100644 --- a/gnuradio-runtime/lib/controlport/rpcserver_booter_aggregator.cc +++ b/gnuradio-runtime/lib/controlport/rpcserver_booter_aggregator.cc @@ -22,42 +22,28 @@ #include <gnuradio/rpcserver_booter_aggregator.h> -rpcserver_booter_aggregator::rpcserver_booter_aggregator() : - d_type(std::string("aggregator")), - server(new rpcserver_aggregator()) -{;} - -rpcserver_booter_aggregator::~rpcserver_booter_aggregator() -{;} - -rpcserver_base* -rpcserver_booter_aggregator::i() +rpcserver_booter_aggregator::rpcserver_booter_aggregator() + : d_type(std::string("aggregator")), server(new rpcserver_aggregator()) { - return &(*server); + ; } -const std::string& -rpcserver_booter_aggregator::type() -{ - return d_type; -} +rpcserver_booter_aggregator::~rpcserver_booter_aggregator() { ; } -const std::vector<std::string> -rpcserver_booter_aggregator::endpoints() -{ - std::vector<std::string> ep; - ep.push_back(std::string("TODO")); - return ep; -} +rpcserver_base* rpcserver_booter_aggregator::i() { return &(*server); } -const std::vector<std::string>& -rpcserver_booter_aggregator::registeredServers() +const std::string& rpcserver_booter_aggregator::type() { return d_type; } + +const std::vector<std::string> rpcserver_booter_aggregator::endpoints() { - return server->registeredServers(); + std::vector<std::string> ep; + ep.push_back(std::string("TODO")); + return ep; } -rpcserver_aggregator* -rpcserver_booter_aggregator::agg() +const std::vector<std::string>& rpcserver_booter_aggregator::registeredServers() { - return &(*server); + return server->registeredServers(); } + +rpcserver_aggregator* rpcserver_booter_aggregator::agg() { return &(*server); } diff --git a/gnuradio-runtime/lib/controlport/rpcserver_selector.cc b/gnuradio-runtime/lib/controlport/rpcserver_selector.cc index 2785513a46..7d2453fd36 100644 --- a/gnuradio-runtime/lib/controlport/rpcserver_selector.cc +++ b/gnuradio-runtime/lib/controlport/rpcserver_selector.cc @@ -35,7 +35,7 @@ rpcmanager manager_instance; #endif #ifdef GR_RPCSERVER_ICE - #error TODO ICE +#error TODO ICE #endif #ifdef GR_RPCSERVER_THRIFT @@ -44,9 +44,9 @@ rpcmanager::rpcserver_booter_register_helper<rpcserver_booter_thrift> boot_thrif #endif #ifdef GR_RPCSERVER_ERLANG - #error TODO ERLANG +#error TODO ERLANG #endif #ifdef GR_RPCSERVER_XMLRPC - #error TODO XMLRPC +#error TODO XMLRPC #endif diff --git a/gnuradio-runtime/lib/controlport/thrift/rpcpmtconverters_thrift.cc b/gnuradio-runtime/lib/controlport/thrift/rpcpmtconverters_thrift.cc index cc8804f79d..05bb936f5a 100644 --- a/gnuradio-runtime/lib/controlport/thrift/rpcpmtconverters_thrift.cc +++ b/gnuradio-runtime/lib/controlport/thrift/rpcpmtconverters_thrift.cc @@ -25,279 +25,249 @@ #include "thrift/gnuradio_types.h" #include <iostream> -GNURadio::Knob -rpcpmtconverter::from_pmt(const pmt::pmt_t& knob) +GNURadio::Knob rpcpmtconverter::from_pmt(const pmt::pmt_t& knob) { - if(pmt::is_real(knob)) { - GNURadio::Knob result; - result.type = GNURadio::BaseTypes::DOUBLE; - result.value.__set_a_double(pmt::to_double(knob)); - return result; - } - else if(pmt::is_symbol(knob)) { - std::string value = pmt::symbol_to_string(knob); - GNURadio::Knob result; - result.type = GNURadio::BaseTypes::STRING; - result.value.__set_a_string(value); - return result; - } - else if(pmt::is_integer(knob)) { - GNURadio::Knob result; - result.type = GNURadio::BaseTypes::LONG; - result.value.__set_a_long(pmt::to_long(knob)); - return result; - } - else if(pmt::is_bool(knob)) { - GNURadio::Knob result; - result.type = GNURadio::BaseTypes::BOOL; - result.value.__set_a_bool(pmt::to_bool(knob)); - return result; - } - else if(pmt::is_uint64(knob)) { - GNURadio::Knob result; - result.type = GNURadio::BaseTypes::LONG; - result.value.__set_a_long(pmt::to_uint64(knob)); - return result; - } - else if(pmt::is_complex(knob)) { - GNURadio::Knob result; - result.type = GNURadio::BaseTypes::COMPLEX; - std::complex<double> tmp = pmt::to_complex(knob); - GNURadio::complex cpx; - cpx.re = tmp.real(); - cpx.im = tmp.imag(); - result.value.__set_a_complex(cpx); - return result; - } - else if(pmt::is_f32vector(knob)) { - GNURadio::Knob result; - result.type = GNURadio::BaseTypes::F32VECTOR; - size_t size(pmt::length(knob)); - const float* start((const float*)pmt::f32vector_elements(knob,size)); - result.value.__set_a_f32vector(std::vector<double>(start,start+size)); - return result; - } - else if(pmt::is_f64vector(knob)) { - GNURadio::Knob result; - result.type = GNURadio::BaseTypes::F64VECTOR; - size_t size(pmt::length(knob)); - const double* start((const double*)pmt::f64vector_elements(knob,size)); - result.value.__set_a_f64vector(std::vector<double>(start,start+size)); - return result; - } - else if(pmt::is_s64vector(knob)) { - GNURadio::Knob result; - result.type = GNURadio::BaseTypes::S64VECTOR; - size_t size(pmt::length(knob)); - const int64_t* start((const int64_t*)pmt::s64vector_elements(knob,size)); - result.value.__set_a_s64vector(std::vector<int64_t>(start,start+size)); - return result; - } - else if(pmt::is_s32vector(knob)) { - GNURadio::Knob result; - result.type = GNURadio::BaseTypes::S32VECTOR; - size_t size(pmt::length(knob)); - const int32_t* start((const int32_t*)pmt::s32vector_elements(knob,size)); - result.value.__set_a_s32vector(std::vector<int32_t>(start,start+size)); - return result; - } - else if(pmt::is_s16vector(knob)) { - GNURadio::Knob result; - result.type = GNURadio::BaseTypes::S16VECTOR; - size_t size(pmt::length(knob)); - const int16_t* start((const int16_t*)pmt::s16vector_elements(knob,size)); - result.value.__set_a_s16vector(std::vector<int16_t>(start,start+size)); - return result; - } - else if(pmt::is_s8vector(knob)) { - GNURadio::Knob result; - result.type = GNURadio::BaseTypes::S8VECTOR; - size_t size(pmt::length(knob)); - const int8_t* start((const int8_t*)pmt::s8vector_elements(knob,size)); - result.value.__set_a_s8vector(std::basic_string<char>(start,start+size)); - return result; - } - else if(pmt::is_c32vector(knob)) { - std::vector< GNURadio::complex > z; + if (pmt::is_real(knob)) { + GNURadio::Knob result; + result.type = GNURadio::BaseTypes::DOUBLE; + result.value.__set_a_double(pmt::to_double(knob)); + return result; + } else if (pmt::is_symbol(knob)) { + std::string value = pmt::symbol_to_string(knob); + GNURadio::Knob result; + result.type = GNURadio::BaseTypes::STRING; + result.value.__set_a_string(value); + return result; + } else if (pmt::is_integer(knob)) { + GNURadio::Knob result; + result.type = GNURadio::BaseTypes::LONG; + result.value.__set_a_long(pmt::to_long(knob)); + return result; + } else if (pmt::is_bool(knob)) { + GNURadio::Knob result; + result.type = GNURadio::BaseTypes::BOOL; + result.value.__set_a_bool(pmt::to_bool(knob)); + return result; + } else if (pmt::is_uint64(knob)) { + GNURadio::Knob result; + result.type = GNURadio::BaseTypes::LONG; + result.value.__set_a_long(pmt::to_uint64(knob)); + return result; + } else if (pmt::is_complex(knob)) { + GNURadio::Knob result; + result.type = GNURadio::BaseTypes::COMPLEX; + std::complex<double> tmp = pmt::to_complex(knob); + GNURadio::complex cpx; + cpx.re = tmp.real(); + cpx.im = tmp.imag(); + result.value.__set_a_complex(cpx); + return result; + } else if (pmt::is_f32vector(knob)) { + GNURadio::Knob result; + result.type = GNURadio::BaseTypes::F32VECTOR; + size_t size(pmt::length(knob)); + const float* start((const float*)pmt::f32vector_elements(knob, size)); + result.value.__set_a_f32vector(std::vector<double>(start, start + size)); + return result; + } else if (pmt::is_f64vector(knob)) { + GNURadio::Knob result; + result.type = GNURadio::BaseTypes::F64VECTOR; + size_t size(pmt::length(knob)); + const double* start((const double*)pmt::f64vector_elements(knob, size)); + result.value.__set_a_f64vector(std::vector<double>(start, start + size)); + return result; + } else if (pmt::is_s64vector(knob)) { + GNURadio::Knob result; + result.type = GNURadio::BaseTypes::S64VECTOR; + size_t size(pmt::length(knob)); + const int64_t* start((const int64_t*)pmt::s64vector_elements(knob, size)); + result.value.__set_a_s64vector(std::vector<int64_t>(start, start + size)); + return result; + } else if (pmt::is_s32vector(knob)) { + GNURadio::Knob result; + result.type = GNURadio::BaseTypes::S32VECTOR; + size_t size(pmt::length(knob)); + const int32_t* start((const int32_t*)pmt::s32vector_elements(knob, size)); + result.value.__set_a_s32vector(std::vector<int32_t>(start, start + size)); + return result; + } else if (pmt::is_s16vector(knob)) { + GNURadio::Knob result; + result.type = GNURadio::BaseTypes::S16VECTOR; + size_t size(pmt::length(knob)); + const int16_t* start((const int16_t*)pmt::s16vector_elements(knob, size)); + result.value.__set_a_s16vector(std::vector<int16_t>(start, start + size)); + return result; + } else if (pmt::is_s8vector(knob)) { + GNURadio::Knob result; + result.type = GNURadio::BaseTypes::S8VECTOR; + size_t size(pmt::length(knob)); + const int8_t* start((const int8_t*)pmt::s8vector_elements(knob, size)); + result.value.__set_a_s8vector(std::basic_string<char>(start, start + size)); + return result; + } else if (pmt::is_c32vector(knob)) { + std::vector<GNURadio::complex> z; - GNURadio::Knob result; - result.type = GNURadio::BaseTypes::C32VECTOR; - size_t size(pmt::length(knob)); - const gr_complex* start((const gr_complex*)pmt::c32vector_elements(knob,size)); - for(size_t s = 0; s < size; s++) { - GNURadio::complex z0; - gr_complex z1 = gr_complex(*(start+s)); - z0.__set_re(z1.real()); - z0.__set_im(z1.imag()); - z.push_back(z0); + GNURadio::Knob result; + result.type = GNURadio::BaseTypes::C32VECTOR; + size_t size(pmt::length(knob)); + const gr_complex* start((const gr_complex*)pmt::c32vector_elements(knob, size)); + for (size_t s = 0; s < size; s++) { + GNURadio::complex z0; + gr_complex z1 = gr_complex(*(start + s)); + z0.__set_re(z1.real()); + z0.__set_im(z1.imag()); + z.push_back(z0); + } + result.value.__set_a_c32vector(z); + return result; + } else { + std::cerr << "Error: Don't know how to handle Knob Type (from): " << knob + << std::endl; + assert(0); } - result.value.__set_a_c32vector(z); - return result; - } - else { - std::cerr << "Error: Don't know how to handle Knob Type (from): " << knob << std::endl; - assert(0); - } - return GNURadio::Knob(); + return GNURadio::Knob(); } -pmt::pmt_t -rpcpmtconverter::to_pmt_byte_f::operator()(const GNURadio::Knob& knob) +pmt::pmt_t rpcpmtconverter::to_pmt_byte_f::operator()(const GNURadio::Knob& knob) { - return pmt::mp(knob.value.a_byte); + return pmt::mp(knob.value.a_byte); } -pmt::pmt_t -rpcpmtconverter::to_pmt_short_f::operator()(const GNURadio::Knob& knob) +pmt::pmt_t rpcpmtconverter::to_pmt_short_f::operator()(const GNURadio::Knob& knob) { - return pmt::mp(knob.value.a_short); + return pmt::mp(knob.value.a_short); } -pmt::pmt_t -rpcpmtconverter::to_pmt_int_f::operator()(const GNURadio::Knob& knob) +pmt::pmt_t rpcpmtconverter::to_pmt_int_f::operator()(const GNURadio::Knob& knob) { - return pmt::mp(knob.value.a_int); + return pmt::mp(knob.value.a_int); } -pmt::pmt_t -rpcpmtconverter::to_pmt_long_f::operator()(const GNURadio::Knob& knob) +pmt::pmt_t rpcpmtconverter::to_pmt_long_f::operator()(const GNURadio::Knob& knob) { - return pmt::from_long(knob.value.a_long); + return pmt::from_long(knob.value.a_long); } -pmt::pmt_t -rpcpmtconverter::to_pmt_double_f::operator()(const GNURadio::Knob& knob) +pmt::pmt_t rpcpmtconverter::to_pmt_double_f::operator()(const GNURadio::Knob& knob) { - return pmt::mp(knob.value.a_double); + return pmt::mp(knob.value.a_double); } -pmt::pmt_t -rpcpmtconverter::to_pmt_string_f::operator()(const GNURadio::Knob& knob) +pmt::pmt_t rpcpmtconverter::to_pmt_string_f::operator()(const GNURadio::Knob& knob) { - return pmt::string_to_symbol(knob.value.a_string); + return pmt::string_to_symbol(knob.value.a_string); } -pmt::pmt_t -rpcpmtconverter::to_pmt_bool_f::operator()(const GNURadio::Knob& knob) +pmt::pmt_t rpcpmtconverter::to_pmt_bool_f::operator()(const GNURadio::Knob& knob) { - if(knob.value.a_bool) - return pmt::PMT_T; - else - return pmt::PMT_F; + if (knob.value.a_bool) + return pmt::PMT_T; + else + return pmt::PMT_F; } -pmt::pmt_t -rpcpmtconverter::to_pmt_complex_f::operator()(const GNURadio::Knob& knob) +pmt::pmt_t rpcpmtconverter::to_pmt_complex_f::operator()(const GNURadio::Knob& knob) { - gr_complexd cpx(knob.value.a_complex.re, knob.value.a_complex.im); - return pmt::from_complex(cpx); + gr_complexd cpx(knob.value.a_complex.re, knob.value.a_complex.im); + return pmt::from_complex(cpx); } -pmt::pmt_t -rpcpmtconverter::to_pmt_f32vect_f::operator()(const GNURadio::Knob& knob) +pmt::pmt_t rpcpmtconverter::to_pmt_f32vect_f::operator()(const GNURadio::Knob& knob) { - std::vector<double> v_double = knob.value.a_f32vector; - std::vector<float> v(v_double.begin(), v_double.end()); - return pmt::init_f32vector(v.size(), v); + std::vector<double> v_double = knob.value.a_f32vector; + std::vector<float> v(v_double.begin(), v_double.end()); + return pmt::init_f32vector(v.size(), v); } -pmt::pmt_t -rpcpmtconverter::to_pmt_f64vect_f::operator()(const GNURadio::Knob& knob) +pmt::pmt_t rpcpmtconverter::to_pmt_f64vect_f::operator()(const GNURadio::Knob& knob) { - std::vector<double> v = knob.value.a_f64vector; - return pmt::init_f64vector(v.size(), v); + std::vector<double> v = knob.value.a_f64vector; + return pmt::init_f64vector(v.size(), v); } -pmt::pmt_t -rpcpmtconverter::to_pmt_s64vect_f::operator()(const GNURadio::Knob& knob) +pmt::pmt_t rpcpmtconverter::to_pmt_s64vect_f::operator()(const GNURadio::Knob& knob) { - std::vector<int64_t> v = knob.value.a_s64vector; - return pmt::init_s64vector(v.size(), v); + std::vector<int64_t> v = knob.value.a_s64vector; + return pmt::init_s64vector(v.size(), v); } -pmt::pmt_t -rpcpmtconverter::to_pmt_s32vect_f::operator()(const GNURadio::Knob& knob) +pmt::pmt_t rpcpmtconverter::to_pmt_s32vect_f::operator()(const GNURadio::Knob& knob) { - std::vector<int32_t> v = knob.value.a_s32vector; - return pmt::init_s32vector(v.size(), v); + std::vector<int32_t> v = knob.value.a_s32vector; + return pmt::init_s32vector(v.size(), v); } -pmt::pmt_t -rpcpmtconverter::to_pmt_s16vect_f::operator()(const GNURadio::Knob& knob) +pmt::pmt_t rpcpmtconverter::to_pmt_s16vect_f::operator()(const GNURadio::Knob& knob) { - std::vector<int16_t> v = knob.value.a_s16vector; - return pmt::init_s16vector(v.size(), v); + std::vector<int16_t> v = knob.value.a_s16vector; + return pmt::init_s16vector(v.size(), v); } -pmt::pmt_t -rpcpmtconverter::to_pmt_s8vect_f::operator()(const GNURadio::Knob& knob) +pmt::pmt_t rpcpmtconverter::to_pmt_s8vect_f::operator()(const GNURadio::Knob& knob) { - std::basic_string<char> v = knob.value.a_s8vector; - return pmt::init_s8vector(v.size(), reinterpret_cast<const int8_t*>(v.data())); + std::basic_string<char> v = knob.value.a_s8vector; + return pmt::init_s8vector(v.size(), reinterpret_cast<const int8_t*>(v.data())); } -pmt::pmt_t -rpcpmtconverter::to_pmt_c32vect_f::operator()(const GNURadio::Knob& knob) +pmt::pmt_t rpcpmtconverter::to_pmt_c32vect_f::operator()(const GNURadio::Knob& knob) { - std::vector<GNURadio::complex> v0 = knob.value.a_c32vector; - std::vector<GNURadio::complex>::iterator vitr; - std::vector<gr_complex> v; - for(vitr = v0.begin(); vitr != v0.end(); vitr++) { - v.push_back(gr_complex(vitr->re, vitr->im)); - } - return pmt::init_c32vector(v.size(), v); + std::vector<GNURadio::complex> v0 = knob.value.a_c32vector; + std::vector<GNURadio::complex>::iterator vitr; + std::vector<gr_complex> v; + for (vitr = v0.begin(); vitr != v0.end(); vitr++) { + v.push_back(gr_complex(vitr->re, vitr->im)); + } + return pmt::init_c32vector(v.size(), v); } rpcpmtconverter::To_PMT rpcpmtconverter::To_PMT::instance; -rpcpmtconverter::to_pmt_reg<rpcpmtconverter::to_pmt_bool_f> reg_bool(rpcpmtconverter::To_PMT::instance, - GNURadio::BaseTypes::BOOL); -rpcpmtconverter::to_pmt_reg<rpcpmtconverter::to_pmt_byte_f> reg_byte(rpcpmtconverter::To_PMT::instance, - GNURadio::BaseTypes::BYTE); -rpcpmtconverter::to_pmt_reg<rpcpmtconverter::to_pmt_short_f> reg_short(rpcpmtconverter::To_PMT::instance, - GNURadio::BaseTypes::SHORT); -rpcpmtconverter::to_pmt_reg<rpcpmtconverter::to_pmt_int_f> reg_int(rpcpmtconverter::To_PMT::instance, - GNURadio::BaseTypes::INT); -rpcpmtconverter::to_pmt_reg<rpcpmtconverter::to_pmt_long_f> reg_long(rpcpmtconverter::To_PMT::instance, - GNURadio::BaseTypes::LONG); -rpcpmtconverter::to_pmt_reg<rpcpmtconverter::to_pmt_double_f> reg_double(rpcpmtconverter::To_PMT::instance, - GNURadio::BaseTypes::DOUBLE); -rpcpmtconverter::to_pmt_reg<rpcpmtconverter::to_pmt_string_f> reg_string(rpcpmtconverter::To_PMT::instance, - GNURadio::BaseTypes::STRING); -rpcpmtconverter::to_pmt_reg<rpcpmtconverter::to_pmt_complex_f> reg_complex(rpcpmtconverter::To_PMT::instance, - GNURadio::BaseTypes::COMPLEX); -rpcpmtconverter::to_pmt_reg<rpcpmtconverter::to_pmt_f32vect_f> reg_f32v(rpcpmtconverter::To_PMT::instance, - GNURadio::BaseTypes::F32VECTOR); -rpcpmtconverter::to_pmt_reg<rpcpmtconverter::to_pmt_f64vect_f> reg_f64v(rpcpmtconverter::To_PMT::instance, - GNURadio::BaseTypes::F64VECTOR); -rpcpmtconverter::to_pmt_reg<rpcpmtconverter::to_pmt_s64vect_f> reg_s64v(rpcpmtconverter::To_PMT::instance, - GNURadio::BaseTypes::S64VECTOR); -rpcpmtconverter::to_pmt_reg<rpcpmtconverter::to_pmt_s32vect_f> reg_s32v(rpcpmtconverter::To_PMT::instance, - GNURadio::BaseTypes::S32VECTOR); -rpcpmtconverter::to_pmt_reg<rpcpmtconverter::to_pmt_s16vect_f> reg_s16v(rpcpmtconverter::To_PMT::instance, - GNURadio::BaseTypes::S16VECTOR); -rpcpmtconverter::to_pmt_reg<rpcpmtconverter::to_pmt_s8vect_f> reg_s8v(rpcpmtconverter::To_PMT::instance, - GNURadio::BaseTypes::S8VECTOR); -rpcpmtconverter::to_pmt_reg<rpcpmtconverter::to_pmt_c32vect_f> reg_c32v(rpcpmtconverter::To_PMT::instance, - GNURadio::BaseTypes::C32VECTOR); +rpcpmtconverter::to_pmt_reg<rpcpmtconverter::to_pmt_bool_f> + reg_bool(rpcpmtconverter::To_PMT::instance, GNURadio::BaseTypes::BOOL); +rpcpmtconverter::to_pmt_reg<rpcpmtconverter::to_pmt_byte_f> + reg_byte(rpcpmtconverter::To_PMT::instance, GNURadio::BaseTypes::BYTE); +rpcpmtconverter::to_pmt_reg<rpcpmtconverter::to_pmt_short_f> + reg_short(rpcpmtconverter::To_PMT::instance, GNURadio::BaseTypes::SHORT); +rpcpmtconverter::to_pmt_reg<rpcpmtconverter::to_pmt_int_f> + reg_int(rpcpmtconverter::To_PMT::instance, GNURadio::BaseTypes::INT); +rpcpmtconverter::to_pmt_reg<rpcpmtconverter::to_pmt_long_f> + reg_long(rpcpmtconverter::To_PMT::instance, GNURadio::BaseTypes::LONG); +rpcpmtconverter::to_pmt_reg<rpcpmtconverter::to_pmt_double_f> + reg_double(rpcpmtconverter::To_PMT::instance, GNURadio::BaseTypes::DOUBLE); +rpcpmtconverter::to_pmt_reg<rpcpmtconverter::to_pmt_string_f> + reg_string(rpcpmtconverter::To_PMT::instance, GNURadio::BaseTypes::STRING); +rpcpmtconverter::to_pmt_reg<rpcpmtconverter::to_pmt_complex_f> + reg_complex(rpcpmtconverter::To_PMT::instance, GNURadio::BaseTypes::COMPLEX); +rpcpmtconverter::to_pmt_reg<rpcpmtconverter::to_pmt_f32vect_f> + reg_f32v(rpcpmtconverter::To_PMT::instance, GNURadio::BaseTypes::F32VECTOR); +rpcpmtconverter::to_pmt_reg<rpcpmtconverter::to_pmt_f64vect_f> + reg_f64v(rpcpmtconverter::To_PMT::instance, GNURadio::BaseTypes::F64VECTOR); +rpcpmtconverter::to_pmt_reg<rpcpmtconverter::to_pmt_s64vect_f> + reg_s64v(rpcpmtconverter::To_PMT::instance, GNURadio::BaseTypes::S64VECTOR); +rpcpmtconverter::to_pmt_reg<rpcpmtconverter::to_pmt_s32vect_f> + reg_s32v(rpcpmtconverter::To_PMT::instance, GNURadio::BaseTypes::S32VECTOR); +rpcpmtconverter::to_pmt_reg<rpcpmtconverter::to_pmt_s16vect_f> + reg_s16v(rpcpmtconverter::To_PMT::instance, GNURadio::BaseTypes::S16VECTOR); +rpcpmtconverter::to_pmt_reg<rpcpmtconverter::to_pmt_s8vect_f> + reg_s8v(rpcpmtconverter::To_PMT::instance, GNURadio::BaseTypes::S8VECTOR); +rpcpmtconverter::to_pmt_reg<rpcpmtconverter::to_pmt_c32vect_f> + reg_c32v(rpcpmtconverter::To_PMT::instance, GNURadio::BaseTypes::C32VECTOR); -template<typename TO_PMT_F> +template <typename TO_PMT_F> rpcpmtconverter::to_pmt_reg<TO_PMT_F>::to_pmt_reg(To_PMT& instance, const GNURadio::BaseTypes::type type) { - boost::assign::ptr_map_insert<TO_PMT_F>(instance.to_pmt_map)(type); + boost::assign::ptr_map_insert<TO_PMT_F>(instance.to_pmt_map)(type); } -pmt::pmt_t -rpcpmtconverter::to_pmt_f::operator()(const GNURadio::Knob& knob) +pmt::pmt_t rpcpmtconverter::to_pmt_f::operator()(const GNURadio::Knob& knob) { - std::cerr << "Error: Don't know how to handle Knob Type: " << knob.type << std::endl; - assert(0); - return pmt::pmt_t(); + std::cerr << "Error: Don't know how to handle Knob Type: " << knob.type << std::endl; + assert(0); + return pmt::pmt_t(); } -pmt::pmt_t -rpcpmtconverter::To_PMT::operator()(const GNURadio::Knob& knob) +pmt::pmt_t rpcpmtconverter::To_PMT::operator()(const GNURadio::Knob& knob) { - return to_pmt_map[knob.type](knob); + return to_pmt_map[knob.type](knob); } diff --git a/gnuradio-runtime/lib/controlport/thrift/rpcserver_booter_thrift.cc b/gnuradio-runtime/lib/controlport/thrift/rpcserver_booter_thrift.cc index 1d6cafe0c0..a5017cd17a 100644 --- a/gnuradio-runtime/lib/controlport/thrift/rpcserver_booter_thrift.cc +++ b/gnuradio-runtime/lib/controlport/thrift/rpcserver_booter_thrift.cc @@ -26,108 +26,120 @@ #include <boost/asio/ip/host_name.hpp> namespace { - static const char* const CONTROL_PORT_CLASS("thrift"); - static const unsigned int ETHERNET_HEADER_SIZE(14); - static const unsigned int IP_HEADER_SIZE(20); - static const unsigned int TCP_HEADER_SIZE(32); - static const unsigned int ETHERNET_TYPICAL_MTU(1500); - static const unsigned int ALRIGHT_DEFAULT_BUFFER_SIZE( - ETHERNET_TYPICAL_MTU - ETHERNET_HEADER_SIZE - IP_HEADER_SIZE - TCP_HEADER_SIZE); -}; +static const char* const CONTROL_PORT_CLASS("thrift"); +static const unsigned int ETHERNET_HEADER_SIZE(14); +static const unsigned int IP_HEADER_SIZE(20); +static const unsigned int TCP_HEADER_SIZE(32); +static const unsigned int ETHERNET_TYPICAL_MTU(1500); +static const unsigned int ALRIGHT_DEFAULT_BUFFER_SIZE(ETHERNET_TYPICAL_MTU - + ETHERNET_HEADER_SIZE - + IP_HEADER_SIZE - TCP_HEADER_SIZE); +}; // namespace /*! * \brief A booter implementation for a Thrift application class. */ -rpcserver_booter_thrift::rpcserver_booter_thrift() : - thrift_server_template<rpcserver_base, - rpcserver_thrift, - rpcserver_booter_thrift>(this), - d_type(std::string(CONTROL_PORT_CLASS)) -{;} +rpcserver_booter_thrift::rpcserver_booter_thrift() + : thrift_server_template<rpcserver_base, rpcserver_thrift, rpcserver_booter_thrift>( + this), + d_type(std::string(CONTROL_PORT_CLASS)) +{ + ; +} -rpcserver_booter_thrift::~rpcserver_booter_thrift() -{;} +rpcserver_booter_thrift::~rpcserver_booter_thrift() { ; } -rpcserver_base* -rpcserver_booter_thrift::i() +rpcserver_base* rpcserver_booter_thrift::i() { - return thrift_server_template<rpcserver_base, rpcserver_thrift, - rpcserver_booter_thrift>::i(); + return thrift_server_template<rpcserver_base, + rpcserver_thrift, + rpcserver_booter_thrift>::i(); } /*! * \brief Returns the endpoint string for the application */ -const std::vector<std::string> -rpcserver_booter_thrift::endpoints() +const std::vector<std::string> rpcserver_booter_thrift::endpoints() { - return thrift_server_template<rpcserver_base, rpcserver_thrift, - rpcserver_booter_thrift>::endpoints(); + return thrift_server_template<rpcserver_base, + rpcserver_thrift, + rpcserver_booter_thrift>::endpoints(); } // Specialized thrift_application_base attributes and functions // for this rpcserver_booter instance. -template<class rpcserver_base, class rpcserver_booter_thrift> -const unsigned int thrift_application_base<rpcserver_base, rpcserver_booter_thrift>::d_default_max_init_attempts(100U); +template <class rpcserver_base, class rpcserver_booter_thrift> +const unsigned int + thrift_application_base<rpcserver_base, + rpcserver_booter_thrift>::d_default_max_init_attempts(100U); -template<class rpcserver_base, class rpcserver_booter_thrift> -const unsigned int thrift_application_base<rpcserver_base, rpcserver_booter_thrift>::d_default_thrift_port(0U); +template <class rpcserver_base, class rpcserver_booter_thrift> +const unsigned int + thrift_application_base<rpcserver_base, + rpcserver_booter_thrift>::d_default_thrift_port(0U); -template<class rpcserver_base, class rpcserver_booter_thrift> -const unsigned int thrift_application_base<rpcserver_base, rpcserver_booter_thrift>::d_default_num_thrift_threads(10U); +template <class rpcserver_base, class rpcserver_booter_thrift> +const unsigned int + thrift_application_base<rpcserver_base, + rpcserver_booter_thrift>::d_default_num_thrift_threads(10U); -template<class rpcserver_base, class rpcserver_booter_thrift> -const unsigned int thrift_application_base<rpcserver_base, rpcserver_booter_thrift>::d_default_thrift_buffer_size( - ALRIGHT_DEFAULT_BUFFER_SIZE); +template <class rpcserver_base, class rpcserver_booter_thrift> +const unsigned int thrift_application_base<rpcserver_base, rpcserver_booter_thrift>:: + d_default_thrift_buffer_size(ALRIGHT_DEFAULT_BUFFER_SIZE); -template<class rpcserver_base, class rpcserver_booter_thrift> +template <class rpcserver_base, class rpcserver_booter_thrift> boost::scoped_ptr<thrift_application_base_impl> - thrift_application_base<rpcserver_base, rpcserver_booter_thrift>::p_impl( - new thrift_application_base_impl()); + thrift_application_base<rpcserver_base, rpcserver_booter_thrift>::p_impl( + new thrift_application_base_impl()); -template<class rpcserver_base, class rpcserver_booter_thrift> -thrift_application_base<rpcserver_base, rpcserver_booter_thrift>::~thrift_application_base() +template <class rpcserver_base, class rpcserver_booter_thrift> +thrift_application_base<rpcserver_base, + rpcserver_booter_thrift>::~thrift_application_base() { - if(d_thirft_is_running) { - d_thriftserver->stop(); - d_thirft_is_running = false; - } + if (d_thirft_is_running) { + d_thriftserver->stop(); + d_thirft_is_running = false; + } } -template<class rpcserver_base, class rpcserver_booter_thrift> +template <class rpcserver_base, class rpcserver_booter_thrift> void thrift_application_base<rpcserver_base, rpcserver_booter_thrift>::start_thrift() { - d_thriftserver->serve(); + d_thriftserver->serve(); } -template<class rpcserver_base, typename rpcserver_booter_thrift> -bool thrift_application_base<rpcserver_base, rpcserver_booter_thrift>::application_started() +template <class rpcserver_base, typename rpcserver_booter_thrift> +bool thrift_application_base<rpcserver_base, + rpcserver_booter_thrift>::application_started() { - if (d_thirft_is_running) return true; + if (d_thirft_is_running) + return true; - bool result(false); - // Define the endpoint. - apache::thrift::transport::TServerTransport *thetransport = - d_thriftserver->getServerTransport().get(); + bool result(false); + // Define the endpoint. + apache::thrift::transport::TServerTransport* thetransport = + d_thriftserver->getServerTransport().get(); - // Determine the specified endpoint port number, or the port number selected by bind() if - int used_port = ((apache::thrift::transport::TServerSocket*)thetransport)->getPort(); + // Determine the specified endpoint port number, or the port number selected by bind() + // if + int used_port = ((apache::thrift::transport::TServerSocket*)thetransport)->getPort(); - if (used_port > 0) { - // Determine the hostname of this host - const std::string boost_hostname(boost::asio::ip::host_name()); + if (used_port > 0) { + // Determine the hostname of this host + const std::string boost_hostname(boost::asio::ip::host_name()); - std::string endpoint = boost::str(boost::format("-h %1% -p %2%") % boost_hostname % used_port); + std::string endpoint = + boost::str(boost::format("-h %1% -p %2%") % boost_hostname % used_port); - set_endpoint(endpoint); + set_endpoint(endpoint); - GR_LOG_INFO(d_logger, "Apache Thrift: " + endpoint); - d_thirft_is_running = true; - result = true; - } + GR_LOG_INFO(d_logger, "Apache Thrift: " + endpoint); + d_thirft_is_running = true; + result = true; + } - return result; + return result; } diff --git a/gnuradio-runtime/lib/controlport/thrift/rpcserver_thrift.cc b/gnuradio-runtime/lib/controlport/thrift/rpcserver_thrift.cc index 6b912bbfae..180bb85f3d 100644 --- a/gnuradio-runtime/lib/controlport/thrift/rpcserver_thrift.cc +++ b/gnuradio-runtime/lib/controlport/thrift/rpcserver_thrift.cc @@ -37,239 +37,239 @@ using namespace rpcpmtconverter; rpcserver_thrift::rpcserver_thrift() { - //std::cerr << "rpcserver_thrift::ctor" << std::endl; + // std::cerr << "rpcserver_thrift::ctor" << std::endl; } rpcserver_thrift::~rpcserver_thrift() { - //std::cerr << "rpcserver_thrift::dtor" << std::endl; + // std::cerr << "rpcserver_thrift::dtor" << std::endl; } -void -rpcserver_thrift::registerConfigureCallback(const std::string &id, - const configureCallback_t callback) +void rpcserver_thrift::registerConfigureCallback(const std::string& id, + const configureCallback_t callback) { - boost::mutex::scoped_lock lock(d_callback_map_lock); - { - ConfigureCallbackMap_t::const_iterator iter(d_setcallbackmap.find(id)); - if(iter != d_setcallbackmap.end()) { - std::stringstream s; - s << "rpcserver_thrift:: rpcserver_thrift ERROR registering set, already registered: " - << id << std::endl; - throw std::runtime_error(s.str().c_str()); + boost::mutex::scoped_lock lock(d_callback_map_lock); + { + ConfigureCallbackMap_t::const_iterator iter(d_setcallbackmap.find(id)); + if (iter != d_setcallbackmap.end()) { + std::stringstream s; + s << "rpcserver_thrift:: rpcserver_thrift ERROR registering set, already " + "registered: " + << id << std::endl; + throw std::runtime_error(s.str().c_str()); + } } - } - if(DEBUG) { - std::cerr << "rpcserver_thrift registering set: " << id << std::endl; - } - d_setcallbackmap.insert(ConfigureCallbackMap_t::value_type(id, callback)); + if (DEBUG) { + std::cerr << "rpcserver_thrift registering set: " << id << std::endl; + } + d_setcallbackmap.insert(ConfigureCallbackMap_t::value_type(id, callback)); } -void -rpcserver_thrift::unregisterConfigureCallback(const std::string &id) +void rpcserver_thrift::unregisterConfigureCallback(const std::string& id) { - boost::mutex::scoped_lock lock(d_callback_map_lock); - ConfigureCallbackMap_t::iterator iter(d_setcallbackmap.find(id)); - if(iter == d_setcallbackmap.end()) { - std::stringstream s; - s << "rpcserver_thrift:: rpcserver_thrift ERROR unregistering set, not registered: " - << id << std::endl; - throw std::runtime_error(s.str().c_str()); - } - - if(DEBUG) - std::cerr << "rpcserver_thrift unregistering set: " << id << std::endl; - - d_setcallbackmap.erase(iter); + boost::mutex::scoped_lock lock(d_callback_map_lock); + ConfigureCallbackMap_t::iterator iter(d_setcallbackmap.find(id)); + if (iter == d_setcallbackmap.end()) { + std::stringstream s; + s << "rpcserver_thrift:: rpcserver_thrift ERROR unregistering set, not " + "registered: " + << id << std::endl; + throw std::runtime_error(s.str().c_str()); + } + + if (DEBUG) + std::cerr << "rpcserver_thrift unregistering set: " << id << std::endl; + + d_setcallbackmap.erase(iter); } -void -rpcserver_thrift::registerQueryCallback(const std::string &id, - const queryCallback_t callback) +void rpcserver_thrift::registerQueryCallback(const std::string& id, + const queryCallback_t callback) { - boost::mutex::scoped_lock lock(d_callback_map_lock); - { - QueryCallbackMap_t::const_iterator iter(d_getcallbackmap.find(id)); - if(iter != d_getcallbackmap.end()) { - std::stringstream s; - s << "rpcserver_thrift:: rpcserver_thrift ERROR registering get, already registered: " - << id << std::endl; - throw std::runtime_error(s.str().c_str()); + boost::mutex::scoped_lock lock(d_callback_map_lock); + { + QueryCallbackMap_t::const_iterator iter(d_getcallbackmap.find(id)); + if (iter != d_getcallbackmap.end()) { + std::stringstream s; + s << "rpcserver_thrift:: rpcserver_thrift ERROR registering get, already " + "registered: " + << id << std::endl; + throw std::runtime_error(s.str().c_str()); + } } - } - if(DEBUG) { - std::cerr << "rpcserver_thrift registering get: " << id << std::endl; - } - d_getcallbackmap.insert(QueryCallbackMap_t::value_type(id, callback)); + if (DEBUG) { + std::cerr << "rpcserver_thrift registering get: " << id << std::endl; + } + d_getcallbackmap.insert(QueryCallbackMap_t::value_type(id, callback)); } -void -rpcserver_thrift::unregisterQueryCallback(const std::string &id) +void rpcserver_thrift::unregisterQueryCallback(const std::string& id) { - boost::mutex::scoped_lock lock(d_callback_map_lock); - QueryCallbackMap_t::iterator iter(d_getcallbackmap.find(id)); - if(iter == d_getcallbackmap.end()) { - std::stringstream s; - s << "rpcserver_thrift:: rpcserver_thrift ERROR unregistering get, registered: " - << id << std::endl; - throw std::runtime_error(s.str().c_str()); - } - - if(DEBUG) { - std::cerr << "rpcserver_thrift unregistering get: " << id << std::endl; - } - - d_getcallbackmap.erase(iter); -} + boost::mutex::scoped_lock lock(d_callback_map_lock); + QueryCallbackMap_t::iterator iter(d_getcallbackmap.find(id)); + if (iter == d_getcallbackmap.end()) { + std::stringstream s; + s << "rpcserver_thrift:: rpcserver_thrift ERROR unregistering get, registered: " + << id << std::endl; + throw std::runtime_error(s.str().c_str()); + } + + if (DEBUG) { + std::cerr << "rpcserver_thrift unregistering get: " << id << std::endl; + } + d_getcallbackmap.erase(iter); +} -void -rpcserver_thrift::registerHandlerCallback(const std::string &id, - const handlerCallback_t callback) +void rpcserver_thrift::registerHandlerCallback(const std::string& id, + const handlerCallback_t callback) { - boost::mutex::scoped_lock lock(d_callback_map_lock); - { - HandlerCallbackMap_t::const_iterator iter(d_handlercallbackmap.find(id)); - if(iter != d_handlercallbackmap.end()) { - std::stringstream s; - s << "rpcserver_thrift:: rpcserver_thrift ERROR registering handler, already registered: " - << id << std::endl; - throw std::runtime_error(s.str().c_str()); + boost::mutex::scoped_lock lock(d_callback_map_lock); + { + HandlerCallbackMap_t::const_iterator iter(d_handlercallbackmap.find(id)); + if (iter != d_handlercallbackmap.end()) { + std::stringstream s; + s << "rpcserver_thrift:: rpcserver_thrift ERROR registering handler, already " + "registered: " + << id << std::endl; + throw std::runtime_error(s.str().c_str()); + } } - } - if(DEBUG) { - std::cerr << "rpcserver_thrift registering handler: " << id << std::endl; - } - d_handlercallbackmap.insert(HandlerCallbackMap_t::value_type(id, callback)); + if (DEBUG) { + std::cerr << "rpcserver_thrift registering handler: " << id << std::endl; + } + d_handlercallbackmap.insert(HandlerCallbackMap_t::value_type(id, callback)); } -void -rpcserver_thrift::unregisterHandlerCallback(const std::string &id) +void rpcserver_thrift::unregisterHandlerCallback(const std::string& id) { - boost::mutex::scoped_lock lock(d_callback_map_lock); - HandlerCallbackMap_t::iterator iter(d_handlercallbackmap.find(id)); - if(iter == d_handlercallbackmap.end()) { - std::stringstream s; - s << "rpcserver_thrift:: rpcserver_thrift ERROR unregistering handler, registered: " - << id << std::endl; - throw std::runtime_error(s.str().c_str()); - } - - if(DEBUG) { - std::cerr << "rpcserver_thrift unregistering handler: " << id << std::endl; - } - - d_handlercallbackmap.erase(iter); -} + boost::mutex::scoped_lock lock(d_callback_map_lock); + HandlerCallbackMap_t::iterator iter(d_handlercallbackmap.find(id)); + if (iter == d_handlercallbackmap.end()) { + std::stringstream s; + s << "rpcserver_thrift:: rpcserver_thrift ERROR unregistering handler, " + "registered: " + << id << std::endl; + throw std::runtime_error(s.str().c_str()); + } + if (DEBUG) { + std::cerr << "rpcserver_thrift unregistering handler: " << id << std::endl; + } + d_handlercallbackmap.erase(iter); +} -void -rpcserver_thrift::setKnobs(const GNURadio::KnobMap& knobs) +void rpcserver_thrift::setKnobs(const GNURadio::KnobMap& knobs) { - boost::mutex::scoped_lock lock(d_callback_map_lock); - std::for_each(knobs.begin(), knobs.end(), - set_f<GNURadio::KnobMap::value_type,ConfigureCallbackMap_t> - (d_setcallbackmap, cur_priv)); + boost::mutex::scoped_lock lock(d_callback_map_lock); + std::for_each(knobs.begin(), + knobs.end(), + set_f<GNURadio::KnobMap::value_type, ConfigureCallbackMap_t>( + d_setcallbackmap, cur_priv)); } -void -rpcserver_thrift::getKnobs(GNURadio::KnobMap& _return, - const GNURadio::KnobIDList& knobs) +void rpcserver_thrift::getKnobs(GNURadio::KnobMap& _return, + const GNURadio::KnobIDList& knobs) { - boost::mutex::scoped_lock lock(d_callback_map_lock); - if(knobs.size() == 0) { - std::for_each(d_getcallbackmap.begin(), d_getcallbackmap.end(), - get_all_f<QueryCallbackMap_t::value_type, QueryCallbackMap_t, GNURadio::KnobMap> - (d_getcallbackmap, cur_priv, _return)); - } - else { - std::for_each(knobs.begin(), knobs.end(), - get_f<GNURadio::KnobIDList::value_type, QueryCallbackMap_t> - (d_getcallbackmap, cur_priv, _return)); - } + boost::mutex::scoped_lock lock(d_callback_map_lock); + if (knobs.size() == 0) { + std::for_each(d_getcallbackmap.begin(), + d_getcallbackmap.end(), + get_all_f<QueryCallbackMap_t::value_type, + QueryCallbackMap_t, + GNURadio::KnobMap>(d_getcallbackmap, cur_priv, _return)); + } else { + std::for_each(knobs.begin(), + knobs.end(), + get_f<GNURadio::KnobIDList::value_type, QueryCallbackMap_t>( + d_getcallbackmap, cur_priv, _return)); + } } -void -rpcserver_thrift::getRe(GNURadio::KnobMap& _return, const GNURadio::KnobIDList& knobs) +void rpcserver_thrift::getRe(GNURadio::KnobMap& _return, + const GNURadio::KnobIDList& knobs) { - boost::mutex::scoped_lock lock(d_callback_map_lock); - if(knobs.size() == 0) { - std::for_each(d_getcallbackmap.begin(), d_getcallbackmap.end(), - get_all_f<QueryCallbackMap_t::value_type, QueryCallbackMap_t, GNURadio::KnobMap> - (d_getcallbackmap, cur_priv, _return)); - } - else { - QueryCallbackMap_t::iterator it; - for(it = d_getcallbackmap.begin(); it != d_getcallbackmap.end(); it++){ - for(size_t j=0; j<knobs.size(); j++) { - const boost::xpressive::sregex re(boost::xpressive::sregex::compile(knobs[j])); - if(boost::xpressive::regex_match(it->first, re)) { - get_f<GNURadio::KnobIDList::value_type, QueryCallbackMap_t> - (d_getcallbackmap, cur_priv, _return)(it->first); - break; + boost::mutex::scoped_lock lock(d_callback_map_lock); + if (knobs.size() == 0) { + std::for_each(d_getcallbackmap.begin(), + d_getcallbackmap.end(), + get_all_f<QueryCallbackMap_t::value_type, + QueryCallbackMap_t, + GNURadio::KnobMap>(d_getcallbackmap, cur_priv, _return)); + } else { + QueryCallbackMap_t::iterator it; + for (it = d_getcallbackmap.begin(); it != d_getcallbackmap.end(); it++) { + for (size_t j = 0; j < knobs.size(); j++) { + const boost::xpressive::sregex re( + boost::xpressive::sregex::compile(knobs[j])); + if (boost::xpressive::regex_match(it->first, re)) { + get_f<GNURadio::KnobIDList::value_type, QueryCallbackMap_t>( + d_getcallbackmap, cur_priv, _return)(it->first); + break; + } + } } - } } - } } -void -rpcserver_thrift::properties(GNURadio::KnobPropMap& _return, - const GNURadio::KnobIDList& knobs) +void rpcserver_thrift::properties(GNURadio::KnobPropMap& _return, + const GNURadio::KnobIDList& knobs) { - boost::mutex::scoped_lock lock(d_callback_map_lock); - if(knobs.size() == 0) { - std::for_each(d_getcallbackmap.begin(), d_getcallbackmap.end(), - properties_all_f<QueryCallbackMap_t::value_type, - QueryCallbackMap_t, GNURadio::KnobPropMap>(d_getcallbackmap, - cur_priv, _return)); - } - else { - std::for_each(knobs.begin(), knobs.end(), - properties_f<GNURadio::KnobIDList::value_type, - QueryCallbackMap_t, GNURadio::KnobPropMap>(d_getcallbackmap, - cur_priv, _return)); - } + boost::mutex::scoped_lock lock(d_callback_map_lock); + if (knobs.size() == 0) { + std::for_each( + d_getcallbackmap.begin(), + d_getcallbackmap.end(), + properties_all_f<QueryCallbackMap_t::value_type, + QueryCallbackMap_t, + GNURadio::KnobPropMap>(d_getcallbackmap, cur_priv, _return)); + } else { + std::for_each( + knobs.begin(), + knobs.end(), + properties_f<GNURadio::KnobIDList::value_type, + QueryCallbackMap_t, + GNURadio::KnobPropMap>(d_getcallbackmap, cur_priv, _return)); + } } -void -rpcserver_thrift::postMessage(const std::string& alias, - const std::string& port, - const std::string& msg) +void rpcserver_thrift::postMessage(const std::string& alias, + const std::string& port, + const std::string& msg) { - // alias and port are received as serialized PMT strings and need to - // be deserialized into PMTs and then the actual info from there. - // The actual message (msg) is also received as a serialized PMT. We - // just need to get the PMT itself out of this to pass to the set_h - // function for handling the message post. - - boost::mutex::scoped_lock lock(d_callback_map_lock); - - pmt::pmt_t alias_pmt = pmt::deserialize_str(alias); - pmt::pmt_t port_pmt = pmt::deserialize_str(port); - pmt::pmt_t msg_pmt = pmt::deserialize_str(msg); - std::string alias_str = pmt::symbol_to_string(alias_pmt); - std::string port_str = pmt::symbol_to_string(port_pmt); - std::string iface = alias_str + "::" + port_str; - - HandlerCallbackMap_t::iterator itr = d_handlercallbackmap.begin(); - for(; itr != d_handlercallbackmap.end(); itr++) { - if(iface == (*itr).first) { - set_h((*itr).second, cur_priv, port_pmt, msg_pmt); + // alias and port are received as serialized PMT strings and need to + // be deserialized into PMTs and then the actual info from there. + // The actual message (msg) is also received as a serialized PMT. We + // just need to get the PMT itself out of this to pass to the set_h + // function for handling the message post. + + boost::mutex::scoped_lock lock(d_callback_map_lock); + + pmt::pmt_t alias_pmt = pmt::deserialize_str(alias); + pmt::pmt_t port_pmt = pmt::deserialize_str(port); + pmt::pmt_t msg_pmt = pmt::deserialize_str(msg); + std::string alias_str = pmt::symbol_to_string(alias_pmt); + std::string port_str = pmt::symbol_to_string(port_pmt); + std::string iface = alias_str + "::" + port_str; + + HandlerCallbackMap_t::iterator itr = d_handlercallbackmap.begin(); + for (; itr != d_handlercallbackmap.end(); itr++) { + if (iface == (*itr).first) { + set_h((*itr).second, cur_priv, port_pmt, msg_pmt); + } } - } } -void -rpcserver_thrift::shutdown() { - if (DEBUG) { - std::cerr << "Shutting down..." << std::endl; - } +void rpcserver_thrift::shutdown() +{ + if (DEBUG) { + std::cerr << "Shutting down..." << std::endl; + } } diff --git a/gnuradio-runtime/lib/feval.cc b/gnuradio-runtime/lib/feval.cc index 93976c8ac7..2da3ffc58b 100644 --- a/gnuradio-runtime/lib/feval.cc +++ b/gnuradio-runtime/lib/feval.cc @@ -28,109 +28,59 @@ namespace gr { - feval_dd::~feval_dd(){} +feval_dd::~feval_dd() {} - double - feval_dd::eval(double x) - { - return 0; - } +double feval_dd::eval(double x) { return 0; } - double - feval_dd::calleval(double x) - { - return eval(x); - } +double feval_dd::calleval(double x) { return eval(x); } - // ---------------------------------------------------------------- +// ---------------------------------------------------------------- - feval_cc::~feval_cc(){} +feval_cc::~feval_cc() {} - gr_complex - feval_cc::eval(gr_complex x) - { - return 0; - } +gr_complex feval_cc::eval(gr_complex x) { return 0; } - gr_complex - feval_cc::calleval(gr_complex x) - { - return eval(x); - } +gr_complex feval_cc::calleval(gr_complex x) { return eval(x); } - // ---------------------------------------------------------------- +// ---------------------------------------------------------------- - feval_ll::~feval_ll(){} +feval_ll::~feval_ll() {} - long - feval_ll::eval(long x) - { - return 0; - } +long feval_ll::eval(long x) { return 0; } - long - feval_ll::calleval(long x) - { - return eval(x); - } +long feval_ll::calleval(long x) { return eval(x); } - // ---------------------------------------------------------------- +// ---------------------------------------------------------------- - feval::~feval(){} +feval::~feval() {} - void - feval::eval(void) - { +void feval::eval(void) +{ // nop - } +} - void - feval::calleval(void) - { - eval(); - } +void feval::calleval(void) { eval(); } - // ---------------------------------------------------------------- +// ---------------------------------------------------------------- - feval_p::~feval_p(){} +feval_p::~feval_p() {} - void - feval_p::eval(pmt::pmt_t x) - { +void feval_p::eval(pmt::pmt_t x) +{ // nop - } - - void - feval_p::calleval(pmt::pmt_t x) - { - eval(x); - } - - /* - * Trivial examples showing C++ (transparently) calling Python - */ - double - feval_dd_example(feval_dd *f, double x) - { - return f->calleval(x); - } - - gr_complex - feval_cc_example(feval_cc *f, gr_complex x) - { - return f->calleval(x); - } - - long - feval_ll_example(feval_ll *f, long x) - { - return f->calleval(x); - } - - void - feval_example(feval *f) - { - f->calleval(); - } +} + +void feval_p::calleval(pmt::pmt_t x) { eval(x); } + +/* + * Trivial examples showing C++ (transparently) calling Python + */ +double feval_dd_example(feval_dd* f, double x) { return f->calleval(x); } + +gr_complex feval_cc_example(feval_cc* f, gr_complex x) { return f->calleval(x); } + +long feval_ll_example(feval_ll* f, long x) { return f->calleval(x); } + +void feval_example(feval* f) { f->calleval(); } } /* namespace gr */ diff --git a/gnuradio-runtime/lib/flat_flowgraph.cc b/gnuradio-runtime/lib/flat_flowgraph.cc index c83ab20769..b798e4812e 100644 --- a/gnuradio-runtime/lib/flat_flowgraph.cc +++ b/gnuradio-runtime/lib/flat_flowgraph.cc @@ -37,93 +37,93 @@ namespace gr { // 32Kbyte buffer size between blocks -#define GR_FIXED_BUFFER_SIZE (32*(1L<<10)) +#define GR_FIXED_BUFFER_SIZE (32 * (1L << 10)) - static const unsigned int s_fixed_buffer_size = GR_FIXED_BUFFER_SIZE; +static const unsigned int s_fixed_buffer_size = GR_FIXED_BUFFER_SIZE; - flat_flowgraph_sptr - make_flat_flowgraph() - { +flat_flowgraph_sptr make_flat_flowgraph() +{ return flat_flowgraph_sptr(new flat_flowgraph()); - } +} - flat_flowgraph::flat_flowgraph() - { +flat_flowgraph::flat_flowgraph() +{ configure_default_loggers(d_logger, d_debug_logger, "flat_flowgraph"); - } +} - flat_flowgraph::~flat_flowgraph() - { - } +flat_flowgraph::~flat_flowgraph() {} - void - flat_flowgraph::setup_connections() - { +void flat_flowgraph::setup_connections() +{ basic_block_vector_t blocks = calc_used_blocks(); // Assign block details to blocks - for(basic_block_viter_t p = blocks.begin(); p != blocks.end(); p++) - cast_to_block_sptr(*p)->set_detail(allocate_block_detail(*p)); + for (basic_block_viter_t p = blocks.begin(); p != blocks.end(); p++) + cast_to_block_sptr(*p)->set_detail(allocate_block_detail(*p)); // Connect inputs to outputs for each block - for(basic_block_viter_t p = blocks.begin(); p != blocks.end(); p++) { - connect_block_inputs(*p); + for (basic_block_viter_t p = blocks.begin(); p != blocks.end(); p++) { + connect_block_inputs(*p); - block_sptr block = cast_to_block_sptr(*p); - block->set_unaligned(0); - block->set_is_unaligned(false); + block_sptr block = cast_to_block_sptr(*p); + block->set_unaligned(0); + block->set_is_unaligned(false); } // Connect message ports connetions - for(msg_edge_viter_t i = d_msg_edges.begin(); i != d_msg_edges.end(); i++) { - GR_LOG_DEBUG(d_debug_logger, - boost::format("flat_fg connecting msg primitives: (%s, %s)->(%s, %s)\n") % - i->src().block() % i->src().port() % - i->dst().block() % i->dst().port() - ); - i->src().block()->message_port_sub(i->src().port(), pmt::cons(i->dst().block()->alias_pmt(), i->dst().port())); + for (msg_edge_viter_t i = d_msg_edges.begin(); i != d_msg_edges.end(); i++) { + GR_LOG_DEBUG( + d_debug_logger, + boost::format("flat_fg connecting msg primitives: (%s, %s)->(%s, %s)\n") % + i->src().block() % i->src().port() % i->dst().block() % i->dst().port()); + i->src().block()->message_port_sub( + i->src().port(), pmt::cons(i->dst().block()->alias_pmt(), i->dst().port())); } - } +} - block_detail_sptr - flat_flowgraph::allocate_block_detail(basic_block_sptr block) - { +block_detail_sptr flat_flowgraph::allocate_block_detail(basic_block_sptr block) +{ int ninputs = calc_used_ports(block, true).size(); int noutputs = calc_used_ports(block, false).size(); block_detail_sptr detail = make_block_detail(ninputs, noutputs); block_sptr grblock = cast_to_block_sptr(block); - if(!grblock) - throw std::runtime_error( - (boost::format("allocate_block_detail found non-gr::block (%s)")% - block->alias()).str()); + if (!grblock) + throw std::runtime_error( + (boost::format("allocate_block_detail found non-gr::block (%s)") % + block->alias()) + .str()); GR_LOG_DEBUG(d_debug_logger, "Creating block detail for " + block->identifier()); - for(int i = 0; i < noutputs; i++) { - grblock->expand_minmax_buffer(i); - - buffer_sptr buffer = allocate_buffer(block, i); - GR_LOG_DEBUG(d_debug_logger, "Allocated buffer for output " + block->identifier() + " " + std::to_string(i)); - detail->set_output(i, buffer); + for (int i = 0; i < noutputs; i++) { + grblock->expand_minmax_buffer(i); - // Update the block's max_output_buffer based on what was actually allocated. - if((grblock->max_output_buffer(i) != buffer->bufsize()) && (grblock->max_output_buffer(i) != -1)) - GR_LOG_WARN(d_logger, boost::format("Block (%1%) max output buffer set to %2%" - " instead of requested %3%") \ - % grblock->alias() % buffer->bufsize() % grblock->max_output_buffer(i)); - grblock->set_max_output_buffer(i, buffer->bufsize()); + buffer_sptr buffer = allocate_buffer(block, i); + GR_LOG_DEBUG(d_debug_logger, + "Allocated buffer for output " + block->identifier() + " " + + std::to_string(i)); + detail->set_output(i, buffer); + + // Update the block's max_output_buffer based on what was actually allocated. + if ((grblock->max_output_buffer(i) != buffer->bufsize()) && + (grblock->max_output_buffer(i) != -1)) + GR_LOG_WARN(d_logger, + boost::format("Block (%1%) max output buffer set to %2%" + " instead of requested %3%") % + grblock->alias() % buffer->bufsize() % + grblock->max_output_buffer(i)); + grblock->set_max_output_buffer(i, buffer->bufsize()); } return detail; - } +} - buffer_sptr - flat_flowgraph::allocate_buffer(basic_block_sptr block, int port) - { +buffer_sptr flat_flowgraph::allocate_buffer(basic_block_sptr block, int port) +{ block_sptr grblock = cast_to_block_sptr(block); - if(!grblock) - throw std::runtime_error("allocate_buffer found non-gr::block"); + if (!grblock) + throw std::runtime_error("allocate_buffer found non-gr::block"); int item_size = block->output_signature()->sizeof_stream_item(port); // *2 because we're now only filling them 1/2 way in order to @@ -132,112 +132,120 @@ namespace gr { int nitems = s_fixed_buffer_size * 2 / item_size; // Make sure there are at least twice the output_multiple no. of items - if(nitems < 2*grblock->output_multiple()) // Note: this means output_multiple() - nitems = 2*grblock->output_multiple(); // can't be changed by block dynamically + if (nitems < 2 * grblock->output_multiple()) // Note: this means output_multiple() + nitems = 2 * grblock->output_multiple(); // can't be changed by block dynamically // If any downstream blocks are decimators and/or have a large output_multiple, // ensure we have a buffer at least twice their decimation factor*output_multiple basic_block_vector_t blocks = calc_downstream_blocks(block, port); // limit buffer size if indicated - if(grblock->max_output_buffer(port) > 0) { - //std::cout << "constraining output items to " << block->max_output_buffer(port) << "\n"; - nitems = std::min((long)nitems, (long)grblock->max_output_buffer(port)); - nitems -= nitems%grblock->output_multiple(); - if(nitems < 1) - throw std::runtime_error("problems allocating a buffer with the given max output buffer constraint!"); - } - else if(grblock->min_output_buffer(port) > 0) { - nitems = std::max((long)nitems, (long)grblock->min_output_buffer(port)); - nitems -= nitems%grblock->output_multiple(); - if(nitems < 1) - throw std::runtime_error("problems allocating a buffer with the given min output buffer constraint!"); + if (grblock->max_output_buffer(port) > 0) { + // std::cout << "constraining output items to " << block->max_output_buffer(port) + // << "\n"; + nitems = std::min((long)nitems, (long)grblock->max_output_buffer(port)); + nitems -= nitems % grblock->output_multiple(); + if (nitems < 1) + throw std::runtime_error("problems allocating a buffer with the given max " + "output buffer constraint!"); + } else if (grblock->min_output_buffer(port) > 0) { + nitems = std::max((long)nitems, (long)grblock->min_output_buffer(port)); + nitems -= nitems % grblock->output_multiple(); + if (nitems < 1) + throw std::runtime_error("problems allocating a buffer with the given min " + "output buffer constraint!"); } - for(basic_block_viter_t p = blocks.begin(); p != blocks.end(); p++) { - block_sptr dgrblock = cast_to_block_sptr(*p); - if(!dgrblock) - throw std::runtime_error("allocate_buffer found non-gr::block"); + for (basic_block_viter_t p = blocks.begin(); p != blocks.end(); p++) { + block_sptr dgrblock = cast_to_block_sptr(*p); + if (!dgrblock) + throw std::runtime_error("allocate_buffer found non-gr::block"); - double decimation = (1.0/dgrblock->relative_rate()); - int multiple = dgrblock->output_multiple(); - int history = dgrblock->history(); - nitems = std::max(nitems, static_cast<int>(2*(decimation*multiple+history))); + double decimation = (1.0 / dgrblock->relative_rate()); + int multiple = dgrblock->output_multiple(); + int history = dgrblock->history(); + nitems = + std::max(nitems, static_cast<int>(2 * (decimation * multiple + history))); } - // std::cout << "make_buffer(" << nitems << ", " << item_size << ", " << grblock << "\n"; + // std::cout << "make_buffer(" << nitems << ", " << item_size << ", " << grblock << + // "\n"; // We're going to let this fail once and retry. If that fails, // throw and exit. buffer_sptr b; try { - b = make_buffer(nitems, item_size, grblock); - } - catch(std::bad_alloc&) { - b = make_buffer(nitems, item_size, grblock); + b = make_buffer(nitems, item_size, grblock); + } catch (std::bad_alloc&) { + b = make_buffer(nitems, item_size, grblock); } // Set the max noutput items size here to make sure it's always // set in the block and available in the start() method. // But don't overwrite if the user has set this externally. - if(!grblock->is_set_max_noutput_items()) - grblock->set_max_noutput_items(nitems); + if (!grblock->is_set_max_noutput_items()) + grblock->set_max_noutput_items(nitems); return b; - } +} - void - flat_flowgraph::connect_block_inputs(basic_block_sptr block) - { +void flat_flowgraph::connect_block_inputs(basic_block_sptr block) +{ block_sptr grblock = cast_to_block_sptr(block); if (!grblock) - throw std::runtime_error("connect_block_inputs found non-gr::block"); + throw std::runtime_error("connect_block_inputs found non-gr::block"); // Get its detail and edges that feed into it block_detail_sptr detail = grblock->detail(); edge_vector_t in_edges = calc_upstream_edges(block); // For each edge that feeds into it - for(edge_viter_t e = in_edges.begin(); e != in_edges.end(); e++) { - // Set the buffer reader on the destination port to the output - // buffer on the source port - int dst_port = e->dst().port(); - int src_port = e->src().port(); - basic_block_sptr src_block = e->src().block(); - block_sptr src_grblock = cast_to_block_sptr(src_block); - if(!src_grblock) - throw std::runtime_error("connect_block_inputs found non-gr::block"); - buffer_sptr src_buffer = src_grblock->detail()->output(src_port); - + for (edge_viter_t e = in_edges.begin(); e != in_edges.end(); e++) { + // Set the buffer reader on the destination port to the output + // buffer on the source port + int dst_port = e->dst().port(); + int src_port = e->src().port(); + basic_block_sptr src_block = e->src().block(); + block_sptr src_grblock = cast_to_block_sptr(src_block); + if (!src_grblock) + throw std::runtime_error("connect_block_inputs found non-gr::block"); + buffer_sptr src_buffer = src_grblock->detail()->output(src_port); - GR_LOG_DEBUG(d_debug_logger, "Setting input " + std::to_string(dst_port) + " from edge " + (*e).identifier()); - detail->set_input(dst_port, buffer_add_reader(src_buffer, grblock->history()-1, grblock, - grblock->sample_delay(src_port))); + GR_LOG_DEBUG(d_debug_logger, + "Setting input " + std::to_string(dst_port) + " from edge " + + (*e).identifier()); + + detail->set_input(dst_port, + buffer_add_reader(src_buffer, + grblock->history() - 1, + grblock, + grblock->sample_delay(src_port))); } - } +} - void - flat_flowgraph::merge_connections(flat_flowgraph_sptr old_ffg) - { +void flat_flowgraph::merge_connections(flat_flowgraph_sptr old_ffg) +{ // Allocate block details if needed. Only new blocks that aren't pruned out // by flattening will need one; existing blocks still in the new flowgraph will // already have one. - for(basic_block_viter_t p = d_blocks.begin(); p != d_blocks.end(); p++) { - block_sptr block = cast_to_block_sptr(*p); - - if (!block->detail()) { - GR_LOG_DEBUG(d_debug_logger, - "merge: allocating new detail for block " + block->identifier()); - block->set_detail(allocate_block_detail(block)); - } else { - GR_LOG_DEBUG(d_debug_logger, - "merge: reusing original detail for block " + block->identifier()); - } + for (basic_block_viter_t p = d_blocks.begin(); p != d_blocks.end(); p++) { + block_sptr block = cast_to_block_sptr(*p); + + if (!block->detail()) { + GR_LOG_DEBUG(d_debug_logger, + "merge: allocating new detail for block " + block->identifier()); + block->set_detail(allocate_block_detail(block)); + } else { + GR_LOG_DEBUG(d_debug_logger, + "merge: reusing original detail for block " + + block->identifier()); + } } // Calculate the old edges that will be going away, and clear the // buffer readers on the RHS. - for (edge_viter_t old_edge = old_ffg->d_edges.begin(); old_edge != old_ffg->d_edges.end(); + for (edge_viter_t old_edge = old_ffg->d_edges.begin(); + old_edge != old_ffg->d_edges.end(); old_edge++) { GR_LOG_DEBUG(d_debug_logger, "merge: testing old edge " + old_edge->identifier() + "..."); @@ -259,234 +267,230 @@ namespace gr { } // Now connect inputs to outputs, reusing old buffer readers if they exist - for(basic_block_viter_t p = d_blocks.begin(); p != d_blocks.end(); p++) { - block_sptr block = cast_to_block_sptr(*p); - - GR_LOG_DEBUG(d_debug_logger, - "merge: merging " + block->identifier() + "..."); - - if (old_ffg->has_block_p(*p)) { - // Block exists in old flow graph - GR_LOG_DEBUG(d_debug_logger, "used in old flow graph") - block_detail_sptr detail = block->detail(); - - // Iterate through the inputs and see what needs to be done - int ninputs = calc_used_ports(block, true).size(); // Might be different now - for (int i = 0; i < ninputs; i++) { - GR_LOG_DEBUG(d_debug_logger, - "Checking input " + block->identifier() + ":" + std::to_string(i) + - "..."); - edge edge = calc_upstream_edge(*p, i); - - // Fish out old buffer reader and see if it matches correct buffer from edge list - block_sptr src_block = cast_to_block_sptr(edge.src().block()); - block_detail_sptr src_detail = src_block->detail(); - buffer_sptr src_buffer = src_detail->output(edge.src().port()); - buffer_reader_sptr old_reader; - if (i < detail->ninputs()) // Don't exceed what the original detail has - old_reader = detail->input(i); - - // If there's a match, use it - if (old_reader && (src_buffer == old_reader->buffer())) { - GR_LOG_DEBUG(d_debug_logger, "matched, reusing"); - } else { - GR_LOG_DEBUG(d_debug_logger, "needs a new reader"); - - // Create new buffer reader and assign - detail->set_input(i, buffer_add_reader(src_buffer, block->history() - 1, block)); - } - } - } - else { - // Block is new, it just needs buffer readers at this point - GR_LOG_DEBUG(d_debug_logger, "new block"); - connect_block_inputs(block); - - // Make sure all buffers are aligned - setup_buffer_alignment(block); - } - - // Connect message ports connetions - for (msg_edge_viter_t i = d_msg_edges.begin(); i != d_msg_edges.end(); i++) { - GR_LOG_DEBUG(d_debug_logger, - boost::format("flat_fg connecting msg primitives: (%s, %s)->(%s, %s)\n") % - i->src().block() % i->src().port() % i->dst().block() % i->dst().port()); - i->src().block()->message_port_sub( - i->src().port(), pmt::cons(i->dst().block()->alias_pmt(), i->dst().port())); - } - - // Now deal with the fact that the block details might have - // changed numbers of inputs and outputs vs. in the old - // flowgraph. - - block->detail()->reset_nitem_counters(); - block->detail()->clear_tags(); + for (basic_block_viter_t p = d_blocks.begin(); p != d_blocks.end(); p++) { + block_sptr block = cast_to_block_sptr(*p); + + GR_LOG_DEBUG(d_debug_logger, "merge: merging " + block->identifier() + "..."); + + if (old_ffg->has_block_p(*p)) { + // Block exists in old flow graph + GR_LOG_DEBUG(d_debug_logger, "used in old flow graph") + block_detail_sptr detail = block->detail(); + + // Iterate through the inputs and see what needs to be done + int ninputs = calc_used_ports(block, true).size(); // Might be different now + for (int i = 0; i < ninputs; i++) { + GR_LOG_DEBUG(d_debug_logger, + "Checking input " + block->identifier() + ":" + + std::to_string(i) + "..."); + edge edge = calc_upstream_edge(*p, i); + + // Fish out old buffer reader and see if it matches correct buffer from + // edge list + block_sptr src_block = cast_to_block_sptr(edge.src().block()); + block_detail_sptr src_detail = src_block->detail(); + buffer_sptr src_buffer = src_detail->output(edge.src().port()); + buffer_reader_sptr old_reader; + if (i < detail->ninputs()) // Don't exceed what the original detail has + old_reader = detail->input(i); + + // If there's a match, use it + if (old_reader && (src_buffer == old_reader->buffer())) { + GR_LOG_DEBUG(d_debug_logger, "matched, reusing"); + } else { + GR_LOG_DEBUG(d_debug_logger, "needs a new reader"); + + // Create new buffer reader and assign + detail->set_input( + i, buffer_add_reader(src_buffer, block->history() - 1, block)); + } + } + } else { + // Block is new, it just needs buffer readers at this point + GR_LOG_DEBUG(d_debug_logger, "new block"); + connect_block_inputs(block); + + // Make sure all buffers are aligned + setup_buffer_alignment(block); + } + + // Connect message ports connetions + for (msg_edge_viter_t i = d_msg_edges.begin(); i != d_msg_edges.end(); i++) { + GR_LOG_DEBUG( + d_debug_logger, + boost::format("flat_fg connecting msg primitives: (%s, %s)->(%s, %s)\n") % + i->src().block() % i->src().port() % i->dst().block() % + i->dst().port()); + i->src().block()->message_port_sub( + i->src().port(), + pmt::cons(i->dst().block()->alias_pmt(), i->dst().port())); + } + + // Now deal with the fact that the block details might have + // changed numbers of inputs and outputs vs. in the old + // flowgraph. + + block->detail()->reset_nitem_counters(); + block->detail()->clear_tags(); } - } +} - void - flat_flowgraph::setup_buffer_alignment(block_sptr block) - { +void flat_flowgraph::setup_buffer_alignment(block_sptr block) +{ const int alignment = volk_get_alignment(); - for(int i = 0; i < block->detail()->ninputs(); i++) { - void *r = (void*)block->detail()->input(i)->read_pointer(); - uintptr_t ri = (uintptr_t)r % alignment; - //std::cerr << "reader: " << r << " alignment: " << ri << std::endl; - if(ri != 0) { - size_t itemsize = block->detail()->input(i)->get_sizeof_item(); - block->detail()->input(i)->update_read_pointer((alignment-ri)/itemsize); - } - block->set_unaligned(0); - block->set_is_unaligned(false); + for (int i = 0; i < block->detail()->ninputs(); i++) { + void* r = (void*)block->detail()->input(i)->read_pointer(); + uintptr_t ri = (uintptr_t)r % alignment; + // std::cerr << "reader: " << r << " alignment: " << ri << std::endl; + if (ri != 0) { + size_t itemsize = block->detail()->input(i)->get_sizeof_item(); + block->detail()->input(i)->update_read_pointer((alignment - ri) / itemsize); + } + block->set_unaligned(0); + block->set_is_unaligned(false); } - for(int i = 0; i < block->detail()->noutputs(); i++) { - void *w = (void*)block->detail()->output(i)->write_pointer(); - uintptr_t wi = (uintptr_t)w % alignment; - //std::cerr << "writer: " << w << " alignment: " << wi << std::endl; - if(wi != 0) { - size_t itemsize = block->detail()->output(i)->get_sizeof_item(); - block->detail()->output(i)->update_write_pointer((alignment-wi)/itemsize); - } - block->set_unaligned(0); - block->set_is_unaligned(false); + for (int i = 0; i < block->detail()->noutputs(); i++) { + void* w = (void*)block->detail()->output(i)->write_pointer(); + uintptr_t wi = (uintptr_t)w % alignment; + // std::cerr << "writer: " << w << " alignment: " << wi << std::endl; + if (wi != 0) { + size_t itemsize = block->detail()->output(i)->get_sizeof_item(); + block->detail()->output(i)->update_write_pointer((alignment - wi) / itemsize); + } + block->set_unaligned(0); + block->set_is_unaligned(false); } - } +} - std::string - flat_flowgraph::edge_list() - { +std::string flat_flowgraph::edge_list() +{ std::stringstream s; - for(edge_viter_t e = d_edges.begin(); e != d_edges.end(); e++) - s << (*e) << std::endl; + for (edge_viter_t e = d_edges.begin(); e != d_edges.end(); e++) + s << (*e) << std::endl; return s.str(); - } +} - std::string - flat_flowgraph::msg_edge_list() - { +std::string flat_flowgraph::msg_edge_list() +{ std::stringstream s; - for(msg_edge_viter_t e = d_msg_edges.begin(); e != d_msg_edges.end(); e++) - s << (*e) << std::endl; + for (msg_edge_viter_t e = d_msg_edges.begin(); e != d_msg_edges.end(); e++) + s << (*e) << std::endl; return s.str(); - } - - void flat_flowgraph::dump() - { - for(edge_viter_t e = d_edges.begin(); e != d_edges.end(); e++) - std::cout << " edge: " << (*e) << std::endl; - - for(basic_block_viter_t p = d_blocks.begin(); p != d_blocks.end(); p++) { - std::cout << " block: " << (*p) << std::endl; - block_detail_sptr detail = cast_to_block_sptr(*p)->detail(); - std::cout << " detail @" << detail << ":" << std::endl; - - int ni = detail->ninputs(); - int no = detail->noutputs(); - for(int i = 0; i < no; i++) { - buffer_sptr buffer = detail->output(i); - std::cout << " output " << i << ": " << buffer << std::endl; - } - - for(int i = 0; i < ni; i++) { - buffer_reader_sptr reader = detail->input(i); - std::cout << " reader " << i << ": " << reader - << " reading from buffer=" << reader->buffer() << std::endl; - } +} + +void flat_flowgraph::dump() +{ + for (edge_viter_t e = d_edges.begin(); e != d_edges.end(); e++) + std::cout << " edge: " << (*e) << std::endl; + + for (basic_block_viter_t p = d_blocks.begin(); p != d_blocks.end(); p++) { + std::cout << " block: " << (*p) << std::endl; + block_detail_sptr detail = cast_to_block_sptr(*p)->detail(); + std::cout << " detail @" << detail << ":" << std::endl; + + int ni = detail->ninputs(); + int no = detail->noutputs(); + for (int i = 0; i < no; i++) { + buffer_sptr buffer = detail->output(i); + std::cout << " output " << i << ": " << buffer << std::endl; + } + + for (int i = 0; i < ni; i++) { + buffer_reader_sptr reader = detail->input(i); + std::cout << " reader " << i << ": " << reader + << " reading from buffer=" << reader->buffer() << std::endl; + } } - } +} - block_vector_t - flat_flowgraph::make_block_vector(basic_block_vector_t &blocks) - { +block_vector_t flat_flowgraph::make_block_vector(basic_block_vector_t& blocks) +{ block_vector_t result; - for(basic_block_viter_t p = blocks.begin(); p != blocks.end(); p++) { - result.push_back(cast_to_block_sptr(*p)); + for (basic_block_viter_t p = blocks.begin(); p != blocks.end(); p++) { + result.push_back(cast_to_block_sptr(*p)); } return result; - } - - void - flat_flowgraph::clear_endpoint(const msg_endpoint &e, bool is_src) - { - for(size_t i=0; i<d_msg_edges.size(); i++) { - if(is_src) { - if(d_msg_edges[i].src() == e) { - d_msg_edges.erase(d_msg_edges.begin() + i); - i--; - } - } - else { - if(d_msg_edges[i].dst() == e) { - d_msg_edges.erase(d_msg_edges.begin() + i); - i--; +} + +void flat_flowgraph::clear_endpoint(const msg_endpoint& e, bool is_src) +{ + for (size_t i = 0; i < d_msg_edges.size(); i++) { + if (is_src) { + if (d_msg_edges[i].src() == e) { + d_msg_edges.erase(d_msg_edges.begin() + i); + i--; + } + } else { + if (d_msg_edges[i].dst() == e) { + d_msg_edges.erase(d_msg_edges.begin() + i); + i--; + } } - } } - } - - void - flat_flowgraph::clear_hier() - { - GR_LOG_DEBUG(d_debug_logger, "Clear_hier()"); - for (size_t i = 0; i < d_msg_edges.size(); i++) { - GR_LOG_DEBUG(d_debug_logger, - "edge: " + d_msg_edges[i].src().identifier() + "-->" + - d_msg_edges[i].dst().identifier()); - if (d_msg_edges[i].src().is_hier() || d_msg_edges[i].dst().is_hier()) { +} + +void flat_flowgraph::clear_hier() +{ + GR_LOG_DEBUG(d_debug_logger, "Clear_hier()"); + for (size_t i = 0; i < d_msg_edges.size(); i++) { + GR_LOG_DEBUG(d_debug_logger, + "edge: " + d_msg_edges[i].src().identifier() + "-->" + + d_msg_edges[i].dst().identifier()); + if (d_msg_edges[i].src().is_hier() || d_msg_edges[i].dst().is_hier()) { GR_LOG_DEBUG(d_debug_logger, "is hier"); d_msg_edges.erase(d_msg_edges.begin() + i); i--; - } + } } - } - - void - flat_flowgraph::replace_endpoint(const msg_endpoint &e, const msg_endpoint &r, bool is_src) - { - size_t n_replr(0); - GR_LOG_DEBUG(d_debug_logger, - boost::format("flat_flowgraph::replace_endpoint( %s, %s, %d )\n") % e.block() % - r.block() % is_src); - for (size_t i = 0; i < d_msg_edges.size(); i++) { - if (is_src) { - if (d_msg_edges[i].src() == e) { - GR_LOG_DEBUG( - d_debug_logger, - boost::format( - "flat_flowgraph::replace_endpoint() flattening to ( %s, %s )\n") % - r % d_msg_edges[i].dst()) - d_msg_edges.push_back(msg_edge(r, d_msg_edges[i].dst())); - n_replr++; - } - } else { - if (d_msg_edges[i].dst() == e) { - GR_LOG_DEBUG( - d_debug_logger, - boost::format( - "flat_flowgraph::replace_endpoint() flattening to ( %s, %s )\n") % - r % d_msg_edges[i].src()); - d_msg_edges.push_back(msg_edge(d_msg_edges[i].src(), r)); - n_replr++; - } - } +} + +void flat_flowgraph::replace_endpoint(const msg_endpoint& e, + const msg_endpoint& r, + bool is_src) +{ + size_t n_replr(0); + GR_LOG_DEBUG(d_debug_logger, + boost::format("flat_flowgraph::replace_endpoint( %s, %s, %d )\n") % + e.block() % r.block() % is_src); + for (size_t i = 0; i < d_msg_edges.size(); i++) { + if (is_src) { + if (d_msg_edges[i].src() == e) { + GR_LOG_DEBUG( + d_debug_logger, + boost::format( + "flat_flowgraph::replace_endpoint() flattening to ( %s, %s )\n") % + r % d_msg_edges[i].dst()) + d_msg_edges.push_back(msg_edge(r, d_msg_edges[i].dst())); + n_replr++; + } + } else { + if (d_msg_edges[i].dst() == e) { + GR_LOG_DEBUG( + d_debug_logger, + boost::format( + "flat_flowgraph::replace_endpoint() flattening to ( %s, %s )\n") % + r % d_msg_edges[i].src()); + d_msg_edges.push_back(msg_edge(d_msg_edges[i].src(), r)); + n_replr++; + } + } } - } +} - void - flat_flowgraph::enable_pc_rpc() - { +void flat_flowgraph::enable_pc_rpc() +{ #ifdef GR_PERFORMANCE_COUNTERS - if(prefs::singleton()->get_bool("PerfCounters", "on", false)) { - basic_block_viter_t p; - for(p = d_blocks.begin(); p != d_blocks.end(); p++) { - block_sptr block = cast_to_block_sptr(*p); - if(!block->is_pc_rpc_set()) - block->setup_pc_rpc(); - } + if (prefs::singleton()->get_bool("PerfCounters", "on", false)) { + basic_block_viter_t p; + for (p = d_blocks.begin(); p != d_blocks.end(); p++) { + block_sptr block = cast_to_block_sptr(*p); + if (!block->is_pc_rpc_set()) + block->setup_pc_rpc(); + } } #endif /* GR_PERFORMANCE_COUNTERS */ - } +} } /* namespace gr */ diff --git a/gnuradio-runtime/lib/flat_flowgraph.h b/gnuradio-runtime/lib/flat_flowgraph.h index 5db38b9dae..3630a2a5c8 100644 --- a/gnuradio-runtime/lib/flat_flowgraph.h +++ b/gnuradio-runtime/lib/flat_flowgraph.h @@ -30,18 +30,18 @@ namespace gr { - // Create a shared pointer to a heap allocated gr::flat_flowgraph - // (types defined in gr_runtime_types.h) - GR_RUNTIME_API flat_flowgraph_sptr make_flat_flowgraph(); - - /*! - *\brief Class specializing gr_flat_flowgraph that has all nodes - * as blocks, with no hierarchy - * \ingroup internal - */ - class GR_RUNTIME_API flat_flowgraph : public flowgraph - { - public: +// Create a shared pointer to a heap allocated gr::flat_flowgraph +// (types defined in gr_runtime_types.h) +GR_RUNTIME_API flat_flowgraph_sptr make_flat_flowgraph(); + +/*! + *\brief Class specializing gr_flat_flowgraph that has all nodes + * as blocks, with no hierarchy + * \ingroup internal + */ +class GR_RUNTIME_API flat_flowgraph : public flowgraph +{ +public: friend GR_RUNTIME_API flat_flowgraph_sptr make_flat_flowgraph(); // Destruct an arbitrary gr::flat_flowgraph @@ -64,17 +64,17 @@ namespace gr { /*! * Make a vector of gr::block from a vector of gr::basic_block */ - static block_vector_t make_block_vector(basic_block_vector_t &blocks); + static block_vector_t make_block_vector(basic_block_vector_t& blocks); /*! * replace hierarchical message connections with internal primitive ones */ - void replace_endpoint(const msg_endpoint &e, const msg_endpoint &r, bool is_src); + void replace_endpoint(const msg_endpoint& e, const msg_endpoint& r, bool is_src); /*! * remove a specific hier message connection after replacement */ - void clear_endpoint(const msg_endpoint &e, bool is_src); + void clear_endpoint(const msg_endpoint& e, bool is_src); /*! * remove remainin hier message connections (non primitive) @@ -87,7 +87,7 @@ namespace gr { */ void enable_pc_rpc(); - private: +private: flat_flowgraph(); block_detail_sptr allocate_block_detail(basic_block_sptr block); @@ -105,7 +105,7 @@ namespace gr { gr::logger_ptr d_logger; gr::logger_ptr d_debug_logger; - }; +}; } /* namespace gr */ diff --git a/gnuradio-runtime/lib/flowgraph.cc b/gnuradio-runtime/lib/flowgraph.cc index b9902363c7..acc1429ae2 100644 --- a/gnuradio-runtime/lib/flowgraph.cc +++ b/gnuradio-runtime/lib/flowgraph.cc @@ -33,499 +33,462 @@ namespace gr { #define FLOWGRAPH_DEBUG 0 - edge::~edge() - { - } - - flowgraph_sptr make_flowgraph() - { - return flowgraph_sptr(new flowgraph()); - } - - flowgraph::flowgraph() - { - } - - flowgraph::~flowgraph() - { - } - - template<class T> - static - std::vector<T> - unique_vector(std::vector<T> v) - { +edge::~edge() {} + +flowgraph_sptr make_flowgraph() { return flowgraph_sptr(new flowgraph()); } + +flowgraph::flowgraph() {} + +flowgraph::~flowgraph() {} + +template <class T> +static std::vector<T> unique_vector(std::vector<T> v) +{ std::vector<T> result; - std::insert_iterator<std::vector<T> > inserter(result, result.begin()); + std::insert_iterator<std::vector<T>> inserter(result, result.begin()); sort(v.begin(), v.end()); unique_copy(v.begin(), v.end(), inserter); return result; - } +} - void - flowgraph::connect(const endpoint &src, const endpoint &dst) - { +void flowgraph::connect(const endpoint& src, const endpoint& dst) +{ check_valid_port(src.block()->output_signature(), src.port()); check_valid_port(dst.block()->input_signature(), dst.port()); check_dst_not_used(dst); check_type_match(src, dst); // Alles klar, Herr Kommissar - d_edges.push_back(edge(src,dst)); - } - - void - flowgraph::disconnect(const endpoint &src, const endpoint &dst) - { - for(edge_viter_t p = d_edges.begin(); p != d_edges.end(); p++) { - if(src == p->src() && dst == p->dst()) { - d_edges.erase(p); - return; - } + d_edges.push_back(edge(src, dst)); +} + +void flowgraph::disconnect(const endpoint& src, const endpoint& dst) +{ + for (edge_viter_t p = d_edges.begin(); p != d_edges.end(); p++) { + if (src == p->src() && dst == p->dst()) { + d_edges.erase(p); + return; + } } std::stringstream msg; msg << "cannot disconnect edge " << edge(src, dst) << ", not found"; throw std::invalid_argument(msg.str()); - } +} - void - flowgraph::validate() - { +void flowgraph::validate() +{ d_blocks = calc_used_blocks(); - for(basic_block_viter_t p = d_blocks.begin(); p != d_blocks.end(); p++) { - std::vector<int> used_ports; - int ninputs, noutputs; + for (basic_block_viter_t p = d_blocks.begin(); p != d_blocks.end(); p++) { + std::vector<int> used_ports; + int ninputs, noutputs; - if(FLOWGRAPH_DEBUG) - std::cout << "Validating block: " << (*p) << std::endl; + if (FLOWGRAPH_DEBUG) + std::cout << "Validating block: " << (*p) << std::endl; - used_ports = calc_used_ports(*p, true); // inputs - ninputs = used_ports.size(); - check_contiguity(*p, used_ports, true); // inputs + used_ports = calc_used_ports(*p, true); // inputs + ninputs = used_ports.size(); + check_contiguity(*p, used_ports, true); // inputs - used_ports = calc_used_ports(*p, false); // outputs - noutputs = used_ports.size(); - check_contiguity(*p, used_ports, false); // outputs + used_ports = calc_used_ports(*p, false); // outputs + noutputs = used_ports.size(); + check_contiguity(*p, used_ports, false); // outputs - if(!((*p)->check_topology(ninputs, noutputs))) { - std::stringstream msg; - msg << "check topology failed on " << (*p) - << " using ninputs=" << ninputs - << ", noutputs=" << noutputs; - throw std::runtime_error(msg.str()); - } + if (!((*p)->check_topology(ninputs, noutputs))) { + std::stringstream msg; + msg << "check topology failed on " << (*p) << " using ninputs=" << ninputs + << ", noutputs=" << noutputs; + throw std::runtime_error(msg.str()); + } } - } +} - void - flowgraph::clear() - { +void flowgraph::clear() +{ // Boost shared pointers will deallocate as needed d_blocks.clear(); d_edges.clear(); - } +} - void - flowgraph::check_valid_port(gr::io_signature::sptr sig, int port) - { +void flowgraph::check_valid_port(gr::io_signature::sptr sig, int port) +{ std::stringstream msg; - if(port < 0) { - msg << "negative port number " << port << " is invalid"; - throw std::invalid_argument(msg.str()); + if (port < 0) { + msg << "negative port number " << port << " is invalid"; + throw std::invalid_argument(msg.str()); } int max = sig->max_streams(); - if(max != io_signature::IO_INFINITE && port >= max) { - msg << "port number " << port << " exceeds max of "; - if(max == 0) - msg << "(none)"; - else - msg << max-1; - throw std::invalid_argument(msg.str()); + if (max != io_signature::IO_INFINITE && port >= max) { + msg << "port number " << port << " exceeds max of "; + if (max == 0) + msg << "(none)"; + else + msg << max - 1; + throw std::invalid_argument(msg.str()); } - } - - void - flowgraph::check_valid_port(const msg_endpoint &e) - { - if(FLOWGRAPH_DEBUG) - std::cout << "check_valid_port( " << e.block() << ", " << e.port() << ")\n"; - - if(!e.block()->has_msg_port(e.port())) { - const gr::basic_block::msg_queue_map_t& msg_map = e.block()->get_msg_map(); - std::cout << "Could not find port: " << e.port() << " in:" << std::endl; - for (gr::basic_block::msg_queue_map_t::const_iterator it = msg_map.begin(); it != msg_map.end(); ++it) - std::cout << it->first << std::endl; - std::cout << std::endl; - throw std::invalid_argument("invalid msg port in connect() or disconnect()"); +} + +void flowgraph::check_valid_port(const msg_endpoint& e) +{ + if (FLOWGRAPH_DEBUG) + std::cout << "check_valid_port( " << e.block() << ", " << e.port() << ")\n"; + + if (!e.block()->has_msg_port(e.port())) { + const gr::basic_block::msg_queue_map_t& msg_map = e.block()->get_msg_map(); + std::cout << "Could not find port: " << e.port() << " in:" << std::endl; + for (gr::basic_block::msg_queue_map_t::const_iterator it = msg_map.begin(); + it != msg_map.end(); + ++it) + std::cout << it->first << std::endl; + std::cout << std::endl; + throw std::invalid_argument("invalid msg port in connect() or disconnect()"); } - } +} - void - flowgraph::check_dst_not_used(const endpoint &dst) - { +void flowgraph::check_dst_not_used(const endpoint& dst) +{ // A destination is in use if it is already on the edge list - for(edge_viter_t p = d_edges.begin(); p != d_edges.end(); p++) - if(p->dst() == dst) { - std::stringstream msg; - msg << "destination already in use by edge " << (*p); - throw std::invalid_argument(msg.str()); - } - } + for (edge_viter_t p = d_edges.begin(); p != d_edges.end(); p++) + if (p->dst() == dst) { + std::stringstream msg; + msg << "destination already in use by edge " << (*p); + throw std::invalid_argument(msg.str()); + } +} - void - flowgraph::check_type_match(const endpoint &src, const endpoint &dst) - { +void flowgraph::check_type_match(const endpoint& src, const endpoint& dst) +{ int src_size = src.block()->output_signature()->sizeof_stream_item(src.port()); int dst_size = dst.block()->input_signature()->sizeof_stream_item(dst.port()); - if(src_size != dst_size) { - std::stringstream msg; - msg << "itemsize mismatch: " << src << " using " << src_size - << ", " << dst << " using " << dst_size; - throw std::invalid_argument(msg.str()); + if (src_size != dst_size) { + std::stringstream msg; + msg << "itemsize mismatch: " << src << " using " << src_size << ", " << dst + << " using " << dst_size; + throw std::invalid_argument(msg.str()); } - } +} - basic_block_vector_t - flowgraph::calc_used_blocks() - { +basic_block_vector_t flowgraph::calc_used_blocks() +{ basic_block_vector_t tmp; // make sure free standing message blocks are included - for(msg_edge_viter_t p = d_msg_edges.begin(); p != d_msg_edges.end(); p++) { - // all msg blocks need a thread context - otherwise start() will never be called! - // even if it is a sender that never does anything - tmp.push_back(p->src().block()); - tmp.push_back(p->dst().block()); + for (msg_edge_viter_t p = d_msg_edges.begin(); p != d_msg_edges.end(); p++) { + // all msg blocks need a thread context - otherwise start() will never be called! + // even if it is a sender that never does anything + tmp.push_back(p->src().block()); + tmp.push_back(p->dst().block()); } // Collect all blocks in the edge list - for(edge_viter_t p = d_edges.begin(); p != d_edges.end(); p++) { - tmp.push_back(p->src().block()); - tmp.push_back(p->dst().block()); + for (edge_viter_t p = d_edges.begin(); p != d_edges.end(); p++) { + tmp.push_back(p->src().block()); + tmp.push_back(p->dst().block()); } return unique_vector<basic_block_sptr>(tmp); - } +} - std::vector<int> - flowgraph::calc_used_ports(basic_block_sptr block, bool check_inputs) - { +std::vector<int> flowgraph::calc_used_ports(basic_block_sptr block, bool check_inputs) +{ std::vector<int> tmp; // Collect all seen ports edge_vector_t edges = calc_connections(block, check_inputs); - for(edge_viter_t p = edges.begin(); p != edges.end(); p++) { - if(check_inputs == true) - tmp.push_back(p->dst().port()); - else - tmp.push_back(p->src().port()); + for (edge_viter_t p = edges.begin(); p != edges.end(); p++) { + if (check_inputs == true) + tmp.push_back(p->dst().port()); + else + tmp.push_back(p->src().port()); } return unique_vector<int>(tmp); - } +} - edge_vector_t - flowgraph::calc_connections(basic_block_sptr block, bool check_inputs) - { +edge_vector_t flowgraph::calc_connections(basic_block_sptr block, bool check_inputs) +{ edge_vector_t result; - for(edge_viter_t p = d_edges.begin(); p != d_edges.end(); p++) { - if(check_inputs) { - if(p->dst().block() == block) - result.push_back(*p); - } - else { - if(p->src().block() == block) - result.push_back(*p); - } + for (edge_viter_t p = d_edges.begin(); p != d_edges.end(); p++) { + if (check_inputs) { + if (p->dst().block() == block) + result.push_back(*p); + } else { + if (p->src().block() == block) + result.push_back(*p); + } } return result; // assumes no duplicates - } +} - void - flowgraph::check_contiguity(basic_block_sptr block, - const std::vector<int> &used_ports, - bool check_inputs) - { +void flowgraph::check_contiguity(basic_block_sptr block, + const std::vector<int>& used_ports, + bool check_inputs) +{ std::stringstream msg; gr::io_signature::sptr sig = - check_inputs ? block->input_signature() : block->output_signature(); + check_inputs ? block->input_signature() : block->output_signature(); int nports = used_ports.size(); int min_ports = sig->min_streams(); int max_ports = sig->max_streams(); - if(nports == 0 && min_ports == 0) - return; + if (nports == 0 && min_ports == 0) + return; - if(nports < min_ports) { - msg << block << ": insufficient connected " - << (check_inputs ? "input ports " : "output ports ") - << "(" << min_ports << " needed, " << nports << " connected)"; - throw std::runtime_error(msg.str()); + if (nports < min_ports) { + msg << block << ": insufficient connected " + << (check_inputs ? "input ports " : "output ports ") << "(" << min_ports + << " needed, " << nports << " connected)"; + throw std::runtime_error(msg.str()); } - if(nports > max_ports && max_ports != io_signature::IO_INFINITE) { - msg << block << ": too many connected " - << (check_inputs ? "input ports " : "output ports ") - << "(" << max_ports << " allowed, " << nports << " connected)"; - throw std::runtime_error(msg.str()); + if (nports > max_ports && max_ports != io_signature::IO_INFINITE) { + msg << block << ": too many connected " + << (check_inputs ? "input ports " : "output ports ") << "(" << max_ports + << " allowed, " << nports << " connected)"; + throw std::runtime_error(msg.str()); } - if(used_ports[nports-1]+1 != nports) { - for(int i = 0; i < nports; i++) { - if(used_ports[i] != i) { - msg << block << ": missing connection " - << (check_inputs ? "to input port " : "from output port ") - << i; - throw std::runtime_error(msg.str()); + if (used_ports[nports - 1] + 1 != nports) { + for (int i = 0; i < nports; i++) { + if (used_ports[i] != i) { + msg << block << ": missing connection " + << (check_inputs ? "to input port " : "from output port ") << i; + throw std::runtime_error(msg.str()); + } } - } } - } +} - basic_block_vector_t - flowgraph::calc_downstream_blocks(basic_block_sptr block, int port) - { +basic_block_vector_t flowgraph::calc_downstream_blocks(basic_block_sptr block, int port) +{ basic_block_vector_t tmp; - for(edge_viter_t p = d_edges.begin(); p != d_edges.end(); p++) - if(p->src() == endpoint(block, port)) - tmp.push_back(p->dst().block()); + for (edge_viter_t p = d_edges.begin(); p != d_edges.end(); p++) + if (p->src() == endpoint(block, port)) + tmp.push_back(p->dst().block()); return unique_vector<basic_block_sptr>(tmp); - } +} - basic_block_vector_t - flowgraph::calc_downstream_blocks(basic_block_sptr block) - { +basic_block_vector_t flowgraph::calc_downstream_blocks(basic_block_sptr block) +{ basic_block_vector_t tmp; - for(edge_viter_t p = d_edges.begin(); p != d_edges.end(); p++) - if(p->src().block() == block) - tmp.push_back(p->dst().block()); + for (edge_viter_t p = d_edges.begin(); p != d_edges.end(); p++) + if (p->src().block() == block) + tmp.push_back(p->dst().block()); return unique_vector<basic_block_sptr>(tmp); - } +} - edge_vector_t - flowgraph::calc_upstream_edges(basic_block_sptr block) - { +edge_vector_t flowgraph::calc_upstream_edges(basic_block_sptr block) +{ edge_vector_t result; - for(edge_viter_t p = d_edges.begin(); p != d_edges.end(); p++) - if(p->dst().block() == block) - result.push_back(*p); + for (edge_viter_t p = d_edges.begin(); p != d_edges.end(); p++) + if (p->dst().block() == block) + result.push_back(*p); return result; // Assume no duplicates - } +} - bool - flowgraph::has_block_p(basic_block_sptr block) - { +bool flowgraph::has_block_p(basic_block_sptr block) +{ basic_block_viter_t result; result = std::find(d_blocks.begin(), d_blocks.end(), block); return (result != d_blocks.end()); - } +} - edge - flowgraph::calc_upstream_edge(basic_block_sptr block, int port) - { +edge flowgraph::calc_upstream_edge(basic_block_sptr block, int port) +{ edge result; - for(edge_viter_t p = d_edges.begin(); p != d_edges.end(); p++) { - if(p->dst() == endpoint(block, port)) { - result = (*p); - break; - } + for (edge_viter_t p = d_edges.begin(); p != d_edges.end(); p++) { + if (p->dst() == endpoint(block, port)) { + result = (*p); + break; + } } return result; - } +} - std::vector<basic_block_vector_t> - flowgraph::partition() - { +std::vector<basic_block_vector_t> flowgraph::partition() +{ std::vector<basic_block_vector_t> result; basic_block_vector_t blocks = calc_used_blocks(); basic_block_vector_t graph; - while(blocks.size() > 0) { - graph = calc_reachable_blocks(blocks[0], blocks); - assert(graph.size()); - result.push_back(topological_sort(graph)); + while (blocks.size() > 0) { + graph = calc_reachable_blocks(blocks[0], blocks); + assert(graph.size()); + result.push_back(topological_sort(graph)); - for(basic_block_viter_t p = graph.begin(); p != graph.end(); p++) - blocks.erase(find(blocks.begin(), blocks.end(), *p)); + for (basic_block_viter_t p = graph.begin(); p != graph.end(); p++) + blocks.erase(find(blocks.begin(), blocks.end(), *p)); } return result; - } +} - basic_block_vector_t - flowgraph::calc_reachable_blocks(basic_block_sptr block, basic_block_vector_t &blocks) - { +basic_block_vector_t flowgraph::calc_reachable_blocks(basic_block_sptr block, + basic_block_vector_t& blocks) +{ basic_block_vector_t result; // Mark all blocks as unvisited - for(basic_block_viter_t p = blocks.begin(); p != blocks.end(); p++) - (*p)->set_color(basic_block::WHITE); + for (basic_block_viter_t p = blocks.begin(); p != blocks.end(); p++) + (*p)->set_color(basic_block::WHITE); // Recursively mark all reachable blocks reachable_dfs_visit(block, blocks); // Collect all the blocks that have been visited - for(basic_block_viter_t p = blocks.begin(); p != blocks.end(); p++) - if((*p)->color() == basic_block::BLACK) - result.push_back(*p); + for (basic_block_viter_t p = blocks.begin(); p != blocks.end(); p++) + if ((*p)->color() == basic_block::BLACK) + result.push_back(*p); return result; - } +} - // Recursively mark all reachable blocks from given block and block list - void - flowgraph::reachable_dfs_visit(basic_block_sptr block, basic_block_vector_t &blocks) - { +// Recursively mark all reachable blocks from given block and block list +void flowgraph::reachable_dfs_visit(basic_block_sptr block, basic_block_vector_t& blocks) +{ // Mark the current one as visited block->set_color(basic_block::BLACK); // Recurse into adjacent vertices basic_block_vector_t adjacent = calc_adjacent_blocks(block, blocks); - for(basic_block_viter_t p = adjacent.begin(); p != adjacent.end(); p++) - if((*p)->color() == basic_block::WHITE) - reachable_dfs_visit(*p, blocks); - } + for (basic_block_viter_t p = adjacent.begin(); p != adjacent.end(); p++) + if ((*p)->color() == basic_block::WHITE) + reachable_dfs_visit(*p, blocks); +} - // Return a list of block adjacent to a given block along any edge - basic_block_vector_t - flowgraph::calc_adjacent_blocks(basic_block_sptr block, basic_block_vector_t &blocks) - { +// Return a list of block adjacent to a given block along any edge +basic_block_vector_t flowgraph::calc_adjacent_blocks(basic_block_sptr block, + basic_block_vector_t& blocks) +{ basic_block_vector_t tmp; // Find any blocks that are inputs or outputs - for(edge_viter_t p = d_edges.begin(); p != d_edges.end(); p++) { - if(p->src().block() == block) - tmp.push_back(p->dst().block()); - if(p->dst().block() == block) - tmp.push_back(p->src().block()); + for (edge_viter_t p = d_edges.begin(); p != d_edges.end(); p++) { + if (p->src().block() == block) + tmp.push_back(p->dst().block()); + if (p->dst().block() == block) + tmp.push_back(p->src().block()); } return unique_vector<basic_block_sptr>(tmp); - } +} - basic_block_vector_t - flowgraph::topological_sort(basic_block_vector_t &blocks) - { +basic_block_vector_t flowgraph::topological_sort(basic_block_vector_t& blocks) +{ basic_block_vector_t tmp; basic_block_vector_t result; tmp = sort_sources_first(blocks); // Start 'em all white - for(basic_block_viter_t p = tmp.begin(); p != tmp.end(); p++) - (*p)->set_color(basic_block::WHITE); + for (basic_block_viter_t p = tmp.begin(); p != tmp.end(); p++) + (*p)->set_color(basic_block::WHITE); - for(basic_block_viter_t p = tmp.begin(); p != tmp.end(); p++) { - if((*p)->color() == basic_block::WHITE) - topological_dfs_visit(*p, result); + for (basic_block_viter_t p = tmp.begin(); p != tmp.end(); p++) { + if ((*p)->color() == basic_block::WHITE) + topological_dfs_visit(*p, result); } reverse(result.begin(), result.end()); return result; - } +} - basic_block_vector_t - flowgraph::sort_sources_first(basic_block_vector_t &blocks) - { +basic_block_vector_t flowgraph::sort_sources_first(basic_block_vector_t& blocks) +{ basic_block_vector_t sources, nonsources, result; - for(basic_block_viter_t p = blocks.begin(); p != blocks.end(); p++) { - if(source_p(*p)) - sources.push_back(*p); - else - nonsources.push_back(*p); + for (basic_block_viter_t p = blocks.begin(); p != blocks.end(); p++) { + if (source_p(*p)) + sources.push_back(*p); + else + nonsources.push_back(*p); } - for(basic_block_viter_t p = sources.begin(); p != sources.end(); p++) - result.push_back(*p); + for (basic_block_viter_t p = sources.begin(); p != sources.end(); p++) + result.push_back(*p); - for(basic_block_viter_t p = nonsources.begin(); p != nonsources.end(); p++) - result.push_back(*p); + for (basic_block_viter_t p = nonsources.begin(); p != nonsources.end(); p++) + result.push_back(*p); return result; - } +} - bool - flowgraph::source_p(basic_block_sptr block) - { +bool flowgraph::source_p(basic_block_sptr block) +{ return (calc_upstream_edges(block).size() == 0); - } +} - void - flowgraph::topological_dfs_visit(basic_block_sptr block, basic_block_vector_t &output) - { +void flowgraph::topological_dfs_visit(basic_block_sptr block, + basic_block_vector_t& output) +{ block->set_color(basic_block::GREY); basic_block_vector_t blocks(calc_downstream_blocks(block)); - for(basic_block_viter_t p = blocks.begin(); p != blocks.end(); p++) { - switch((*p)->color()) { - case basic_block::WHITE: - topological_dfs_visit(*p, output); - break; + for (basic_block_viter_t p = blocks.begin(); p != blocks.end(); p++) { + switch ((*p)->color()) { + case basic_block::WHITE: + topological_dfs_visit(*p, output); + break; - case basic_block::GREY: - throw std::runtime_error("flow graph has loops!"); + case basic_block::GREY: + throw std::runtime_error("flow graph has loops!"); - case basic_block::BLACK: - continue; + case basic_block::BLACK: + continue; - default: - throw std::runtime_error("invalid color on block!"); - } + default: + throw std::runtime_error("invalid color on block!"); + } } block->set_color(basic_block::BLACK); output.push_back(block); - } +} - void - flowgraph::connect(const msg_endpoint &src, const msg_endpoint &dst) - { +void flowgraph::connect(const msg_endpoint& src, const msg_endpoint& dst) +{ check_valid_port(src); check_valid_port(dst); - for(msg_edge_viter_t p = d_msg_edges.begin(); p != d_msg_edges.end(); p++) { - if(p->src() == src && p->dst() == dst){ - throw std::runtime_error("connect called on already connected edge!"); - } + for (msg_edge_viter_t p = d_msg_edges.begin(); p != d_msg_edges.end(); p++) { + if (p->src() == src && p->dst() == dst) { + throw std::runtime_error("connect called on already connected edge!"); + } } - d_msg_edges.push_back(msg_edge(src,dst)); - } + d_msg_edges.push_back(msg_edge(src, dst)); +} - void - flowgraph::disconnect(const msg_endpoint &src, const msg_endpoint &dst) - { +void flowgraph::disconnect(const msg_endpoint& src, const msg_endpoint& dst) +{ check_valid_port(src); check_valid_port(dst); - for(msg_edge_viter_t p = d_msg_edges.begin(); p != d_msg_edges.end(); p++) { - if(p->src() == src && p->dst() == dst){ - d_msg_edges.erase(p); - return; - } + for (msg_edge_viter_t p = d_msg_edges.begin(); p != d_msg_edges.end(); p++) { + if (p->src() == src && p->dst() == dst) { + d_msg_edges.erase(p); + return; + } } throw std::runtime_error("disconnect called on non-connected edge!"); - } +} - std::string - dot_graph_fg(flowgraph_sptr fg) - { +std::string dot_graph_fg(flowgraph_sptr fg) +{ basic_block_vector_t blocks = fg->calc_used_blocks(); edge_vector_t edges = fg->edges(); @@ -534,22 +497,20 @@ namespace gr { out << "digraph flowgraph {" << std::endl; // Define nodes and set labels - for(basic_block_viter_t block = blocks.begin(); block != blocks.end(); ++block) { - out << (*block)->unique_id() - << " [ label=\"" << (*block)->name() << "\" ]" - << std::endl; + for (basic_block_viter_t block = blocks.begin(); block != blocks.end(); ++block) { + out << (*block)->unique_id() << " [ label=\"" << (*block)->name() << "\" ]" + << std::endl; } // Define edges - for(edge_viter_t edge = edges.begin(); edge != edges.end(); ++edge) { - out << edge->src().block()->unique_id() - << " -> " - << edge->dst().block()->unique_id() << std::endl; + for (edge_viter_t edge = edges.begin(); edge != edges.end(); ++edge) { + out << edge->src().block()->unique_id() << " -> " + << edge->dst().block()->unique_id() << std::endl; } out << "}" << std::endl; return out.str(); - } +} } /* namespace gr */ diff --git a/gnuradio-runtime/lib/hier_block2.cc b/gnuradio-runtime/lib/hier_block2.cc index 8ebbbda587..4c6414c465 100644 --- a/gnuradio-runtime/lib/hier_block2.cc +++ b/gnuradio-runtime/lib/hier_block2.cc @@ -34,251 +34,211 @@ namespace gr { #define GR_HIER_BLOCK2_DEBUG 0 - hier_block2_sptr - make_hier_block2(const std::string &name, - gr::io_signature::sptr input_signature, - gr::io_signature::sptr output_signature) - { - return gnuradio::get_initial_sptr - (new hier_block2(name, input_signature, output_signature)); - } - - hier_block2::hier_block2(const std::string &name, - gr::io_signature::sptr input_signature, - gr::io_signature::sptr output_signature) +hier_block2_sptr make_hier_block2(const std::string& name, + gr::io_signature::sptr input_signature, + gr::io_signature::sptr output_signature) +{ + return gnuradio::get_initial_sptr( + new hier_block2(name, input_signature, output_signature)); +} + +hier_block2::hier_block2(const std::string& name, + gr::io_signature::sptr input_signature, + gr::io_signature::sptr output_signature) : basic_block(name, input_signature, output_signature), d_detail(new hier_block2_detail(this)), hier_message_ports_in(pmt::PMT_NIL), hier_message_ports_out(pmt::PMT_NIL) - { +{ // This bit of magic ensures that self() works in the constructors of derived classes. gnuradio::detail::sptr_magic::create_and_stash_initial_sptr(this); - } +} - hier_block2::~hier_block2() - { +hier_block2::~hier_block2() +{ disconnect_all(); gnuradio::detail::sptr_magic::cancel_initial_sptr(this); delete d_detail; - } +} - hier_block2::opaque_self - hier_block2::self() - { - return shared_from_this(); - } +hier_block2::opaque_self hier_block2::self() { return shared_from_this(); } - hier_block2_sptr - hier_block2::to_hier_block2() - { +hier_block2_sptr hier_block2::to_hier_block2() +{ return cast_to_hier_block2_sptr(shared_from_this()); - } - - void - hier_block2::connect(basic_block_sptr block) - { - d_detail->connect(block); - } - - void - hier_block2::connect(basic_block_sptr src, int src_port, - basic_block_sptr dst, int dst_port) - { +} + +void hier_block2::connect(basic_block_sptr block) { d_detail->connect(block); } + +void hier_block2::connect(basic_block_sptr src, + int src_port, + basic_block_sptr dst, + int dst_port) +{ d_detail->connect(src, src_port, dst, dst_port); - } - - void - hier_block2::msg_connect(basic_block_sptr src, pmt::pmt_t srcport, - basic_block_sptr dst, pmt::pmt_t dstport) - { - if(!pmt::is_symbol(srcport)) { - throw std::runtime_error("bad port id"); +} + +void hier_block2::msg_connect(basic_block_sptr src, + pmt::pmt_t srcport, + basic_block_sptr dst, + pmt::pmt_t dstport) +{ + if (!pmt::is_symbol(srcport)) { + throw std::runtime_error("bad port id"); } d_detail->msg_connect(src, srcport, dst, dstport); - } +} - void - hier_block2::msg_connect(basic_block_sptr src, std::string srcport, - basic_block_sptr dst, std::string dstport) - { +void hier_block2::msg_connect(basic_block_sptr src, + std::string srcport, + basic_block_sptr dst, + std::string dstport) +{ d_detail->msg_connect(src, pmt::mp(srcport), dst, pmt::mp(dstport)); - } - - void - hier_block2::msg_disconnect(basic_block_sptr src, pmt::pmt_t srcport, - basic_block_sptr dst, pmt::pmt_t dstport) - { - if(!pmt::is_symbol(srcport)) { - throw std::runtime_error("bad port id"); +} + +void hier_block2::msg_disconnect(basic_block_sptr src, + pmt::pmt_t srcport, + basic_block_sptr dst, + pmt::pmt_t dstport) +{ + if (!pmt::is_symbol(srcport)) { + throw std::runtime_error("bad port id"); } d_detail->msg_disconnect(src, srcport, dst, dstport); - } +} - void - hier_block2::msg_disconnect(basic_block_sptr src, std::string srcport, - basic_block_sptr dst, std::string dstport) - { +void hier_block2::msg_disconnect(basic_block_sptr src, + std::string srcport, + basic_block_sptr dst, + std::string dstport) +{ d_detail->msg_disconnect(src, pmt::mp(srcport), dst, pmt::mp(dstport)); - } - - void - hier_block2::disconnect(basic_block_sptr block) - { - d_detail->disconnect(block); - } - - void - hier_block2::disconnect(basic_block_sptr src, int src_port, - basic_block_sptr dst, int dst_port) - { +} + +void hier_block2::disconnect(basic_block_sptr block) { d_detail->disconnect(block); } + +void hier_block2::disconnect(basic_block_sptr src, + int src_port, + basic_block_sptr dst, + int dst_port) +{ d_detail->disconnect(src, src_port, dst, dst_port); - } - - void - hier_block2::disconnect_all() - { - d_detail->disconnect_all(); - } - - void - hier_block2::lock() - { - d_detail->lock(); - } - - void - hier_block2::unlock() - { - d_detail->unlock(); - } - - flat_flowgraph_sptr - hier_block2::flatten() const - { +} + +void hier_block2::disconnect_all() { d_detail->disconnect_all(); } + +void hier_block2::lock() { d_detail->lock(); } + +void hier_block2::unlock() { d_detail->unlock(); } + +flat_flowgraph_sptr hier_block2::flatten() const +{ flat_flowgraph_sptr new_ffg = make_flat_flowgraph(); d_detail->flatten_aux(new_ffg); return new_ffg; - } +} - void - hier_block2::set_processor_affinity(const std::vector<int> &mask) - { +void hier_block2::set_processor_affinity(const std::vector<int>& mask) +{ d_detail->set_processor_affinity(mask); - } +} - void - hier_block2::unset_processor_affinity() - { - d_detail->unset_processor_affinity(); - } +void hier_block2::unset_processor_affinity() { d_detail->unset_processor_affinity(); } - std::vector<int> - hier_block2::processor_affinity() - { +std::vector<int> hier_block2::processor_affinity() +{ return d_detail->processor_affinity(); - } - - void - hier_block2::set_log_level(std::string level) - { - d_detail->set_log_level(level); - } - - std::string - hier_block2::log_level() - { - return d_detail->log_level(); - } - - std::string - dot_graph(hier_block2_sptr hierblock2) - { +} + +void hier_block2::set_log_level(std::string level) { d_detail->set_log_level(level); } + +std::string hier_block2::log_level() { return d_detail->log_level(); } + +std::string dot_graph(hier_block2_sptr hierblock2) +{ return dot_graph_fg(hierblock2->flatten()); - } +} - int - hier_block2::max_output_buffer(size_t port) - { - if(port >= d_detail->d_max_output_buffer.size()) - throw std::invalid_argument("hier_block2::max_output_buffer(int): port out of range."); +int hier_block2::max_output_buffer(size_t port) +{ + if (port >= d_detail->d_max_output_buffer.size()) + throw std::invalid_argument( + "hier_block2::max_output_buffer(int): port out of range."); return d_detail->d_max_output_buffer[port]; - } - - void - hier_block2::set_max_output_buffer(int max_output_buffer) - { - if(output_signature()->max_streams()>0) - { - if(d_detail->d_max_output_buffer.size() == 0) - throw std::length_error("hier_block2::set_max_output_buffer(int): out_sig greater than zero, buff_vect isn't"); - for(int idx = 0; idx < output_signature()->max_streams(); idx++){ - d_detail->d_max_output_buffer[idx] = max_output_buffer; - } +} + +void hier_block2::set_max_output_buffer(int max_output_buffer) +{ + if (output_signature()->max_streams() > 0) { + if (d_detail->d_max_output_buffer.size() == 0) + throw std::length_error("hier_block2::set_max_output_buffer(int): out_sig " + "greater than zero, buff_vect isn't"); + for (int idx = 0; idx < output_signature()->max_streams(); idx++) { + d_detail->d_max_output_buffer[idx] = max_output_buffer; + } } - } - - void - hier_block2::set_max_output_buffer(size_t port, int max_output_buffer) - { - if(port >= d_detail->d_max_output_buffer.size()) - throw std::invalid_argument("hier_block2::set_max_output_buffer(size_t,int): port out of range."); - else{ - d_detail->d_max_output_buffer[port] = max_output_buffer; +} + +void hier_block2::set_max_output_buffer(size_t port, int max_output_buffer) +{ + if (port >= d_detail->d_max_output_buffer.size()) + throw std::invalid_argument( + "hier_block2::set_max_output_buffer(size_t,int): port out of range."); + else { + d_detail->d_max_output_buffer[port] = max_output_buffer; } - } +} - int - hier_block2::min_output_buffer(size_t port) - { - if(port >= d_detail->d_min_output_buffer.size()) - throw std::invalid_argument("hier_block2::min_output_buffer(size_t): port out of range."); +int hier_block2::min_output_buffer(size_t port) +{ + if (port >= d_detail->d_min_output_buffer.size()) + throw std::invalid_argument( + "hier_block2::min_output_buffer(size_t): port out of range."); return d_detail->d_min_output_buffer[port]; - } - - void - hier_block2::set_min_output_buffer(int min_output_buffer) - { - if(output_signature()->max_streams()>0) - { - if(d_detail->d_min_output_buffer.size() == 0) - throw std::length_error("hier_block2::set_min_output_buffer(int): out_sig greater than zero, buff_vect isn't"); - for(int idx = 0; idx < output_signature()->max_streams(); idx++){ - d_detail->d_min_output_buffer[idx] = min_output_buffer; - } +} + +void hier_block2::set_min_output_buffer(int min_output_buffer) +{ + if (output_signature()->max_streams() > 0) { + if (d_detail->d_min_output_buffer.size() == 0) + throw std::length_error("hier_block2::set_min_output_buffer(int): out_sig " + "greater than zero, buff_vect isn't"); + for (int idx = 0; idx < output_signature()->max_streams(); idx++) { + d_detail->d_min_output_buffer[idx] = min_output_buffer; + } } - } - - void - hier_block2::set_min_output_buffer(size_t port, int min_output_buffer) - { - if(port >= d_detail->d_min_output_buffer.size()) - throw std::invalid_argument("hier_block2::set_min_output_buffer(size_t,int): port out of range."); - else{ - d_detail->d_min_output_buffer[port] = min_output_buffer; +} + +void hier_block2::set_min_output_buffer(size_t port, int min_output_buffer) +{ + if (port >= d_detail->d_min_output_buffer.size()) + throw std::invalid_argument( + "hier_block2::set_min_output_buffer(size_t,int): port out of range."); + else { + d_detail->d_min_output_buffer[port] = min_output_buffer; } - } - - bool - hier_block2::all_min_output_buffer_p(void) - { - if(!d_detail->d_min_output_buffer.size()) - return false; - for(size_t idx = 1; idx < d_detail->d_min_output_buffer.size(); idx++){ - if(d_detail->d_min_output_buffer[0] != d_detail->d_min_output_buffer[idx]) +} + +bool hier_block2::all_min_output_buffer_p(void) +{ + if (!d_detail->d_min_output_buffer.size()) return false; + for (size_t idx = 1; idx < d_detail->d_min_output_buffer.size(); idx++) { + if (d_detail->d_min_output_buffer[0] != d_detail->d_min_output_buffer[idx]) + return false; } return true; - } - bool - hier_block2::all_max_output_buffer_p(void) - { - if(!d_detail->d_max_output_buffer.size()) - return false; - for(size_t idx = 1; idx < d_detail->d_max_output_buffer.size(); idx++){ - if(d_detail->d_max_output_buffer[0] != d_detail->d_max_output_buffer[idx]) +} +bool hier_block2::all_max_output_buffer_p(void) +{ + if (!d_detail->d_max_output_buffer.size()) return false; + for (size_t idx = 1; idx < d_detail->d_max_output_buffer.size(); idx++) { + if (d_detail->d_max_output_buffer[0] != d_detail->d_max_output_buffer[idx]) + return false; } return true; - } +} } /* namespace gr */ diff --git a/gnuradio-runtime/lib/hier_block2_detail.cc b/gnuradio-runtime/lib/hier_block2_detail.cc index dbf519b6ef..38925330cb 100644 --- a/gnuradio-runtime/lib/hier_block2_detail.cc +++ b/gnuradio-runtime/lib/hier_block2_detail.cc @@ -35,141 +35,145 @@ namespace gr { #define HIER_BLOCK2_DETAIL_DEBUG 0 - hier_block2_detail::hier_block2_detail(hier_block2 *owner) - : d_owner(owner), - d_parent_detail(0), - d_fg(make_flowgraph()) - { +hier_block2_detail::hier_block2_detail(hier_block2* owner) + : d_owner(owner), d_parent_detail(0), d_fg(make_flowgraph()) +{ int min_inputs = owner->input_signature()->min_streams(); int max_inputs = owner->input_signature()->max_streams(); int min_outputs = owner->output_signature()->min_streams(); int max_outputs = owner->output_signature()->max_streams(); - if(max_inputs == io_signature::IO_INFINITE || - max_outputs == io_signature::IO_INFINITE || - (min_inputs != max_inputs) ||(min_outputs != max_outputs) ) { - std::stringstream msg; - msg << "Hierarchical blocks do not yet support arbitrary or" - << " variable numbers of inputs or outputs (" << d_owner->name() << ")"; - throw std::runtime_error(msg.str()); + if (max_inputs == io_signature::IO_INFINITE || + max_outputs == io_signature::IO_INFINITE || (min_inputs != max_inputs) || + (min_outputs != max_outputs)) { + std::stringstream msg; + msg << "Hierarchical blocks do not yet support arbitrary or" + << " variable numbers of inputs or outputs (" << d_owner->name() << ")"; + throw std::runtime_error(msg.str()); } d_inputs = std::vector<endpoint_vector_t>(max_inputs); d_outputs = endpoint_vector_t(max_outputs); - d_max_output_buffer = std::vector<size_t>(std::max(max_outputs,1), 0); - d_min_output_buffer = std::vector<size_t>(std::max(max_outputs,1), 0); - } + d_max_output_buffer = std::vector<size_t>(std::max(max_outputs, 1), 0); + d_min_output_buffer = std::vector<size_t>(std::max(max_outputs, 1), 0); +} - hier_block2_detail::~hier_block2_detail() - { +hier_block2_detail::~hier_block2_detail() +{ d_owner = 0; // Don't use delete, we didn't allocate - } +} - void - hier_block2_detail::connect(basic_block_sptr block) - { +void hier_block2_detail::connect(basic_block_sptr block) +{ std::stringstream msg; // Check if duplicate - if(std::find(d_blocks.begin(), d_blocks.end(), block) != d_blocks.end()) { - msg << "Block " << block << " already connected."; - throw std::invalid_argument(msg.str()); + if (std::find(d_blocks.begin(), d_blocks.end(), block) != d_blocks.end()) { + msg << "Block " << block << " already connected."; + throw std::invalid_argument(msg.str()); } // Check if has inputs or outputs - if(block->input_signature()->max_streams() != 0 || - block->output_signature()->max_streams() != 0) { - msg << "Block " << block << " must not have any input or output ports"; - throw std::invalid_argument(msg.str()); + if (block->input_signature()->max_streams() != 0 || + block->output_signature()->max_streams() != 0) { + msg << "Block " << block << " must not have any input or output ports"; + throw std::invalid_argument(msg.str()); } hier_block2_sptr hblock(cast_to_hier_block2_sptr(block)); - if(hblock && hblock.get() != d_owner) { - if(HIER_BLOCK2_DETAIL_DEBUG) - std::cout << "connect: block is hierarchical, setting parent to " << this << std::endl; - hblock->d_detail->d_parent_detail = this; + if (hblock && hblock.get() != d_owner) { + if (HIER_BLOCK2_DETAIL_DEBUG) + std::cout << "connect: block is hierarchical, setting parent to " << this + << std::endl; + hblock->d_detail->d_parent_detail = this; } d_blocks.push_back(block); - } +} - void - hier_block2_detail::connect(basic_block_sptr src, int src_port, - basic_block_sptr dst, int dst_port) - { +void hier_block2_detail::connect(basic_block_sptr src, + int src_port, + basic_block_sptr dst, + int dst_port) +{ std::stringstream msg; - if(HIER_BLOCK2_DETAIL_DEBUG) - std::cout << "connecting: " << endpoint(src, src_port) - << " -> " << endpoint(dst, dst_port) << std::endl; + if (HIER_BLOCK2_DETAIL_DEBUG) + std::cout << "connecting: " << endpoint(src, src_port) << " -> " + << endpoint(dst, dst_port) << std::endl; - if(src.get() == dst.get()) - throw std::invalid_argument("connect: src and destination blocks cannot be the same"); + if (src.get() == dst.get()) + throw std::invalid_argument( + "connect: src and destination blocks cannot be the same"); hier_block2_sptr src_block(cast_to_hier_block2_sptr(src)); hier_block2_sptr dst_block(cast_to_hier_block2_sptr(dst)); - if(src_block && src.get() != d_owner) { - if(HIER_BLOCK2_DETAIL_DEBUG) - std::cout << "connect: src is hierarchical, setting parent to " << this << std::endl; - src_block->d_detail->d_parent_detail = this; + if (src_block && src.get() != d_owner) { + if (HIER_BLOCK2_DETAIL_DEBUG) + std::cout << "connect: src is hierarchical, setting parent to " << this + << std::endl; + src_block->d_detail->d_parent_detail = this; } - if(dst_block && dst.get() != d_owner) { - if(HIER_BLOCK2_DETAIL_DEBUG) - std::cout << "connect: dst is hierarchical, setting parent to " << this << std::endl; - dst_block->d_detail->d_parent_detail = this; + if (dst_block && dst.get() != d_owner) { + if (HIER_BLOCK2_DETAIL_DEBUG) + std::cout << "connect: dst is hierarchical, setting parent to " << this + << std::endl; + dst_block->d_detail->d_parent_detail = this; } // Connections to block inputs or outputs int max_port; - if(src.get() == d_owner) { - max_port = src->input_signature()->max_streams(); - if((max_port != -1 && (src_port >= max_port)) || src_port < 0) { - msg << "source port " << src_port << " out of range for " << src; - throw std::invalid_argument(msg.str()); - } + if (src.get() == d_owner) { + max_port = src->input_signature()->max_streams(); + if ((max_port != -1 && (src_port >= max_port)) || src_port < 0) { + msg << "source port " << src_port << " out of range for " << src; + throw std::invalid_argument(msg.str()); + } - return connect_input(src_port, dst_port, dst); + return connect_input(src_port, dst_port, dst); } - if(dst.get() == d_owner) { - max_port = dst->output_signature()->max_streams(); - if((max_port != -1 && (dst_port >= max_port)) || dst_port < 0) { - msg << "destination port " << dst_port << " out of range for " << dst; - throw std::invalid_argument(msg.str()); - } + if (dst.get() == d_owner) { + max_port = dst->output_signature()->max_streams(); + if ((max_port != -1 && (dst_port >= max_port)) || dst_port < 0) { + msg << "destination port " << dst_port << " out of range for " << dst; + throw std::invalid_argument(msg.str()); + } - return connect_output(dst_port, src_port, src); + return connect_output(dst_port, src_port, src); } // Internal connections d_fg->connect(src, src_port, dst, dst_port); // TODO: connects to NC - } +} - void - hier_block2_detail::msg_connect(basic_block_sptr src, pmt::pmt_t srcport, - basic_block_sptr dst, pmt::pmt_t dstport) - { - if(HIER_BLOCK2_DETAIL_DEBUG) - std::cout << "connecting message port..." << std::endl; +void hier_block2_detail::msg_connect(basic_block_sptr src, + pmt::pmt_t srcport, + basic_block_sptr dst, + pmt::pmt_t dstport) +{ + if (HIER_BLOCK2_DETAIL_DEBUG) + std::cout << "connecting message port..." << std::endl; // add block uniquely to list to internal blocks - if(std::find(d_blocks.begin(), d_blocks.end(), dst) == d_blocks.end()){ - d_blocks.push_back(src); - d_blocks.push_back(dst); + if (std::find(d_blocks.begin(), d_blocks.end(), dst) == d_blocks.end()) { + d_blocks.push_back(src); + d_blocks.push_back(dst); } - bool hier_in=false, hier_out=false; - if(d_owner == src.get()){ + bool hier_in = false, hier_out = false; + if (d_owner == src.get()) { hier_out = src->message_port_is_hier_in(srcport); - } else if (d_owner == dst.get()){ - hier_in = dst->message_port_is_hier_out(dstport);; + } else if (d_owner == dst.get()) { + hier_in = dst->message_port_is_hier_out(dstport); + ; } else { hier_out = src->message_port_is_hier_out(srcport); hier_in = dst->message_port_is_hier_in(dstport); @@ -178,45 +182,50 @@ namespace gr { hier_block2_sptr src_block(cast_to_hier_block2_sptr(src)); hier_block2_sptr dst_block(cast_to_hier_block2_sptr(dst)); - if(src_block && src.get() != d_owner) { - if(HIER_BLOCK2_DETAIL_DEBUG) - std::cout << "msg_connect: src is hierarchical, setting parent to " << this << std::endl; - src_block->d_detail->d_parent_detail = this; + if (src_block && src.get() != d_owner) { + if (HIER_BLOCK2_DETAIL_DEBUG) + std::cout << "msg_connect: src is hierarchical, setting parent to " << this + << std::endl; + src_block->d_detail->d_parent_detail = this; } - if(dst_block && dst.get() != d_owner) { - if(HIER_BLOCK2_DETAIL_DEBUG) - std::cout << "msg_connect: dst is hierarchical, setting parent to " << this << std::endl; - dst_block->d_detail->d_parent_detail = this; + if (dst_block && dst.get() != d_owner) { + if (HIER_BLOCK2_DETAIL_DEBUG) + std::cout << "msg_connect: dst is hierarchical, setting parent to " << this + << std::endl; + dst_block->d_detail->d_parent_detail = this; } // add edge for this message connection - if(HIER_BLOCK2_DETAIL_DEBUG) - std::cout << boost::format("msg_connect( (%s, %s, %d), (%s, %s, %d) )\n") % \ - src % srcport % hier_out % - dst % dstport % hier_in; - d_fg->connect(msg_endpoint(src, srcport, hier_out), msg_endpoint(dst, dstport, hier_in)); - } - - void - hier_block2_detail::msg_disconnect(basic_block_sptr src, pmt::pmt_t srcport, - basic_block_sptr dst, pmt::pmt_t dstport) - { - if(HIER_BLOCK2_DETAIL_DEBUG) - std::cout << "disconnecting message port..." << std::endl; + if (HIER_BLOCK2_DETAIL_DEBUG) + std::cout << boost::format("msg_connect( (%s, %s, %d), (%s, %s, %d) )\n") % src % + srcport % hier_out % dst % dstport % hier_in; + d_fg->connect(msg_endpoint(src, srcport, hier_out), + msg_endpoint(dst, dstport, hier_in)); +} + +void hier_block2_detail::msg_disconnect(basic_block_sptr src, + pmt::pmt_t srcport, + basic_block_sptr dst, + pmt::pmt_t dstport) +{ + if (HIER_BLOCK2_DETAIL_DEBUG) + std::cout << "disconnecting message port..." << std::endl; // remove edge for this message connection - bool hier_in=false, hier_out=false; - if(d_owner == src.get()){ + bool hier_in = false, hier_out = false; + if (d_owner == src.get()) { hier_out = src->message_port_is_hier_in(srcport); - } else if (d_owner == dst.get()){ - hier_in = dst->message_port_is_hier_out(dstport);; + } else if (d_owner == dst.get()) { + hier_in = dst->message_port_is_hier_out(dstport); + ; } else { hier_out = src->message_port_is_hier_out(srcport); hier_in = dst->message_port_is_hier_in(dstport); } - d_fg->disconnect(msg_endpoint(src, srcport, hier_out), msg_endpoint(dst, dstport, hier_in)); + d_fg->disconnect(msg_endpoint(src, srcport, hier_out), + msg_endpoint(dst, dstport, hier_in)); hier_block2_sptr src_block(cast_to_hier_block2_sptr(src)); hier_block2_sptr dst_block(cast_to_hier_block2_sptr(dst)); @@ -233,7 +242,8 @@ namespace gr { } if (dst_block && dst.get() != d_owner) { - // if the destination is hier, we need to resolve the endpoint before calling unsub + // if the destination is hier, we need to resolve the endpoint before calling + // unsub msg_edge_vector_t edges = dst_block->d_detail->d_fg->msg_edges(); for (msg_edge_viter_t it = edges.begin(); it != edges.end(); ++it) { if ((*it).src().block() == dst) { @@ -245,276 +255,262 @@ namespace gr { // unregister the subscription - if already subscribed src->message_port_unsub(srcport, pmt::cons(dst->alias_pmt(), dstport)); +} - } - - void - hier_block2_detail::disconnect(basic_block_sptr block) - { +void hier_block2_detail::disconnect(basic_block_sptr block) +{ // Check on singleton list - for(basic_block_viter_t p = d_blocks.begin(); p != d_blocks.end(); p++) { - if(*p == block) { - d_blocks.erase(p); - - hier_block2_sptr hblock(cast_to_hier_block2_sptr(block)); - if(block && block.get() != d_owner) { - if(HIER_BLOCK2_DETAIL_DEBUG) - std::cout << "disconnect: block is hierarchical, clearing parent" << std::endl; - hblock->d_detail->d_parent_detail = 0; - } + for (basic_block_viter_t p = d_blocks.begin(); p != d_blocks.end(); p++) { + if (*p == block) { + d_blocks.erase(p); + + hier_block2_sptr hblock(cast_to_hier_block2_sptr(block)); + if (block && block.get() != d_owner) { + if (HIER_BLOCK2_DETAIL_DEBUG) + std::cout << "disconnect: block is hierarchical, clearing parent" + << std::endl; + hblock->d_detail->d_parent_detail = 0; + } - return; - } + return; + } } // Otherwise find all edges containing block edge_vector_t edges, tmp = d_fg->edges(); edge_vector_t::iterator p; - for(p = tmp.begin(); p != tmp.end(); p++) { - if((*p).src().block() == block || (*p).dst().block() == block) { - edges.push_back(*p); + for (p = tmp.begin(); p != tmp.end(); p++) { + if ((*p).src().block() == block || (*p).dst().block() == block) { + edges.push_back(*p); - if(HIER_BLOCK2_DETAIL_DEBUG) - std::cout << "disconnect: block found in edge " << (*p) << std::endl; - } + if (HIER_BLOCK2_DETAIL_DEBUG) + std::cout << "disconnect: block found in edge " << (*p) << std::endl; + } } - if(edges.size() == 0) { - std::stringstream msg; - msg << "cannot disconnect block " << block << ", not found"; - throw std::invalid_argument(msg.str()); + if (edges.size() == 0) { + std::stringstream msg; + msg << "cannot disconnect block " << block << ", not found"; + throw std::invalid_argument(msg.str()); } - for(p = edges.begin(); p != edges.end(); p++) { - disconnect((*p).src().block(), (*p).src().port(), - (*p).dst().block(), (*p).dst().port()); + for (p = edges.begin(); p != edges.end(); p++) { + disconnect( + (*p).src().block(), (*p).src().port(), (*p).dst().block(), (*p).dst().port()); } - } +} - void - hier_block2_detail::disconnect(basic_block_sptr src, int src_port, - basic_block_sptr dst, int dst_port) - { - if(HIER_BLOCK2_DETAIL_DEBUG) - std::cout << "disconnecting: " << endpoint(src, src_port) - << " -> " << endpoint(dst, dst_port) << std::endl; +void hier_block2_detail::disconnect(basic_block_sptr src, + int src_port, + basic_block_sptr dst, + int dst_port) +{ + if (HIER_BLOCK2_DETAIL_DEBUG) + std::cout << "disconnecting: " << endpoint(src, src_port) << " -> " + << endpoint(dst, dst_port) << std::endl; - if(src.get() == dst.get()) - throw std::invalid_argument("disconnect: source and destination blocks cannot be the same"); + if (src.get() == dst.get()) + throw std::invalid_argument( + "disconnect: source and destination blocks cannot be the same"); hier_block2_sptr src_block(cast_to_hier_block2_sptr(src)); hier_block2_sptr dst_block(cast_to_hier_block2_sptr(dst)); - if(src_block && src.get() != d_owner) { - if(HIER_BLOCK2_DETAIL_DEBUG) - std::cout << "disconnect: src is hierarchical, clearing parent" << std::endl; - src_block->d_detail->d_parent_detail = 0; + if (src_block && src.get() != d_owner) { + if (HIER_BLOCK2_DETAIL_DEBUG) + std::cout << "disconnect: src is hierarchical, clearing parent" << std::endl; + src_block->d_detail->d_parent_detail = 0; } - if(dst_block && dst.get() != d_owner) { - if(HIER_BLOCK2_DETAIL_DEBUG) - std::cout << "disconnect: dst is hierarchical, clearing parent" << std::endl; - dst_block->d_detail->d_parent_detail = 0; + if (dst_block && dst.get() != d_owner) { + if (HIER_BLOCK2_DETAIL_DEBUG) + std::cout << "disconnect: dst is hierarchical, clearing parent" << std::endl; + dst_block->d_detail->d_parent_detail = 0; } - if(src.get() == d_owner) - return disconnect_input(src_port, dst_port, dst); + if (src.get() == d_owner) + return disconnect_input(src_port, dst_port, dst); - if(dst.get() == d_owner) - return disconnect_output(dst_port, src_port, src); + if (dst.get() == d_owner) + return disconnect_output(dst_port, src_port, src); // Internal connections d_fg->disconnect(src, src_port, dst, dst_port); - } +} - void - hier_block2_detail::refresh_io_signature() - { - int min_inputs = d_owner->input_signature()->min_streams(); - int max_inputs = d_owner->input_signature()->max_streams(); +void hier_block2_detail::refresh_io_signature() +{ + int min_inputs = d_owner->input_signature()->min_streams(); + int max_inputs = d_owner->input_signature()->max_streams(); int min_outputs = d_owner->output_signature()->min_streams(); int max_outputs = d_owner->output_signature()->max_streams(); - if(max_inputs == io_signature::IO_INFINITE || - max_outputs == io_signature::IO_INFINITE || - (min_inputs != max_inputs) ||(min_outputs != max_outputs) ) { - std::stringstream msg; - msg << "Hierarchical blocks do not yet support arbitrary or" - << " variable numbers of inputs or outputs (" << d_owner->name() << ")"; - throw std::runtime_error(msg.str()); + if (max_inputs == io_signature::IO_INFINITE || + max_outputs == io_signature::IO_INFINITE || (min_inputs != max_inputs) || + (min_outputs != max_outputs)) { + std::stringstream msg; + msg << "Hierarchical blocks do not yet support arbitrary or" + << " variable numbers of inputs or outputs (" << d_owner->name() << ")"; + throw std::runtime_error(msg.str()); } // Check for # input change - if ((signed)d_inputs.size() != max_inputs) - { - d_inputs.resize(max_inputs); + if ((signed)d_inputs.size() != max_inputs) { + d_inputs.resize(max_inputs); } // Check for # output change - if ((signed)d_outputs.size() != max_outputs) - { - d_outputs.resize(max_outputs); - d_min_output_buffer.resize(max_outputs, 0); - d_max_output_buffer.resize(max_outputs, 0); - } - } - - void - hier_block2_detail::connect_input(int my_port, int port, - basic_block_sptr block) - { + if ((signed)d_outputs.size() != max_outputs) { + d_outputs.resize(max_outputs); + d_min_output_buffer.resize(max_outputs, 0); + d_max_output_buffer.resize(max_outputs, 0); + } +} + +void hier_block2_detail::connect_input(int my_port, int port, basic_block_sptr block) +{ std::stringstream msg; refresh_io_signature(); - if(my_port < 0 || my_port >= (signed)d_inputs.size()) { - msg << "input port " << my_port << " out of range for " << block; - throw std::invalid_argument(msg.str()); + if (my_port < 0 || my_port >= (signed)d_inputs.size()) { + msg << "input port " << my_port << " out of range for " << block; + throw std::invalid_argument(msg.str()); } - endpoint_vector_t &endps = d_inputs[my_port]; + endpoint_vector_t& endps = d_inputs[my_port]; endpoint endp(block, port); endpoint_viter_t p = std::find(endps.begin(), endps.end(), endp); - if(p != endps.end()) { - msg << "external input port " << my_port << " already wired to " << endp; - throw std::invalid_argument(msg.str()); + if (p != endps.end()) { + msg << "external input port " << my_port << " already wired to " << endp; + throw std::invalid_argument(msg.str()); } endps.push_back(endp); - } +} - void - hier_block2_detail::connect_output(int my_port, int port, - basic_block_sptr block) - { +void hier_block2_detail::connect_output(int my_port, int port, basic_block_sptr block) +{ std::stringstream msg; refresh_io_signature(); - if(my_port < 0 || my_port >= (signed)d_outputs.size()) { - msg << "output port " << my_port << " out of range for " << block; - throw std::invalid_argument(msg.str()); + if (my_port < 0 || my_port >= (signed)d_outputs.size()) { + msg << "output port " << my_port << " out of range for " << block; + throw std::invalid_argument(msg.str()); } - if(d_outputs[my_port].block()) { - msg << "external output port " << my_port << " already connected from " - << d_outputs[my_port]; - throw std::invalid_argument(msg.str()); + if (d_outputs[my_port].block()) { + msg << "external output port " << my_port << " already connected from " + << d_outputs[my_port]; + throw std::invalid_argument(msg.str()); } d_outputs[my_port] = endpoint(block, port); - } +} - void - hier_block2_detail::disconnect_input(int my_port, int port, - basic_block_sptr block) - { +void hier_block2_detail::disconnect_input(int my_port, int port, basic_block_sptr block) +{ std::stringstream msg; refresh_io_signature(); - if(my_port < 0 || my_port >= (signed)d_inputs.size()) { - msg << "input port number " << my_port << " out of range for " << block; - throw std::invalid_argument(msg.str()); + if (my_port < 0 || my_port >= (signed)d_inputs.size()) { + msg << "input port number " << my_port << " out of range for " << block; + throw std::invalid_argument(msg.str()); } - endpoint_vector_t &endps = d_inputs[my_port]; + endpoint_vector_t& endps = d_inputs[my_port]; endpoint endp(block, port); endpoint_viter_t p = std::find(endps.begin(), endps.end(), endp); - if(p == endps.end()) { - msg << "external input port " << my_port << " not connected to " << endp; - throw std::invalid_argument(msg.str()); + if (p == endps.end()) { + msg << "external input port " << my_port << " not connected to " << endp; + throw std::invalid_argument(msg.str()); } endps.erase(p); - } +} - void - hier_block2_detail::disconnect_output(int my_port, int port, - basic_block_sptr block) - { +void hier_block2_detail::disconnect_output(int my_port, int port, basic_block_sptr block) +{ std::stringstream msg; refresh_io_signature(); - if(my_port < 0 || my_port >= (signed)d_outputs.size()) { - msg << "output port number " << my_port << " out of range for " << block; - throw std::invalid_argument(msg.str()); + if (my_port < 0 || my_port >= (signed)d_outputs.size()) { + msg << "output port number " << my_port << " out of range for " << block; + throw std::invalid_argument(msg.str()); } - if(d_outputs[my_port].block() != block) { - msg << "block " << block << " not assigned to output " - << my_port << ", can't disconnect"; - throw std::invalid_argument(msg.str()); + if (d_outputs[my_port].block() != block) { + msg << "block " << block << " not assigned to output " << my_port + << ", can't disconnect"; + throw std::invalid_argument(msg.str()); } d_outputs[my_port] = endpoint(); - } +} - endpoint_vector_t - hier_block2_detail::resolve_port(int port, bool is_input) - { +endpoint_vector_t hier_block2_detail::resolve_port(int port, bool is_input) +{ std::stringstream msg; - if(HIER_BLOCK2_DETAIL_DEBUG) - std::cout << "Resolving port " << port << " as an " - << (is_input ? "input" : "output") - << " of " << d_owner->name() << std::endl; + if (HIER_BLOCK2_DETAIL_DEBUG) + std::cout << "Resolving port " << port << " as an " + << (is_input ? "input" : "output") << " of " << d_owner->name() + << std::endl; endpoint_vector_t result; - if(is_input) { - if(port < 0 || port >= (signed)d_inputs.size()) { - msg << "resolve_port: hierarchical block '" << d_owner->name() - << "': input " << port << " is out of range"; - throw std::runtime_error(msg.str()); - } + if (is_input) { + if (port < 0 || port >= (signed)d_inputs.size()) { + msg << "resolve_port: hierarchical block '" << d_owner->name() << "': input " + << port << " is out of range"; + throw std::runtime_error(msg.str()); + } - if(d_inputs[port].empty()) { - msg << "resolve_port: hierarchical block '" << d_owner->name() - << "': input " << port << " is not connected internally"; - throw std::runtime_error(msg.str()); - } + if (d_inputs[port].empty()) { + msg << "resolve_port: hierarchical block '" << d_owner->name() << "': input " + << port << " is not connected internally"; + throw std::runtime_error(msg.str()); + } - endpoint_vector_t &endps = d_inputs[port]; - endpoint_viter_t p; - for(p = endps.begin(); p != endps.end(); p++) { - endpoint_vector_t tmp = resolve_endpoint(*p, true); - std::copy(tmp.begin(), tmp.end(), back_inserter(result)); - } - } - else { - if(port < 0 || port >= (signed)d_outputs.size()) { - msg << "resolve_port: hierarchical block '" << d_owner->name() - << "': output " << port << " is out of range"; - throw std::runtime_error(msg.str()); - } + endpoint_vector_t& endps = d_inputs[port]; + endpoint_viter_t p; + for (p = endps.begin(); p != endps.end(); p++) { + endpoint_vector_t tmp = resolve_endpoint(*p, true); + std::copy(tmp.begin(), tmp.end(), back_inserter(result)); + } + } else { + if (port < 0 || port >= (signed)d_outputs.size()) { + msg << "resolve_port: hierarchical block '" << d_owner->name() << "': output " + << port << " is out of range"; + throw std::runtime_error(msg.str()); + } - if(d_outputs[port] == endpoint()) { - msg << "resolve_port: hierarchical block '" << d_owner->name() - << "': output " << port << " is not connected internally"; - throw std::runtime_error(msg.str()); - } + if (d_outputs[port] == endpoint()) { + msg << "resolve_port: hierarchical block '" << d_owner->name() << "': output " + << port << " is not connected internally"; + throw std::runtime_error(msg.str()); + } - result = resolve_endpoint(d_outputs[port], false); + result = resolve_endpoint(d_outputs[port], false); } - if(result.empty()) { - msg << "resolve_port: hierarchical block '" << d_owner->name() - << "': unable to resolve " - << (is_input ? "input port " : "output port ") - << port; - throw std::runtime_error(msg.str()); + if (result.empty()) { + msg << "resolve_port: hierarchical block '" << d_owner->name() + << "': unable to resolve " << (is_input ? "input port " : "output port ") + << port; + throw std::runtime_error(msg.str()); } return result; - } +} - void - hier_block2_detail::disconnect_all() - { +void hier_block2_detail::disconnect_all() +{ d_fg->clear(); d_blocks.clear(); @@ -522,49 +518,49 @@ namespace gr { int max_outputs = d_owner->output_signature()->max_streams(); d_inputs = std::vector<endpoint_vector_t>(max_inputs); d_outputs = endpoint_vector_t(max_outputs); - } +} - endpoint_vector_t - hier_block2_detail::resolve_endpoint(const endpoint &endp, bool is_input) const - { +endpoint_vector_t hier_block2_detail::resolve_endpoint(const endpoint& endp, + bool is_input) const +{ std::stringstream msg; endpoint_vector_t result; // Check if endpoint is a leaf node - if(cast_to_block_sptr(endp.block())) { - if(HIER_BLOCK2_DETAIL_DEBUG) - std::cout << "Block " << endp.block() << " is a leaf node, returning." << std::endl; - result.push_back(endp); - return result; + if (cast_to_block_sptr(endp.block())) { + if (HIER_BLOCK2_DETAIL_DEBUG) + std::cout << "Block " << endp.block() << " is a leaf node, returning." + << std::endl; + result.push_back(endp); + return result; } // Check if endpoint is a hierarchical block hier_block2_sptr hier_block2(cast_to_hier_block2_sptr(endp.block())); - if(hier_block2) { - if(HIER_BLOCK2_DETAIL_DEBUG) - std::cout << "Resolving endpoint " << endp << " as an " - << (is_input ? "input" : "output") - << ", recursing" << std::endl; - return hier_block2->d_detail->resolve_port(endp.port(), is_input); + if (hier_block2) { + if (HIER_BLOCK2_DETAIL_DEBUG) + std::cout << "Resolving endpoint " << endp << " as an " + << (is_input ? "input" : "output") << ", recursing" << std::endl; + return hier_block2->d_detail->resolve_port(endp.port(), is_input); } - msg << "unable to resolve" << (is_input ? " input " : " output ") - << "endpoint " << endp; + msg << "unable to resolve" << (is_input ? " input " : " output ") << "endpoint " + << endp; throw std::runtime_error(msg.str()); - } +} - void - hier_block2_detail::flatten_aux(flat_flowgraph_sptr sfg) const - { - if(HIER_BLOCK2_DETAIL_DEBUG) - std::cout << " ** Flattening " << d_owner->name() << " parent: " << d_parent_detail << std::endl; +void hier_block2_detail::flatten_aux(flat_flowgraph_sptr sfg) const +{ + if (HIER_BLOCK2_DETAIL_DEBUG) + std::cout << " ** Flattening " << d_owner->name() + << " parent: " << d_parent_detail << std::endl; bool is_top_block = (d_parent_detail == NULL); // Add my edges to the flow graph, resolving references to actual endpoints edge_vector_t edges = d_fg->edges(); msg_edge_vector_t msg_edges = d_fg->msg_edges(); edge_viter_t p; - msg_edge_viter_t q,u; + msg_edge_viter_t q, u; // Only run setup_rpc if ControlPort config param is enabled. bool ctrlport_on = prefs::singleton()->get_bool("ControlPort", "on", false); @@ -575,195 +571,191 @@ namespace gr { bool set_all_min_buff = d_owner->all_min_output_buffer_p(); bool set_all_max_buff = d_owner->all_max_output_buffer_p(); // Get the min and max buffer length - if(set_all_min_buff){ - if(HIER_BLOCK2_DETAIL_DEBUG) - std::cout << "Getting (" << (d_owner->alias()).c_str() - << ") min buffer" << std::endl; - min_buff = d_owner->min_output_buffer(); + if (set_all_min_buff) { + if (HIER_BLOCK2_DETAIL_DEBUG) + std::cout << "Getting (" << (d_owner->alias()).c_str() << ") min buffer" + << std::endl; + min_buff = d_owner->min_output_buffer(); } - if(set_all_max_buff){ - if(HIER_BLOCK2_DETAIL_DEBUG) - std::cout << "Getting (" << (d_owner->alias()).c_str() - << ") max buffer" << std::endl; - max_buff = d_owner->max_output_buffer(); + if (set_all_max_buff) { + if (HIER_BLOCK2_DETAIL_DEBUG) + std::cout << "Getting (" << (d_owner->alias()).c_str() << ") max buffer" + << std::endl; + max_buff = d_owner->max_output_buffer(); } // For every block (gr::block and gr::hier_block2), set up the RPC // interface. - for(p = edges.begin(); p != edges.end(); p++) { - basic_block_sptr b; - b = p->src().block(); - - if(set_all_min_buff){ - //sets the min buff for every block within hier_block2 - if(min_buff != 0){ - block_sptr bb = boost::dynamic_pointer_cast<block>(b); - if(bb != 0){ - if(bb->min_output_buffer(0) != min_buff){ - if(HIER_BLOCK2_DETAIL_DEBUG) - std::cout << "Block (" << (bb->alias()).c_str() - << ") min_buff (" << min_buff - << ")" << std::endl; - bb->set_min_output_buffer(min_buff); - } - } - else{ - hier_block2_sptr hh = boost::dynamic_pointer_cast<hier_block2>(b); - if(hh != 0){ - if(hh->min_output_buffer(0) != min_buff){ - if(HIER_BLOCK2_DETAIL_DEBUG) - std::cout << "HBlock (" << (hh->alias()).c_str() - << ") min_buff (" << min_buff - << ")" << std::endl; - hh->set_min_output_buffer(min_buff); - } + for (p = edges.begin(); p != edges.end(); p++) { + basic_block_sptr b; + b = p->src().block(); + + if (set_all_min_buff) { + // sets the min buff for every block within hier_block2 + if (min_buff != 0) { + block_sptr bb = boost::dynamic_pointer_cast<block>(b); + if (bb != 0) { + if (bb->min_output_buffer(0) != min_buff) { + if (HIER_BLOCK2_DETAIL_DEBUG) + std::cout << "Block (" << (bb->alias()).c_str() + << ") min_buff (" << min_buff << ")" << std::endl; + bb->set_min_output_buffer(min_buff); + } + } else { + hier_block2_sptr hh = boost::dynamic_pointer_cast<hier_block2>(b); + if (hh != 0) { + if (hh->min_output_buffer(0) != min_buff) { + if (HIER_BLOCK2_DETAIL_DEBUG) + std::cout << "HBlock (" << (hh->alias()).c_str() + << ") min_buff (" << min_buff << ")" + << std::endl; + hh->set_min_output_buffer(min_buff); + } + } + } } - } } - } - if(set_all_max_buff){ - //sets the max buff for every block within hier_block2 - if(max_buff != 0){ - block_sptr bb = boost::dynamic_pointer_cast<block>(b); - if(bb != 0){ - if(bb->max_output_buffer(0) != max_buff){ - if(HIER_BLOCK2_DETAIL_DEBUG) - std::cout << "Block (" << (bb->alias()).c_str() - << ") max_buff (" << max_buff - << ")" << std::endl; - bb->set_max_output_buffer(max_buff); - } - } - else{ - hier_block2_sptr hh = boost::dynamic_pointer_cast<hier_block2>(b); - if(hh != 0){ - if(hh->max_output_buffer(0) != max_buff){ - if(HIER_BLOCK2_DETAIL_DEBUG) - std::cout << "HBlock (" << (hh->alias()).c_str() - << ") max_buff (" << max_buff - << ")" << std::endl; - hh->set_max_output_buffer(max_buff); - } + if (set_all_max_buff) { + // sets the max buff for every block within hier_block2 + if (max_buff != 0) { + block_sptr bb = boost::dynamic_pointer_cast<block>(b); + if (bb != 0) { + if (bb->max_output_buffer(0) != max_buff) { + if (HIER_BLOCK2_DETAIL_DEBUG) + std::cout << "Block (" << (bb->alias()).c_str() + << ") max_buff (" << max_buff << ")" << std::endl; + bb->set_max_output_buffer(max_buff); + } + } else { + hier_block2_sptr hh = boost::dynamic_pointer_cast<hier_block2>(b); + if (hh != 0) { + if (hh->max_output_buffer(0) != max_buff) { + if (HIER_BLOCK2_DETAIL_DEBUG) + std::cout << "HBlock (" << (hh->alias()).c_str() + << ") max_buff (" << max_buff << ")" + << std::endl; + hh->set_max_output_buffer(max_buff); + } + } + } } - } } - } - b = p->dst().block(); - if(set_all_min_buff){ - //sets the min buff for every block within hier_block2 - if(min_buff != 0){ - block_sptr bb = boost::dynamic_pointer_cast<block>(b); - if(bb != 0){ - if(bb->min_output_buffer(0) != min_buff){ - if(HIER_BLOCK2_DETAIL_DEBUG) - std::cout << "Block (" << (bb->alias()).c_str() - << ") min_buff (" << min_buff - << ")" << std::endl; - bb->set_min_output_buffer(min_buff); + b = p->dst().block(); + if (set_all_min_buff) { + // sets the min buff for every block within hier_block2 + if (min_buff != 0) { + block_sptr bb = boost::dynamic_pointer_cast<block>(b); + if (bb != 0) { + if (bb->min_output_buffer(0) != min_buff) { + if (HIER_BLOCK2_DETAIL_DEBUG) + std::cout << "Block (" << (bb->alias()).c_str() + << ") min_buff (" << min_buff << ")" << std::endl; + bb->set_min_output_buffer(min_buff); + } + } else { + hier_block2_sptr hh = boost::dynamic_pointer_cast<hier_block2>(b); + if (hh != 0) { + if (hh->min_output_buffer(0) != min_buff) { + if (HIER_BLOCK2_DETAIL_DEBUG) + std::cout << "HBlock (" << (hh->alias()).c_str() + << ") min_buff (" << min_buff << ")" + << std::endl; + hh->set_min_output_buffer(min_buff); + } + } + } } - } - else{ - hier_block2_sptr hh = boost::dynamic_pointer_cast<hier_block2>(b); - if(hh != 0){ - if(hh->min_output_buffer(0) != min_buff){ - if(HIER_BLOCK2_DETAIL_DEBUG) - std::cout << "HBlock (" << (hh->alias()).c_str() - << ") min_buff (" << min_buff - << ")" << std::endl; - hh->set_min_output_buffer(min_buff); - } - } - } } - } - if(set_all_max_buff){ - //sets the max buff for every block within hier_block2 - if(max_buff != 0){ - block_sptr bb = boost::dynamic_pointer_cast<block>(b); - if(bb != 0){ - if(bb->max_output_buffer(0) != max_buff){ - if(HIER_BLOCK2_DETAIL_DEBUG) - std::cout << "Block (" << (bb->alias()).c_str() - << ") max_buff (" << max_buff - << ")" << std::endl; - bb->set_max_output_buffer(max_buff); + if (set_all_max_buff) { + // sets the max buff for every block within hier_block2 + if (max_buff != 0) { + block_sptr bb = boost::dynamic_pointer_cast<block>(b); + if (bb != 0) { + if (bb->max_output_buffer(0) != max_buff) { + if (HIER_BLOCK2_DETAIL_DEBUG) + std::cout << "Block (" << (bb->alias()).c_str() + << ") max_buff (" << max_buff << ")" << std::endl; + bb->set_max_output_buffer(max_buff); + } + } else { + hier_block2_sptr hh = boost::dynamic_pointer_cast<hier_block2>(b); + if (hh != 0) { + if (hh->max_output_buffer(0) != max_buff) { + if (HIER_BLOCK2_DETAIL_DEBUG) + std::cout << "HBlock (" << (hh->alias()).c_str() + << ") max_buff (" << max_buff << ")" + << std::endl; + hh->set_max_output_buffer(max_buff); + } + } + } } - } - else{ - hier_block2_sptr hh = boost::dynamic_pointer_cast<hier_block2>(b); - if(hh != 0){ - if(hh->max_output_buffer(0) != max_buff){ - if(HIER_BLOCK2_DETAIL_DEBUG) - std::cout << "HBlock (" << (hh->alias()).c_str() - << ") max_buff (" << max_buff - << ")" << std::endl; - hh->set_max_output_buffer(max_buff); - } - } - } } - } } - if(HIER_BLOCK2_DETAIL_DEBUG) - std::cout << "Flattening stream connections: " << std::endl; + if (HIER_BLOCK2_DETAIL_DEBUG) + std::cout << "Flattening stream connections: " << std::endl; - for(p = edges.begin(); p != edges.end(); p++) { - if(HIER_BLOCK2_DETAIL_DEBUG) - std::cout << "Flattening edge " << (*p) << std::endl; + for (p = edges.begin(); p != edges.end(); p++) { + if (HIER_BLOCK2_DETAIL_DEBUG) + std::cout << "Flattening edge " << (*p) << std::endl; - endpoint_vector_t src_endps = resolve_endpoint(p->src(), false); - endpoint_vector_t dst_endps = resolve_endpoint(p->dst(), true); + endpoint_vector_t src_endps = resolve_endpoint(p->src(), false); + endpoint_vector_t dst_endps = resolve_endpoint(p->dst(), true); - endpoint_viter_t s, d; - for(s = src_endps.begin(); s != src_endps.end(); s++) { - for(d = dst_endps.begin(); d != dst_endps.end(); d++) { - if(HIER_BLOCK2_DETAIL_DEBUG) - std::cout << (*s) << "->" << (*d) << std::endl; - sfg->connect(*s, *d); + endpoint_viter_t s, d; + for (s = src_endps.begin(); s != src_endps.end(); s++) { + for (d = dst_endps.begin(); d != dst_endps.end(); d++) { + if (HIER_BLOCK2_DETAIL_DEBUG) + std::cout << (*s) << "->" << (*d) << std::endl; + sfg->connect(*s, *d); + } } - } } // loop through flattening hierarchical connections - if(HIER_BLOCK2_DETAIL_DEBUG) - std::cout << "Flattening msg connections: " << std::endl; - - std::vector<std::pair<msg_endpoint, bool> > resolved_endpoints; - for(q = msg_edges.begin(); q != msg_edges.end(); q++) { - if(HIER_BLOCK2_DETAIL_DEBUG) - std::cout << boost::format(" flattening edge ( %s, %s, %d) -> ( %s, %s, %d)\n") % \ - q->src().block() % q->src().port() % q->src().is_hier() % q->dst().block() % \ - q->dst().port() % q->dst().is_hier(); - - - if(q->src().is_hier() && q->src().block().get() == d_owner){ - // connection into this block .. - if(HIER_BLOCK2_DETAIL_DEBUG) - std::cout << "hier incoming port: " << q->src() << std::endl; - sfg->replace_endpoint(q->src(), q->dst(), false); - resolved_endpoints.push_back( std::pair<msg_endpoint,bool>( q->src(), false)); - } else - if(q->dst().is_hier() && q->dst().block().get() == d_owner){ - // connection out of this block - if(HIER_BLOCK2_DETAIL_DEBUG) - std::cout << "hier outgoing port: " << q->dst() << std::endl; - sfg->replace_endpoint(q->dst(), q->src(), true); - resolved_endpoints.push_back( std::pair<msg_endpoint,bool>(q->dst(), true)); - } else { - // internal connection only - if(HIER_BLOCK2_DETAIL_DEBUG) - std::cout << "internal msg connection: " << q->src() << "-->" << q->dst() << std::endl; - sfg->connect( q->src(), q->dst() ); - } + if (HIER_BLOCK2_DETAIL_DEBUG) + std::cout << "Flattening msg connections: " << std::endl; + + std::vector<std::pair<msg_endpoint, bool>> resolved_endpoints; + for (q = msg_edges.begin(); q != msg_edges.end(); q++) { + if (HIER_BLOCK2_DETAIL_DEBUG) + std::cout << boost::format( + " flattening edge ( %s, %s, %d) -> ( %s, %s, %d)\n") % + q->src().block() % q->src().port() % q->src().is_hier() % + q->dst().block() % q->dst().port() % q->dst().is_hier(); + + + if (q->src().is_hier() && q->src().block().get() == d_owner) { + // connection into this block .. + if (HIER_BLOCK2_DETAIL_DEBUG) + std::cout << "hier incoming port: " << q->src() << std::endl; + sfg->replace_endpoint(q->src(), q->dst(), false); + resolved_endpoints.push_back(std::pair<msg_endpoint, bool>(q->src(), false)); + } else if (q->dst().is_hier() && q->dst().block().get() == d_owner) { + // connection out of this block + if (HIER_BLOCK2_DETAIL_DEBUG) + std::cout << "hier outgoing port: " << q->dst() << std::endl; + sfg->replace_endpoint(q->dst(), q->src(), true); + resolved_endpoints.push_back(std::pair<msg_endpoint, bool>(q->dst(), true)); + } else { + // internal connection only + if (HIER_BLOCK2_DETAIL_DEBUG) + std::cout << "internal msg connection: " << q->src() << "-->" << q->dst() + << std::endl; + sfg->connect(q->src(), q->dst()); + } } - for(std::vector<std::pair<msg_endpoint, bool> >::iterator it = resolved_endpoints.begin(); - it != resolved_endpoints.end(); it++) { - if(HIER_BLOCK2_DETAIL_DEBUG) - std::cout << "sfg->clear_endpoint(" << (*it).first << ", " << (*it).second << ") " << std::endl; - sfg->clear_endpoint((*it).first, (*it).second); + for (std::vector<std::pair<msg_endpoint, bool>>::iterator it = + resolved_endpoints.begin(); + it != resolved_endpoints.end(); + it++) { + if (HIER_BLOCK2_DETAIL_DEBUG) + std::cout << "sfg->clear_endpoint(" << (*it).first << ", " << (*it).second + << ") " << std::endl; + sfg->clear_endpoint((*it).first, (*it).second); } /* @@ -784,87 +776,81 @@ namespace gr { basic_block_vector_t tmp = d_fg->calc_used_blocks(); // First add the list of singleton blocks - std::vector<basic_block_sptr>::const_iterator b; // Because flatten_aux is const - for(b = d_blocks.begin(); b != d_blocks.end(); b++) { - tmp.push_back(*b); + std::vector<basic_block_sptr>::const_iterator b; // Because flatten_aux is const + for (b = d_blocks.begin(); b != d_blocks.end(); b++) { + tmp.push_back(*b); } // Now add the list of connected input blocks std::stringstream msg; - for(unsigned int i = 0; i < d_inputs.size(); i++) { - if(d_inputs[i].size() == 0) { - msg << "In hierarchical block " << d_owner->name() << ", input " << i - << " is not connected internally"; - throw std::runtime_error(msg.str()); - } + for (unsigned int i = 0; i < d_inputs.size(); i++) { + if (d_inputs[i].size() == 0) { + msg << "In hierarchical block " << d_owner->name() << ", input " << i + << " is not connected internally"; + throw std::runtime_error(msg.str()); + } - for(unsigned int j = 0; j < d_inputs[i].size(); j++) - tmp.push_back(d_inputs[i][j].block()); + for (unsigned int j = 0; j < d_inputs[i].size(); j++) + tmp.push_back(d_inputs[i][j].block()); } - for(unsigned int i = 0; i < d_outputs.size(); i++) { - basic_block_sptr blk = d_outputs[i].block(); - if(!blk) { - msg << "In hierarchical block " << d_owner->name() << ", output " << i - << " is not connected internally"; - throw std::runtime_error(msg.str()); - } - // Set the buffers of only the blocks connected to the hier output - if(!set_all_min_buff){ - min_buff = d_owner->min_output_buffer(i); - if(min_buff != 0){ - block_sptr bb = boost::dynamic_pointer_cast<block>(blk); - if(bb != 0){ - int bb_src_port = d_outputs[i].port(); - if(HIER_BLOCK2_DETAIL_DEBUG) - std::cout << "Block (" << (bb->alias()).c_str() - << ") Port (" << bb_src_port - << ") min_buff (" << min_buff - << ")" << std::endl; - bb->set_min_output_buffer(bb_src_port, min_buff); - } - else{ - hier_block2_sptr hh = boost::dynamic_pointer_cast<hier_block2>(blk); - if(hh != 0){ - int hh_src_port = d_outputs[i].port(); - if(HIER_BLOCK2_DETAIL_DEBUG) - std::cout << "HBlock (" << (hh->alias()).c_str() - << ") Port (" << hh_src_port - << ") min_buff ("<< min_buff - << ")" << std::endl; - hh->set_min_output_buffer(hh_src_port, min_buff); + for (unsigned int i = 0; i < d_outputs.size(); i++) { + basic_block_sptr blk = d_outputs[i].block(); + if (!blk) { + msg << "In hierarchical block " << d_owner->name() << ", output " << i + << " is not connected internally"; + throw std::runtime_error(msg.str()); + } + // Set the buffers of only the blocks connected to the hier output + if (!set_all_min_buff) { + min_buff = d_owner->min_output_buffer(i); + if (min_buff != 0) { + block_sptr bb = boost::dynamic_pointer_cast<block>(blk); + if (bb != 0) { + int bb_src_port = d_outputs[i].port(); + if (HIER_BLOCK2_DETAIL_DEBUG) + std::cout << "Block (" << (bb->alias()).c_str() << ") Port (" + << bb_src_port << ") min_buff (" << min_buff << ")" + << std::endl; + bb->set_min_output_buffer(bb_src_port, min_buff); + } else { + hier_block2_sptr hh = boost::dynamic_pointer_cast<hier_block2>(blk); + if (hh != 0) { + int hh_src_port = d_outputs[i].port(); + if (HIER_BLOCK2_DETAIL_DEBUG) + std::cout << "HBlock (" << (hh->alias()).c_str() << ") Port (" + << hh_src_port << ") min_buff (" << min_buff << ")" + << std::endl; + hh->set_min_output_buffer(hh_src_port, min_buff); + } + } } - } } - } - if(!set_all_max_buff){ - max_buff = d_owner->max_output_buffer(i); - if(max_buff != 0){ - block_sptr bb = boost::dynamic_pointer_cast<block>(blk); - if(bb != 0){ - int bb_src_port = d_outputs[i].port(); - if(HIER_BLOCK2_DETAIL_DEBUG) - std::cout << "Block (" << (bb->alias()).c_str() - << ") Port (" << bb_src_port - << ") max_buff (" << max_buff - << ")" << std::endl; - bb->set_max_output_buffer(bb_src_port, max_buff); - } - else{ - hier_block2_sptr hh = boost::dynamic_pointer_cast<hier_block2>(blk); - if(hh != 0){ - int hh_src_port = d_outputs[i].port(); - if(HIER_BLOCK2_DETAIL_DEBUG) - std::cout << "HBlock (" << (hh->alias()).c_str() - << ") Port (" << hh_src_port - << ") max_buff (" << max_buff - << ")" << std::endl; - hh->set_max_output_buffer(hh_src_port, max_buff); + if (!set_all_max_buff) { + max_buff = d_owner->max_output_buffer(i); + if (max_buff != 0) { + block_sptr bb = boost::dynamic_pointer_cast<block>(blk); + if (bb != 0) { + int bb_src_port = d_outputs[i].port(); + if (HIER_BLOCK2_DETAIL_DEBUG) + std::cout << "Block (" << (bb->alias()).c_str() << ") Port (" + << bb_src_port << ") max_buff (" << max_buff << ")" + << std::endl; + bb->set_max_output_buffer(bb_src_port, max_buff); + } else { + hier_block2_sptr hh = boost::dynamic_pointer_cast<hier_block2>(blk); + if (hh != 0) { + int hh_src_port = d_outputs[i].port(); + if (HIER_BLOCK2_DETAIL_DEBUG) + std::cout << "HBlock (" << (hh->alias()).c_str() << ") Port (" + << hh_src_port << ") max_buff (" << max_buff << ")" + << std::endl; + hh->set_max_output_buffer(hh_src_port, max_buff); + } + } } - } } - } - tmp.push_back(blk); + tmp.push_back(blk); } sort(tmp.begin(), tmp.end()); @@ -872,105 +858,98 @@ namespace gr { unique_copy(tmp.begin(), tmp.end(), inserter); // Recurse hierarchical children - for(basic_block_viter_t p = blocks.begin(); p != blocks.end(); p++) { - hier_block2_sptr hier_block2(cast_to_hier_block2_sptr(*p)); - if(hier_block2 && (hier_block2.get() != d_owner)) { - if(HIER_BLOCK2_DETAIL_DEBUG) - std::cout << "flatten_aux: recursing into hierarchical block " - << hier_block2->alias() << std::endl; - hier_block2->d_detail->flatten_aux(sfg); - } + for (basic_block_viter_t p = blocks.begin(); p != blocks.end(); p++) { + hier_block2_sptr hier_block2(cast_to_hier_block2_sptr(*p)); + if (hier_block2 && (hier_block2.get() != d_owner)) { + if (HIER_BLOCK2_DETAIL_DEBUG) + std::cout << "flatten_aux: recursing into hierarchical block " + << hier_block2->alias() << std::endl; + hier_block2->d_detail->flatten_aux(sfg); + } } // prune any remaining hier connections // if they were not replaced with hier internal connections while in sub-calls // they must remain unconnected and can be deleted... - if(is_top_block){ - sfg->clear_hier(); + if (is_top_block) { + sfg->clear_hier(); } // print all primitive connections at exit - if(HIER_BLOCK2_DETAIL_DEBUG && is_top_block){ - std::cout << "flatten_aux finished in top_block" << std::endl; - sfg->dump(); + if (HIER_BLOCK2_DETAIL_DEBUG && is_top_block) { + std::cout << "flatten_aux finished in top_block" << std::endl; + sfg->dump(); } // if ctrlport is enabled, call setup RPC for all blocks in the flowgraph - if(ctrlport_on) { - for(b = blocks.begin(); b != blocks.end(); b++) { - if(!(*b)->is_rpc_set()) { - (*b)->setup_rpc(); - (*b)->rpc_set(); + if (ctrlport_on) { + for (b = blocks.begin(); b != blocks.end(); b++) { + if (!(*b)->is_rpc_set()) { + (*b)->setup_rpc(); + (*b)->rpc_set(); + } } - } } - } +} - void - hier_block2_detail::lock() - { - if(HIER_BLOCK2_DETAIL_DEBUG) - std::cout << "lock: entered in " << this << std::endl; +void hier_block2_detail::lock() +{ + if (HIER_BLOCK2_DETAIL_DEBUG) + std::cout << "lock: entered in " << this << std::endl; - if(d_parent_detail) - d_parent_detail->lock(); + if (d_parent_detail) + d_parent_detail->lock(); else - d_owner->lock(); - } + d_owner->lock(); +} - void - hier_block2_detail::unlock() - { - if(HIER_BLOCK2_DETAIL_DEBUG) - std::cout << "unlock: entered in " << this << std::endl; +void hier_block2_detail::unlock() +{ + if (HIER_BLOCK2_DETAIL_DEBUG) + std::cout << "unlock: entered in " << this << std::endl; - if(d_parent_detail) - d_parent_detail->unlock(); + if (d_parent_detail) + d_parent_detail->unlock(); else - d_owner->unlock(); - } + d_owner->unlock(); +} - void - hier_block2_detail::set_processor_affinity(const std::vector<int> &mask) - { +void hier_block2_detail::set_processor_affinity(const std::vector<int>& mask) +{ basic_block_vector_t tmp = d_fg->calc_used_blocks(); - for(basic_block_viter_t p = tmp.begin(); p != tmp.end(); p++) { - (*p)->set_processor_affinity(mask); + for (basic_block_viter_t p = tmp.begin(); p != tmp.end(); p++) { + (*p)->set_processor_affinity(mask); } - } +} - void - hier_block2_detail::unset_processor_affinity() - { +void hier_block2_detail::unset_processor_affinity() +{ basic_block_vector_t tmp = d_fg->calc_used_blocks(); - for(basic_block_viter_t p = tmp.begin(); p != tmp.end(); p++) { - (*p)->unset_processor_affinity(); + for (basic_block_viter_t p = tmp.begin(); p != tmp.end(); p++) { + (*p)->unset_processor_affinity(); } - } +} - std::vector<int> - hier_block2_detail::processor_affinity() - { +std::vector<int> hier_block2_detail::processor_affinity() +{ basic_block_vector_t tmp = d_fg->calc_used_blocks(); return tmp[0]->processor_affinity(); - } +} - void - hier_block2_detail::set_log_level(std::string level) - { +void hier_block2_detail::set_log_level(std::string level) +{ basic_block_vector_t tmp = d_fg->calc_used_blocks(); - for(basic_block_viter_t p = tmp.begin(); p != tmp.end(); p++) { - (*p)->set_log_level(level); + for (basic_block_viter_t p = tmp.begin(); p != tmp.end(); p++) { + (*p)->set_log_level(level); } - } +} - std::string - hier_block2_detail::log_level() - { +std::string hier_block2_detail::log_level() +{ // Assume that log_level was set for all hier_block2 blocks basic_block_vector_t tmp = d_fg->calc_used_blocks(); return tmp[0]->log_level(); - } +} } /* namespace gr */ diff --git a/gnuradio-runtime/lib/hier_block2_detail.h b/gnuradio-runtime/lib/hier_block2_detail.h index aa419c49bd..4d16c1dae9 100644 --- a/gnuradio-runtime/lib/hier_block2_detail.h +++ b/gnuradio-runtime/lib/hier_block2_detail.h @@ -30,48 +30,51 @@ namespace gr { - /*! - * \ingroup internal - */ - class GR_RUNTIME_API hier_block2_detail : boost::noncopyable - { - public: - hier_block2_detail(hier_block2 *owner); +/*! + * \ingroup internal + */ +class GR_RUNTIME_API hier_block2_detail : boost::noncopyable +{ +public: + hier_block2_detail(hier_block2* owner); ~hier_block2_detail(); void connect(basic_block_sptr block); - void connect(basic_block_sptr src, int src_port, - basic_block_sptr dst, int dst_port); - void msg_connect(basic_block_sptr src, pmt::pmt_t srcport, - basic_block_sptr dst, pmt::pmt_t dstport); - void msg_disconnect(basic_block_sptr src, pmt::pmt_t srcport, - basic_block_sptr dst, pmt::pmt_t dstport); + void connect(basic_block_sptr src, int src_port, basic_block_sptr dst, int dst_port); + void msg_connect(basic_block_sptr src, + pmt::pmt_t srcport, + basic_block_sptr dst, + pmt::pmt_t dstport); + void msg_disconnect(basic_block_sptr src, + pmt::pmt_t srcport, + basic_block_sptr dst, + pmt::pmt_t dstport); void disconnect(basic_block_sptr block); - void disconnect(basic_block_sptr, int src_port, - basic_block_sptr, int dst_port); + void disconnect(basic_block_sptr, int src_port, basic_block_sptr, int dst_port); void disconnect_all(); void lock(); void unlock(); void flatten_aux(flat_flowgraph_sptr sfg) const; - void set_processor_affinity(const std::vector<int> &mask); + void set_processor_affinity(const std::vector<int>& mask); void unset_processor_affinity(); std::vector<int> processor_affinity(); void set_log_level(std::string level); std::string log_level(); - + // Track output buffer min/max settings std::vector<size_t> d_max_output_buffer; std::vector<size_t> d_min_output_buffer; - private: +private: // Private implementation data - hier_block2 *d_owner; - hier_block2_detail *d_parent_detail; + hier_block2* d_owner; + hier_block2_detail* d_parent_detail; flowgraph_sptr d_fg; - std::vector<endpoint_vector_t> d_inputs; // Multiple internal endpoints per external input - endpoint_vector_t d_outputs; // Single internal endpoint per external output + std::vector<endpoint_vector_t> + d_inputs; // Multiple internal endpoints per external input + endpoint_vector_t d_outputs; // Single internal endpoint per external output basic_block_vector_t d_blocks; void refresh_io_signature(); @@ -81,8 +84,8 @@ namespace gr { void disconnect_output(int my_port, int port, basic_block_sptr block); endpoint_vector_t resolve_port(int port, bool is_input); - endpoint_vector_t resolve_endpoint(const endpoint &endp, bool is_input) const; - }; + endpoint_vector_t resolve_endpoint(const endpoint& endp, bool is_input) const; +}; } /* namespace gr */ diff --git a/gnuradio-runtime/lib/high_res_timer.cc b/gnuradio-runtime/lib/high_res_timer.cc index 37e7e322a8..bf871ce65e 100644 --- a/gnuradio-runtime/lib/high_res_timer.cc +++ b/gnuradio-runtime/lib/high_res_timer.cc @@ -3,6 +3,3 @@ #ifdef GNURADIO_HRT_USE_CLOCK_GETTIME clockid_t gr::high_res_timer_source = CLOCK_THREAD_CPUTIME_ID; #endif - - - diff --git a/gnuradio-runtime/lib/io_signature.cc b/gnuradio-runtime/lib/io_signature.cc index ccfdf3c06b..7e9aefc2a7 100644 --- a/gnuradio-runtime/lib/io_signature.cc +++ b/gnuradio-runtime/lib/io_signature.cc @@ -30,88 +30,82 @@ namespace gr { - gr::io_signature::sptr - io_signature::makev(int min_streams, int max_streams, - const std::vector<int> &sizeof_stream_items) - { - return gr::io_signature::sptr - (new io_signature(min_streams, max_streams, - sizeof_stream_items)); - } - - gr::io_signature::sptr - io_signature::make(int min_streams, int max_streams, - int sizeof_stream_item) - { +gr::io_signature::sptr io_signature::makev(int min_streams, + int max_streams, + const std::vector<int>& sizeof_stream_items) +{ + return gr::io_signature::sptr( + new io_signature(min_streams, max_streams, sizeof_stream_items)); +} + +gr::io_signature::sptr +io_signature::make(int min_streams, int max_streams, int sizeof_stream_item) +{ std::vector<int> sizeof_items(1); sizeof_items[0] = sizeof_stream_item; return io_signature::makev(min_streams, max_streams, sizeof_items); - } +} - gr::io_signature::sptr - io_signature::make2(int min_streams, int max_streams, - int sizeof_stream_item1, - int sizeof_stream_item2) - { +gr::io_signature::sptr io_signature::make2(int min_streams, + int max_streams, + int sizeof_stream_item1, + int sizeof_stream_item2) +{ std::vector<int> sizeof_items(2); sizeof_items[0] = sizeof_stream_item1; sizeof_items[1] = sizeof_stream_item2; return io_signature::makev(min_streams, max_streams, sizeof_items); - } - - gr::io_signature::sptr - io_signature::make3(int min_streams, int max_streams, - int sizeof_stream_item1, - int sizeof_stream_item2, - int sizeof_stream_item3) - { +} + +gr::io_signature::sptr io_signature::make3(int min_streams, + int max_streams, + int sizeof_stream_item1, + int sizeof_stream_item2, + int sizeof_stream_item3) +{ std::vector<int> sizeof_items(3); sizeof_items[0] = sizeof_stream_item1; sizeof_items[1] = sizeof_stream_item2; sizeof_items[2] = sizeof_stream_item3; return io_signature::makev(min_streams, max_streams, sizeof_items); - } +} - // ------------------------------------------------------------------------ +// ------------------------------------------------------------------------ - io_signature::io_signature(int min_streams, int max_streams, - const std::vector<int> &sizeof_stream_items) - { - if(min_streams < 0 - || (max_streams != IO_INFINITE && max_streams < min_streams)) - throw std::invalid_argument ("gr::io_signature(1)"); +io_signature::io_signature(int min_streams, + int max_streams, + const std::vector<int>& sizeof_stream_items) +{ + if (min_streams < 0 || (max_streams != IO_INFINITE && max_streams < min_streams)) + throw std::invalid_argument("gr::io_signature(1)"); - if(sizeof_stream_items.size() < 1) - throw std::invalid_argument("gr::io_signature(2)"); + if (sizeof_stream_items.size() < 1) + throw std::invalid_argument("gr::io_signature(2)"); - for(size_t i = 0; i < sizeof_stream_items.size(); i++) { - if(max_streams != 0 && sizeof_stream_items[i] < 1) - throw std::invalid_argument("gr::io_signature(3)"); + for (size_t i = 0; i < sizeof_stream_items.size(); i++) { + if (max_streams != 0 && sizeof_stream_items[i] < 1) + throw std::invalid_argument("gr::io_signature(3)"); } d_min_streams = min_streams; d_max_streams = max_streams; d_sizeof_stream_item = sizeof_stream_items; - } +} - io_signature::~io_signature() - { - } +io_signature::~io_signature() {} - int - io_signature::sizeof_stream_item(int _index) const - { - if(_index < 0) - throw std::invalid_argument("gr::io_signature::sizeof_stream_item"); +int io_signature::sizeof_stream_item(int _index) const +{ + if (_index < 0) + throw std::invalid_argument("gr::io_signature::sizeof_stream_item"); size_t index = _index; return d_sizeof_stream_item[std::min(index, d_sizeof_stream_item.size() - 1)]; - } +} - std::vector<int> - io_signature::sizeof_stream_items() const - { +std::vector<int> io_signature::sizeof_stream_items() const +{ return d_sizeof_stream_item; - } +} } /* namespace gr */ diff --git a/gnuradio-runtime/lib/local_sighandler.cc b/gnuradio-runtime/lib/local_sighandler.cc index ebd9bb1362..4f3083b3ed 100644 --- a/gnuradio-runtime/lib/local_sighandler.cc +++ b/gnuradio-runtime/lib/local_sighandler.cc @@ -31,10 +31,9 @@ namespace gr { - local_sighandler::local_sighandler(int signum, - void (*new_handler)(int)) +local_sighandler::local_sighandler(int signum, void (*new_handler)(int)) : d_signum(signum) - { +{ #ifdef HAVE_SIGACTION struct sigaction new_action; memset(&new_action, 0, sizeof(new_action)); @@ -43,147 +42,144 @@ namespace gr { sigemptyset(&new_action.sa_mask); new_action.sa_flags = 0; - if(sigaction (d_signum, &new_action, &d_old_action) < 0) { - perror("sigaction (install new)"); - throw std::runtime_error("sigaction"); + if (sigaction(d_signum, &new_action, &d_old_action) < 0) { + perror("sigaction (install new)"); + throw std::runtime_error("sigaction"); } #endif - } +} - local_sighandler::~local_sighandler() - { +local_sighandler::~local_sighandler() +{ #ifdef HAVE_SIGACTION - if(sigaction (d_signum, &d_old_action, 0) < 0) { - perror("sigaction (restore old)"); - throw std::runtime_error("sigaction"); + if (sigaction(d_signum, &d_old_action, 0) < 0) { + perror("sigaction (restore old)"); + throw std::runtime_error("sigaction"); } #endif - } +} - void - local_sighandler::throw_signal(int signum) - { - throw signal(signum); - } +void local_sighandler::throw_signal(int signum) { throw signal(signum); } - /* - * Semi-hideous way to may a signal number into a signal name - */ - #define SIGNAME(x) case x: return #x +/* + * Semi-hideous way to may a signal number into a signal name + */ +#define SIGNAME(x) \ + case x: \ + return #x - std::string - signal::name() const - { +std::string signal::name() const +{ char tmp[128]; - switch(signum()) { + switch (signum()) { #ifdef SIGHUP - SIGNAME(SIGHUP); + SIGNAME(SIGHUP); #endif #ifdef SIGINT - SIGNAME(SIGINT); + SIGNAME(SIGINT); #endif #ifdef SIGQUIT - SIGNAME(SIGQUIT); + SIGNAME(SIGQUIT); #endif #ifdef SIGILL - SIGNAME(SIGILL); + SIGNAME(SIGILL); #endif #ifdef SIGTRAP - SIGNAME(SIGTRAP); + SIGNAME(SIGTRAP); #endif #ifdef SIGABRT - SIGNAME(SIGABRT); + SIGNAME(SIGABRT); #endif #ifdef SIGBUS - SIGNAME(SIGBUS); + SIGNAME(SIGBUS); #endif #ifdef SIGFPE - SIGNAME(SIGFPE); + SIGNAME(SIGFPE); #endif #ifdef SIGKILL - SIGNAME(SIGKILL); + SIGNAME(SIGKILL); #endif #ifdef SIGUSR1 - SIGNAME(SIGUSR1); + SIGNAME(SIGUSR1); #endif #ifdef SIGSEGV - SIGNAME(SIGSEGV); + SIGNAME(SIGSEGV); #endif #ifdef SIGUSR2 - SIGNAME(SIGUSR2); + SIGNAME(SIGUSR2); #endif #ifdef SIGPIPE - SIGNAME(SIGPIPE); + SIGNAME(SIGPIPE); #endif #ifdef SIGALRM - SIGNAME(SIGALRM); + SIGNAME(SIGALRM); #endif #ifdef SIGTERM - SIGNAME(SIGTERM); + SIGNAME(SIGTERM); #endif #ifdef SIGSTKFLT - SIGNAME(SIGSTKFLT); + SIGNAME(SIGSTKFLT); #endif #ifdef SIGCHLD - SIGNAME(SIGCHLD); + SIGNAME(SIGCHLD); #endif #ifdef SIGCONT - SIGNAME(SIGCONT); + SIGNAME(SIGCONT); #endif #ifdef SIGSTOP - SIGNAME(SIGSTOP); + SIGNAME(SIGSTOP); #endif #ifdef SIGTSTP - SIGNAME(SIGTSTP); + SIGNAME(SIGTSTP); #endif #ifdef SIGTTIN - SIGNAME(SIGTTIN); + SIGNAME(SIGTTIN); #endif #ifdef SIGTTOU - SIGNAME(SIGTTOU); + SIGNAME(SIGTTOU); #endif #ifdef SIGURG - SIGNAME(SIGURG); + SIGNAME(SIGURG); #endif #ifdef SIGXCPU - SIGNAME(SIGXCPU); + SIGNAME(SIGXCPU); #endif #ifdef SIGXFSZ - SIGNAME(SIGXFSZ); + SIGNAME(SIGXFSZ); #endif #ifdef SIGVTALRM - SIGNAME(SIGVTALRM); + SIGNAME(SIGVTALRM); #endif #ifdef SIGPROF - SIGNAME(SIGPROF); + SIGNAME(SIGPROF); #endif #ifdef SIGWINCH - SIGNAME(SIGWINCH); + SIGNAME(SIGWINCH); #endif #ifdef SIGIO - SIGNAME(SIGIO); + SIGNAME(SIGIO); #endif #ifdef SIGPWR - SIGNAME(SIGPWR); + SIGNAME(SIGPWR); #endif #ifdef SIGSYS - SIGNAME(SIGSYS); + SIGNAME(SIGSYS); #endif default: -#if defined (HAVE_SNPRINTF) -#if defined (SIGRTMIN) && defined (SIGRTMAX) - if(signum() >= SIGRTMIN && signum() <= SIGRTMAX) { - snprintf(tmp, sizeof(tmp), "SIGRTMIN + %d", signum()); +#if defined(HAVE_SNPRINTF) +#if defined(SIGRTMIN) && defined(SIGRTMAX) + if (signum() >= SIGRTMIN && signum() <= SIGRTMAX) { + snprintf(tmp, sizeof(tmp), "SIGRTMIN + %d", signum()); + return tmp; + } +#endif + snprintf(tmp, sizeof(tmp), "SIGNAL %d", signum()); return tmp; - } -#endif - snprintf(tmp, sizeof(tmp), "SIGNAL %d", signum()); - return tmp; #else - return "Unknown signal"; + return "Unknown signal"; #endif } - } +} } /* namespace gr */ diff --git a/gnuradio-runtime/lib/local_sighandler.h b/gnuradio-runtime/lib/local_sighandler.h index bd322e5b00..688d43c287 100644 --- a/gnuradio-runtime/lib/local_sighandler.h +++ b/gnuradio-runtime/lib/local_sighandler.h @@ -32,42 +32,42 @@ namespace gr { - /*! - * \brief Get and set signal handler. - * - * \ingroup internal - * Constructor installs new handler, destructor reinstalls - * original value. - */ - class GR_RUNTIME_API local_sighandler - { - private: +/*! + * \brief Get and set signal handler. + * + * \ingroup internal + * Constructor installs new handler, destructor reinstalls + * original value. + */ +class GR_RUNTIME_API local_sighandler +{ +private: int d_signum; #ifdef HAVE_SIGACTION struct sigaction d_old_action; #endif - public: +public: local_sighandler(int signum, void (*new_handler)(int)); ~local_sighandler(); /* throw gr_signal (signum) */ static void throw_signal(int signum); - }; +}; - /*! - * \brief Representation of signal. - */ - class GR_RUNTIME_API signal - { - private: +/*! + * \brief Representation of signal. + */ +class GR_RUNTIME_API signal +{ +private: int d_signum; - public: +public: signal(int signum) : d_signum(signum) {} int signum() const { return d_signum; } std::string name() const; - }; +}; } /* namespace gr */ diff --git a/gnuradio-runtime/lib/logger.cc b/gnuradio-runtime/lib/logger.cc index d4f1e27083..f3fa86b30a 100644 --- a/gnuradio-runtime/lib/logger.cc +++ b/gnuradio-runtime/lib/logger.cc @@ -21,10 +21,10 @@ */ /******************************************************************************* -* Author: Mark Plett -* Description: -* The gr_log module wraps the log4cpp library for logging in gnuradio. -*******************************************************************************/ + * Author: Mark Plett + * Description: + * The gr_log module wraps the log4cpp library for logging in gnuradio. + *******************************************************************************/ #ifdef HAVE_CONFIG_H #include "config.h" @@ -37,306 +37,301 @@ namespace gr { - bool logger_config::logger_configured(false); +bool logger_config::logger_configured(false); - /************************ BEGIN LOG4CPP HELPERS ***********************/ - /* Logger config class. This is a singleton that controls how - * log4cpp is configured If watch_period>0 a thread is started to - * watch the config file for changes. - */ +/************************ BEGIN LOG4CPP HELPERS ***********************/ +/* Logger config class. This is a singleton that controls how + * log4cpp is configured If watch_period>0 a thread is started to + * watch the config file for changes. + */ - // Getters of logger_config - logger_config& - logger_config::get_instance(void) - { +// Getters of logger_config +logger_config& logger_config::get_instance(void) +{ static logger_config instance; return instance; - } +} - std::string - logger_config::get_filename() - { - logger_config& in=get_instance(); +std::string logger_config::get_filename() +{ + logger_config& in = get_instance(); return in.filename; - } +} - unsigned int - logger_config::get_watch_period() - { - logger_config& in=get_instance(); +unsigned int logger_config::get_watch_period() +{ + logger_config& in = get_instance(); return in.watch_period; - } +} - // Method to watch config file for changes - void - logger_config::watch_file(std::string filename, unsigned int watch_period) - { +// Method to watch config file for changes +void logger_config::watch_file(std::string filename, unsigned int watch_period) +{ std::time_t last_write(boost::filesystem::last_write_time(filename)); std::time_t current_time(0); - while(true) { - try { - current_time = boost::filesystem::last_write_time(filename); - if(current_time>last_write) { - //std::cout<<"GNURadio Reloading logger configuration:"<<filename<<std::endl; - last_write = current_time; - // Should we wipe out all old configuration or just add the - // new? Just adding... logger_reset_config(); - logger_configured = logger_load_config(filename); + while (true) { + try { + current_time = boost::filesystem::last_write_time(filename); + if (current_time > last_write) { + // std::cout<<"GNURadio Reloading logger + // configuration:"<<filename<<std::endl; + last_write = current_time; + // Should we wipe out all old configuration or just add the + // new? Just adding... logger_reset_config(); + logger_configured = logger_load_config(filename); + } + boost::this_thread::sleep( + boost::posix_time::time_duration(0, 0, watch_period, 0)); + } catch (const boost::thread_interrupted&) { + std::cout << "GNURadio leaving logger config file watch." << std::endl; + break; } - boost::this_thread::sleep(boost::posix_time::time_duration(0,0,watch_period,0)); - } - catch(const boost::thread_interrupted&) { - std::cout<<"GNURadio leaving logger config file watch."<<std::endl; - break; - } } - } +} - // Method to load the configuration. It only loads if the filename - // or watch has changed - void - logger_config::load_config(std::string filename,unsigned int watch_period) - { +// Method to load the configuration. It only loads if the filename +// or watch has changed +void logger_config::load_config(std::string filename, unsigned int watch_period) +{ logger_config& instance = get_instance(); // Only reconfigure if filename or watch has changed - if(!logger_configured) { - instance.filename = filename; - instance.watch_period = watch_period; - // Stop any file watching thread - if(instance.watch_thread!=NULL) - stop_watch(); - // Load configuration - //std::cout<<"GNURadio Loading logger configuration:"<<instance.filename<<std::endl; - logger_configured = logger_load_config(instance.filename); - // Start watch if required - if(instance.watch_period>0) { - instance.watch_thread = new boost::thread(watch_file, instance.filename, - instance.watch_period); - } + if (!logger_configured) { + instance.filename = filename; + instance.watch_period = watch_period; + // Stop any file watching thread + if (instance.watch_thread != NULL) + stop_watch(); + // Load configuration + // std::cout<<"GNURadio Loading logger + // configuration:"<<instance.filename<<std::endl; + logger_configured = logger_load_config(instance.filename); + // Start watch if required + if (instance.watch_period > 0) { + instance.watch_thread = + new boost::thread(watch_file, instance.filename, instance.watch_period); + } } - } +} - // Method to stop the watcher thread - void - logger_config::stop_watch() - { +// Method to stop the watcher thread +void logger_config::stop_watch() +{ logger_config& instance = get_instance(); - if(instance.watch_thread) { - instance.watch_thread->interrupt(); - instance.watch_thread->join(); - delete(instance.watch_thread); - instance.watch_thread=NULL; + if (instance.watch_thread) { + instance.watch_thread->interrupt(); + instance.watch_thread->join(); + delete (instance.watch_thread); + instance.watch_thread = NULL; } - } +} - // Method to reset logger configuration - void - logger_config::reset_config(void) - { +// Method to reset logger configuration +void logger_config::reset_config(void) +{ logger_config& instance = get_instance(); stop_watch(); - std::vector<log4cpp::Category*> *loggers = log4cpp::Category::getCurrentCategories(); + std::vector<log4cpp::Category*>* loggers = log4cpp::Category::getCurrentCategories(); std::vector<log4cpp::Category*>::iterator logger = loggers->begin(); // We can't destroy categories but we can neuter them by removing all appenders. - for(;logger!=loggers->end();logger++) { - (*logger)->removeAllAppenders(); + for (; logger != loggers->end(); logger++) { + (*logger)->removeAllAppenders(); } instance.filename = std::string(""); instance.watch_period = 0; logger_configured = false; - } +} - /***************** Functions to call log4cpp methods *************************/ +/***************** Functions to call log4cpp methods *************************/ - logger_ptr - logger_get_logger(std::string name) - { - if(log4cpp::Category::exists(name)) { - logger_ptr logger = &log4cpp::Category::getInstance(name); - return logger; - } - else { - logger_ptr logger = &log4cpp::Category::getInstance(name); - logger->setPriority(log4cpp::Priority::NOTSET); - return logger; +logger_ptr logger_get_logger(std::string name) +{ + if (log4cpp::Category::exists(name)) { + logger_ptr logger = &log4cpp::Category::getInstance(name); + return logger; + } else { + logger_ptr logger = &log4cpp::Category::getInstance(name); + logger->setPriority(log4cpp::Priority::NOTSET); + return logger; } - } - - bool - logger_load_config(const std::string &config_filename) - { - if(config_filename.size() != 0) { - try { - log4cpp::PropertyConfigurator::configure(config_filename); - return true; - } - catch(log4cpp::ConfigureFailure &e) { - std::cerr << "Logger config failed :" << e.what() << std::endl; - } +} + +bool logger_load_config(const std::string& config_filename) +{ + if (config_filename.size() != 0) { + try { + log4cpp::PropertyConfigurator::configure(config_filename); + return true; + } catch (log4cpp::ConfigureFailure& e) { + std::cerr << "Logger config failed :" << e.what() << std::endl; + } } return false; - } +} - void - logger_set_level(logger_ptr logger, const std::string &level) - { +void logger_set_level(logger_ptr logger, const std::string& level) +{ std::string nocase = level; std::transform(level.begin(), level.end(), nocase.begin(), ::tolower); - if(nocase == "off" || nocase == "notset") - logger_set_level(logger, log4cpp::Priority::NOTSET); - else if(nocase == "all" || nocase == "debug") - logger_set_level(logger, log4cpp::Priority::DEBUG); - else if(nocase == "info") - logger_set_level(logger, log4cpp::Priority::INFO); - else if(nocase == "notice") - logger_set_level(logger, log4cpp::Priority::NOTICE); - else if(nocase == "warn") - logger_set_level(logger, log4cpp::Priority::WARN); - else if(nocase == "error") - logger_set_level(logger, log4cpp::Priority::ERROR); - else if(nocase == "crit") - logger_set_level(logger, log4cpp::Priority::CRIT); - else if(nocase == "alert") - logger_set_level(logger, log4cpp::Priority::ALERT); - else if(nocase=="fatal") - logger_set_level(logger, log4cpp::Priority::FATAL); - else if(nocase == "emerg") - logger_set_level(logger, log4cpp::Priority::EMERG); + if (nocase == "off" || nocase == "notset") + logger_set_level(logger, log4cpp::Priority::NOTSET); + else if (nocase == "all" || nocase == "debug") + logger_set_level(logger, log4cpp::Priority::DEBUG); + else if (nocase == "info") + logger_set_level(logger, log4cpp::Priority::INFO); + else if (nocase == "notice") + logger_set_level(logger, log4cpp::Priority::NOTICE); + else if (nocase == "warn") + logger_set_level(logger, log4cpp::Priority::WARN); + else if (nocase == "error") + logger_set_level(logger, log4cpp::Priority::ERROR); + else if (nocase == "crit") + logger_set_level(logger, log4cpp::Priority::CRIT); + else if (nocase == "alert") + logger_set_level(logger, log4cpp::Priority::ALERT); + else if (nocase == "fatal") + logger_set_level(logger, log4cpp::Priority::FATAL); + else if (nocase == "emerg") + logger_set_level(logger, log4cpp::Priority::EMERG); else - throw std::runtime_error("logger_set_level: Bad level type.\n"); - } + throw std::runtime_error("logger_set_level: Bad level type.\n"); +} - void - logger_set_level(logger_ptr logger, log4cpp::Priority::Value level) - { +void logger_set_level(logger_ptr logger, log4cpp::Priority::Value level) +{ logger->setPriority(level); - } +} - void - logger_get_level(logger_ptr logger, std::string &level) - { +void logger_get_level(logger_ptr logger, std::string& level) +{ log4cpp::Priority::Value levelPtr = logger->getPriority(); - if(levelPtr == log4cpp::Priority::NOTSET) level = "notset"; - if(levelPtr == log4cpp::Priority::DEBUG) level = "debug"; - if(levelPtr == log4cpp::Priority::INFO) level = "info"; - if(levelPtr == log4cpp::Priority::NOTICE) level = "notice"; - if(levelPtr == log4cpp::Priority::WARN) level = "warn"; - if(levelPtr == log4cpp::Priority::ERROR) level = "error"; - if(levelPtr == log4cpp::Priority::CRIT) level = "crit"; - if(levelPtr == log4cpp::Priority::ALERT) level = "alert"; - if(levelPtr == log4cpp::Priority::FATAL) level = "fatal"; - if(levelPtr == log4cpp::Priority::EMERG) level = "emerg"; - } - - void - logger_get_level(logger_ptr logger,log4cpp::Priority::Value level) - { + if (levelPtr == log4cpp::Priority::NOTSET) + level = "notset"; + if (levelPtr == log4cpp::Priority::DEBUG) + level = "debug"; + if (levelPtr == log4cpp::Priority::INFO) + level = "info"; + if (levelPtr == log4cpp::Priority::NOTICE) + level = "notice"; + if (levelPtr == log4cpp::Priority::WARN) + level = "warn"; + if (levelPtr == log4cpp::Priority::ERROR) + level = "error"; + if (levelPtr == log4cpp::Priority::CRIT) + level = "crit"; + if (levelPtr == log4cpp::Priority::ALERT) + level = "alert"; + if (levelPtr == log4cpp::Priority::FATAL) + level = "fatal"; + if (levelPtr == log4cpp::Priority::EMERG) + level = "emerg"; +} + +void logger_get_level(logger_ptr logger, log4cpp::Priority::Value level) +{ level = logger->getPriority(); - } +} - void - logger_add_console_appender(logger_ptr logger, std::string target, std::string pattern) - { +void logger_add_console_appender(logger_ptr logger, + std::string target, + std::string pattern) +{ log4cpp::PatternLayout* layout = new log4cpp::PatternLayout(); log4cpp::Appender* app; - if(target=="stdout") - app = new log4cpp::OstreamAppender("ConsoleAppender::",&std::cout); + if (target == "stdout") + app = new log4cpp::OstreamAppender("ConsoleAppender::", &std::cout); else - app = new log4cpp::OstreamAppender("ConsoleAppender::",&std::cerr); + app = new log4cpp::OstreamAppender("ConsoleAppender::", &std::cerr); layout->setConversionPattern(pattern); app->setLayout(layout); logger->setAppender(app); - } +} - void - logger_set_console_appender(logger_ptr logger, std::string target, std::string pattern) - { +void logger_set_console_appender(logger_ptr logger, + std::string target, + std::string pattern) +{ logger->removeAllAppenders(); logger_add_console_appender(logger, target, pattern); - } +} - void - logger_add_file_appender(logger_ptr logger, std::string filename, - bool append, std::string pattern) - { +void logger_add_file_appender(logger_ptr logger, + std::string filename, + bool append, + std::string pattern) +{ log4cpp::PatternLayout* layout = new log4cpp::PatternLayout(); - log4cpp::Appender* app = new - log4cpp::FileAppender("FileAppender::"+filename, - filename); + log4cpp::Appender* app = + new log4cpp::FileAppender("FileAppender::" + filename, filename); layout->setConversionPattern(pattern); app->setLayout(layout); logger->setAppender(app); - } +} - void - logger_set_file_appender(logger_ptr logger, std::string filename, - bool append, std::string pattern) - { +void logger_set_file_appender(logger_ptr logger, + std::string filename, + bool append, + std::string pattern) +{ logger->removeAllAppenders(); logger_add_file_appender(logger, filename, append, pattern); - } +} - void - logger_add_rollingfile_appender(logger_ptr logger, std::string filename, - size_t filesize, int bkup_index, bool append, - mode_t mode, std::string pattern) - { +void logger_add_rollingfile_appender(logger_ptr logger, + std::string filename, + size_t filesize, + int bkup_index, + bool append, + mode_t mode, + std::string pattern) +{ log4cpp::PatternLayout* layout = new log4cpp::PatternLayout(); - log4cpp::Appender* app = new - log4cpp::RollingFileAppender("RollFileAppender::" + filename, filename, - filesize, bkup_index, append, mode); + log4cpp::Appender* app = new log4cpp::RollingFileAppender( + "RollFileAppender::" + filename, filename, filesize, bkup_index, append, mode); layout->setConversionPattern(pattern); app->setLayout(layout); logger->setAppender(app); - } +} - std::vector<std::string> - logger_get_logger_names(void) - { +std::vector<std::string> logger_get_logger_names(void) +{ std::vector<std::string> names; - std::vector<log4cpp::Category*> *loggers = log4cpp::Category::getCurrentCategories(); + std::vector<log4cpp::Category*>* loggers = log4cpp::Category::getCurrentCategories(); std::vector<log4cpp::Category*>::iterator logger = loggers->begin(); - for(;logger!=loggers->end();logger++) { - names.push_back((*logger)->getName()); + for (; logger != loggers->end(); logger++) { + names.push_back((*logger)->getName()); } return names; - } +} } /* namespace gr */ /****** Start Methods to provide Python the capabilities of the macros ********/ -void -gr_logger_config(const std::string config_filename, unsigned int watch_period) +void gr_logger_config(const std::string config_filename, unsigned int watch_period) { - GR_CONFIG_AND_WATCH_LOGGER(config_filename, watch_period); + GR_CONFIG_AND_WATCH_LOGGER(config_filename, watch_period); } -std::vector<std::string> -gr_logger_get_logger_names(void) +std::vector<std::string> gr_logger_get_logger_names(void) { - std::vector<std::string> names; - GR_GET_LOGGER_NAMES(names); - return names; + std::vector<std::string> names; + GR_GET_LOGGER_NAMES(names); + return names; } -void -gr_logger_reset_config(void) -{ - GR_RESET_CONFIGURATION(); -} +void gr_logger_reset_config(void) { GR_RESET_CONFIGURATION(); } // Remaining capability provided by gr::logger class in gnuradio/logger.h namespace gr { - bool - configure_default_loggers(gr::logger_ptr &l, gr::logger_ptr &d, - const std::string name) - { - prefs *p = prefs::singleton(); +bool configure_default_loggers(gr::logger_ptr& l, + gr::logger_ptr& d, + const std::string name) +{ + prefs* p = prefs::singleton(); std::string config_file = p->get_string("LOG", "log_config", ""); std::string log_level = p->get_string("LOG", "log_level", "off"); std::string log_file = p->get_string("LOG", "log_file", ""); @@ -348,59 +343,52 @@ namespace gr { GR_LOG_GETLOGGER(LOG, "gr_log." + name); GR_LOG_SET_LEVEL(LOG, log_level); - if(log_file.size() > 0) { - if(log_file == "stdout") { - GR_LOG_SET_CONSOLE_APPENDER(LOG, "stdout","gr::log :%p: %c{1} - %m%n"); - } - else if(log_file == "stderr") { - GR_LOG_SET_CONSOLE_APPENDER(LOG, "stderr","gr::log :%p: %c{1} - %m%n"); - } - else { - GR_LOG_SET_FILE_APPENDER(LOG, log_file , true,"%r :%p: %c{1} - %m%n"); - } + if (log_file.size() > 0) { + if (log_file == "stdout") { + GR_LOG_SET_CONSOLE_APPENDER(LOG, "stdout", "gr::log :%p: %c{1} - %m%n"); + } else if (log_file == "stderr") { + GR_LOG_SET_CONSOLE_APPENDER(LOG, "stderr", "gr::log :%p: %c{1} - %m%n"); + } else { + GR_LOG_SET_FILE_APPENDER(LOG, log_file, true, "%r :%p: %c{1} - %m%n"); + } } l = LOG; GR_LOG_GETLOGGER(DLOG, "gr_log_debug." + name); GR_LOG_SET_LEVEL(DLOG, debug_level); - if(debug_file.size() > 0) { - if(debug_file == "stdout") { - GR_LOG_SET_CONSOLE_APPENDER(DLOG, "stdout","gr::debug :%p: %c{1} - %m%n"); - } - else if(debug_file == "stderr") { - GR_LOG_SET_CONSOLE_APPENDER(DLOG, "stderr", "gr::debug :%p: %c{1} - %m%n"); - } - else { - GR_LOG_SET_FILE_APPENDER(DLOG, debug_file, true, "%r :%p: %c{1} - %m%n"); - } + if (debug_file.size() > 0) { + if (debug_file == "stdout") { + GR_LOG_SET_CONSOLE_APPENDER(DLOG, "stdout", "gr::debug :%p: %c{1} - %m%n"); + } else if (debug_file == "stderr") { + GR_LOG_SET_CONSOLE_APPENDER(DLOG, "stderr", "gr::debug :%p: %c{1} - %m%n"); + } else { + GR_LOG_SET_FILE_APPENDER(DLOG, debug_file, true, "%r :%p: %c{1} - %m%n"); + } } d = DLOG; return true; - } +} - bool - update_logger_alias(const std::string &name, const std::string &alias) - { - prefs *p = prefs::singleton(); +bool update_logger_alias(const std::string& name, const std::string& alias) +{ + prefs* p = prefs::singleton(); std::string log_file = p->get_string("LOG", "log_file", ""); std::string debug_file = p->get_string("LOG", "debug_file", ""); GR_LOG_GETLOGGER(LOG, "gr_log." + name); - if(log_file.size() > 0) { - if(log_file == "stdout") { - boost::format str("gr::log :%%p: %1% - %%m%%n"); - GR_LOG_SET_CONSOLE_APPENDER(LOG, "stdout", boost::str(str % alias)); - } - else if(log_file == "stderr") { - boost::format str("gr::log :%%p: %1% - %%m%%n"); - GR_LOG_SET_CONSOLE_APPENDER(LOG, "stderr", boost::str(str % alias)); - } - else { - boost::format str("%%r :%%p: %1% - %%m%%n"); - GR_LOG_SET_FILE_APPENDER(LOG, log_file, true, boost::str(str % alias)); - } + if (log_file.size() > 0) { + if (log_file == "stdout") { + boost::format str("gr::log :%%p: %1% - %%m%%n"); + GR_LOG_SET_CONSOLE_APPENDER(LOG, "stdout", boost::str(str % alias)); + } else if (log_file == "stderr") { + boost::format str("gr::log :%%p: %1% - %%m%%n"); + GR_LOG_SET_CONSOLE_APPENDER(LOG, "stderr", boost::str(str % alias)); + } else { + boost::format str("%%r :%%p: %1% - %%m%%n"); + GR_LOG_SET_FILE_APPENDER(LOG, log_file, true, boost::str(str % alias)); + } } return true; - } +} } /* namespace gr */ diff --git a/gnuradio-runtime/lib/math/fast_atan2f.cc b/gnuradio-runtime/lib/math/fast_atan2f.cc index 72e7291913..f0f37586a3 100644 --- a/gnuradio-runtime/lib/math/fast_atan2f.cc +++ b/gnuradio-runtime/lib/math/fast_atan2f.cc @@ -20,110 +20,86 @@ * Boston, MA 02110-1301, USA. */ -#include <gnuradio/math.h> // declaration is in here +#include <gnuradio/math.h> // declaration is in here #include <cmath> namespace gr { - /***************************************************************************/ - /* Constant definitions */ - /***************************************************************************/ - - #define TAN_MAP_RES 0.003921569 /* (smallest non-zero value in table) */ - #define RAD_PER_DEG 0.017453293 - #define TAN_MAP_SIZE 255 - - /* arctangents from 0 to pi/4 radians */ - static float - fast_atan_table[257] = { - 0.000000e+00, 3.921549e-03, 7.842976e-03, 1.176416e-02, - 1.568499e-02, 1.960533e-02, 2.352507e-02, 2.744409e-02, - 3.136226e-02, 3.527947e-02, 3.919560e-02, 4.311053e-02, - 4.702413e-02, 5.093629e-02, 5.484690e-02, 5.875582e-02, - 6.266295e-02, 6.656816e-02, 7.047134e-02, 7.437238e-02, - 7.827114e-02, 8.216752e-02, 8.606141e-02, 8.995267e-02, - 9.384121e-02, 9.772691e-02, 1.016096e-01, 1.054893e-01, - 1.093658e-01, 1.132390e-01, 1.171087e-01, 1.209750e-01, - 1.248376e-01, 1.286965e-01, 1.325515e-01, 1.364026e-01, - 1.402496e-01, 1.440924e-01, 1.479310e-01, 1.517652e-01, - 1.555948e-01, 1.594199e-01, 1.632403e-01, 1.670559e-01, - 1.708665e-01, 1.746722e-01, 1.784728e-01, 1.822681e-01, - 1.860582e-01, 1.898428e-01, 1.936220e-01, 1.973956e-01, - 2.011634e-01, 2.049255e-01, 2.086818e-01, 2.124320e-01, - 2.161762e-01, 2.199143e-01, 2.236461e-01, 2.273716e-01, - 2.310907e-01, 2.348033e-01, 2.385093e-01, 2.422086e-01, - 2.459012e-01, 2.495869e-01, 2.532658e-01, 2.569376e-01, - 2.606024e-01, 2.642600e-01, 2.679104e-01, 2.715535e-01, - 2.751892e-01, 2.788175e-01, 2.824383e-01, 2.860514e-01, - 2.896569e-01, 2.932547e-01, 2.968447e-01, 3.004268e-01, - 3.040009e-01, 3.075671e-01, 3.111252e-01, 3.146752e-01, - 3.182170e-01, 3.217506e-01, 3.252758e-01, 3.287927e-01, - 3.323012e-01, 3.358012e-01, 3.392926e-01, 3.427755e-01, - 3.462497e-01, 3.497153e-01, 3.531721e-01, 3.566201e-01, - 3.600593e-01, 3.634896e-01, 3.669110e-01, 3.703234e-01, - 3.737268e-01, 3.771211e-01, 3.805064e-01, 3.838825e-01, - 3.872494e-01, 3.906070e-01, 3.939555e-01, 3.972946e-01, - 4.006244e-01, 4.039448e-01, 4.072558e-01, 4.105574e-01, - 4.138496e-01, 4.171322e-01, 4.204054e-01, 4.236689e-01, - 4.269229e-01, 4.301673e-01, 4.334021e-01, 4.366272e-01, - 4.398426e-01, 4.430483e-01, 4.462443e-01, 4.494306e-01, - 4.526070e-01, 4.557738e-01, 4.589307e-01, 4.620778e-01, - 4.652150e-01, 4.683424e-01, 4.714600e-01, 4.745676e-01, - 4.776654e-01, 4.807532e-01, 4.838312e-01, 4.868992e-01, - 4.899573e-01, 4.930055e-01, 4.960437e-01, 4.990719e-01, - 5.020902e-01, 5.050985e-01, 5.080968e-01, 5.110852e-01, - 5.140636e-01, 5.170320e-01, 5.199904e-01, 5.229388e-01, - 5.258772e-01, 5.288056e-01, 5.317241e-01, 5.346325e-01, - 5.375310e-01, 5.404195e-01, 5.432980e-01, 5.461666e-01, - 5.490251e-01, 5.518738e-01, 5.547124e-01, 5.575411e-01, - 5.603599e-01, 5.631687e-01, 5.659676e-01, 5.687566e-01, - 5.715357e-01, 5.743048e-01, 5.770641e-01, 5.798135e-01, - 5.825531e-01, 5.852828e-01, 5.880026e-01, 5.907126e-01, - 5.934128e-01, 5.961032e-01, 5.987839e-01, 6.014547e-01, - 6.041158e-01, 6.067672e-01, 6.094088e-01, 6.120407e-01, - 6.146630e-01, 6.172755e-01, 6.198784e-01, 6.224717e-01, - 6.250554e-01, 6.276294e-01, 6.301939e-01, 6.327488e-01, - 6.352942e-01, 6.378301e-01, 6.403565e-01, 6.428734e-01, - 6.453808e-01, 6.478788e-01, 6.503674e-01, 6.528466e-01, - 6.553165e-01, 6.577770e-01, 6.602282e-01, 6.626701e-01, - 6.651027e-01, 6.675261e-01, 6.699402e-01, 6.723452e-01, - 6.747409e-01, 6.771276e-01, 6.795051e-01, 6.818735e-01, - 6.842328e-01, 6.865831e-01, 6.889244e-01, 6.912567e-01, - 6.935800e-01, 6.958943e-01, 6.981998e-01, 7.004964e-01, - 7.027841e-01, 7.050630e-01, 7.073330e-01, 7.095943e-01, - 7.118469e-01, 7.140907e-01, 7.163258e-01, 7.185523e-01, - 7.207701e-01, 7.229794e-01, 7.251800e-01, 7.273721e-01, - 7.295557e-01, 7.317307e-01, 7.338974e-01, 7.360555e-01, - 7.382053e-01, 7.403467e-01, 7.424797e-01, 7.446045e-01, - 7.467209e-01, 7.488291e-01, 7.509291e-01, 7.530208e-01, - 7.551044e-01, 7.571798e-01, 7.592472e-01, 7.613064e-01, - 7.633576e-01, 7.654008e-01, 7.674360e-01, 7.694633e-01, - 7.714826e-01, 7.734940e-01, 7.754975e-01, 7.774932e-01, - 7.794811e-01, 7.814612e-01, 7.834335e-01, 7.853982e-01, - 7.853982e-01 - }; - - - /***************************************************************************** - Function: Arc tangent - - Syntax: angle = fast_atan2(y, x); - float y y component of input vector - float x x component of input vector - float angle angle of vector (x, y) in radians - - Description: This function calculates the angle of the vector (x,y) - based on a table lookup and linear interpolation. The table uses a - 256 point table covering -45 to +45 degrees and uses symmetry to - determine the final angle value in the range of -180 to 180 - degrees. Note that this function uses the small angle approximation - for values close to zero. This routine calculates the arc tangent - with an average error of +/- 3.56e-5 degrees (6.21e-7 radians). - *****************************************************************************/ - - float - fast_atan2f(float y, float x) - { +/***************************************************************************/ +/* Constant definitions */ +/***************************************************************************/ + +#define TAN_MAP_RES 0.003921569 /* (smallest non-zero value in table) */ +#define RAD_PER_DEG 0.017453293 +#define TAN_MAP_SIZE 255 + +/* arctangents from 0 to pi/4 radians */ +static float fast_atan_table[257] = { + 0.000000e+00, 3.921549e-03, 7.842976e-03, 1.176416e-02, 1.568499e-02, 1.960533e-02, + 2.352507e-02, 2.744409e-02, 3.136226e-02, 3.527947e-02, 3.919560e-02, 4.311053e-02, + 4.702413e-02, 5.093629e-02, 5.484690e-02, 5.875582e-02, 6.266295e-02, 6.656816e-02, + 7.047134e-02, 7.437238e-02, 7.827114e-02, 8.216752e-02, 8.606141e-02, 8.995267e-02, + 9.384121e-02, 9.772691e-02, 1.016096e-01, 1.054893e-01, 1.093658e-01, 1.132390e-01, + 1.171087e-01, 1.209750e-01, 1.248376e-01, 1.286965e-01, 1.325515e-01, 1.364026e-01, + 1.402496e-01, 1.440924e-01, 1.479310e-01, 1.517652e-01, 1.555948e-01, 1.594199e-01, + 1.632403e-01, 1.670559e-01, 1.708665e-01, 1.746722e-01, 1.784728e-01, 1.822681e-01, + 1.860582e-01, 1.898428e-01, 1.936220e-01, 1.973956e-01, 2.011634e-01, 2.049255e-01, + 2.086818e-01, 2.124320e-01, 2.161762e-01, 2.199143e-01, 2.236461e-01, 2.273716e-01, + 2.310907e-01, 2.348033e-01, 2.385093e-01, 2.422086e-01, 2.459012e-01, 2.495869e-01, + 2.532658e-01, 2.569376e-01, 2.606024e-01, 2.642600e-01, 2.679104e-01, 2.715535e-01, + 2.751892e-01, 2.788175e-01, 2.824383e-01, 2.860514e-01, 2.896569e-01, 2.932547e-01, + 2.968447e-01, 3.004268e-01, 3.040009e-01, 3.075671e-01, 3.111252e-01, 3.146752e-01, + 3.182170e-01, 3.217506e-01, 3.252758e-01, 3.287927e-01, 3.323012e-01, 3.358012e-01, + 3.392926e-01, 3.427755e-01, 3.462497e-01, 3.497153e-01, 3.531721e-01, 3.566201e-01, + 3.600593e-01, 3.634896e-01, 3.669110e-01, 3.703234e-01, 3.737268e-01, 3.771211e-01, + 3.805064e-01, 3.838825e-01, 3.872494e-01, 3.906070e-01, 3.939555e-01, 3.972946e-01, + 4.006244e-01, 4.039448e-01, 4.072558e-01, 4.105574e-01, 4.138496e-01, 4.171322e-01, + 4.204054e-01, 4.236689e-01, 4.269229e-01, 4.301673e-01, 4.334021e-01, 4.366272e-01, + 4.398426e-01, 4.430483e-01, 4.462443e-01, 4.494306e-01, 4.526070e-01, 4.557738e-01, + 4.589307e-01, 4.620778e-01, 4.652150e-01, 4.683424e-01, 4.714600e-01, 4.745676e-01, + 4.776654e-01, 4.807532e-01, 4.838312e-01, 4.868992e-01, 4.899573e-01, 4.930055e-01, + 4.960437e-01, 4.990719e-01, 5.020902e-01, 5.050985e-01, 5.080968e-01, 5.110852e-01, + 5.140636e-01, 5.170320e-01, 5.199904e-01, 5.229388e-01, 5.258772e-01, 5.288056e-01, + 5.317241e-01, 5.346325e-01, 5.375310e-01, 5.404195e-01, 5.432980e-01, 5.461666e-01, + 5.490251e-01, 5.518738e-01, 5.547124e-01, 5.575411e-01, 5.603599e-01, 5.631687e-01, + 5.659676e-01, 5.687566e-01, 5.715357e-01, 5.743048e-01, 5.770641e-01, 5.798135e-01, + 5.825531e-01, 5.852828e-01, 5.880026e-01, 5.907126e-01, 5.934128e-01, 5.961032e-01, + 5.987839e-01, 6.014547e-01, 6.041158e-01, 6.067672e-01, 6.094088e-01, 6.120407e-01, + 6.146630e-01, 6.172755e-01, 6.198784e-01, 6.224717e-01, 6.250554e-01, 6.276294e-01, + 6.301939e-01, 6.327488e-01, 6.352942e-01, 6.378301e-01, 6.403565e-01, 6.428734e-01, + 6.453808e-01, 6.478788e-01, 6.503674e-01, 6.528466e-01, 6.553165e-01, 6.577770e-01, + 6.602282e-01, 6.626701e-01, 6.651027e-01, 6.675261e-01, 6.699402e-01, 6.723452e-01, + 6.747409e-01, 6.771276e-01, 6.795051e-01, 6.818735e-01, 6.842328e-01, 6.865831e-01, + 6.889244e-01, 6.912567e-01, 6.935800e-01, 6.958943e-01, 6.981998e-01, 7.004964e-01, + 7.027841e-01, 7.050630e-01, 7.073330e-01, 7.095943e-01, 7.118469e-01, 7.140907e-01, + 7.163258e-01, 7.185523e-01, 7.207701e-01, 7.229794e-01, 7.251800e-01, 7.273721e-01, + 7.295557e-01, 7.317307e-01, 7.338974e-01, 7.360555e-01, 7.382053e-01, 7.403467e-01, + 7.424797e-01, 7.446045e-01, 7.467209e-01, 7.488291e-01, 7.509291e-01, 7.530208e-01, + 7.551044e-01, 7.571798e-01, 7.592472e-01, 7.613064e-01, 7.633576e-01, 7.654008e-01, + 7.674360e-01, 7.694633e-01, 7.714826e-01, 7.734940e-01, 7.754975e-01, 7.774932e-01, + 7.794811e-01, 7.814612e-01, 7.834335e-01, 7.853982e-01, 7.853982e-01 +}; + + +/***************************************************************************** + Function: Arc tangent + + Syntax: angle = fast_atan2(y, x); + float y y component of input vector + float x x component of input vector + float angle angle of vector (x, y) in radians + + Description: This function calculates the angle of the vector (x,y) + based on a table lookup and linear interpolation. The table uses a + 256 point table covering -45 to +45 degrees and uses symmetry to + determine the final angle value in the range of -180 to 180 + degrees. Note that this function uses the small angle approximation + for values close to zero. This routine calculates the arc tangent + with an average error of +/- 3.56e-5 degrees (6.21e-7 radians). +*****************************************************************************/ + +float fast_atan2f(float y, float x) +{ float x_abs, y_abs, z; float alpha, angle, base_angle; int index; @@ -132,69 +108,66 @@ namespace gr { y_abs = fabsf(y); x_abs = fabsf(x); /* don't divide by zero! */ - if(!((y_abs > 0.0f) || (x_abs > 0.0f))) - return 0.0; + if (!((y_abs > 0.0f) || (x_abs > 0.0f))) + return 0.0; - if(y_abs < x_abs) - z = y_abs / x_abs; + if (y_abs < x_abs) + z = y_abs / x_abs; else - z = x_abs / y_abs; + z = x_abs / y_abs; /* when ratio approaches the table resolution, the angle is */ /* best approximated with the argument itself... */ - if(z < TAN_MAP_RES) - base_angle = z; + if (z < TAN_MAP_RES) + base_angle = z; else { - /* find index and interpolation value */ - alpha = z * (float)TAN_MAP_SIZE; - index = ((int)alpha) & 0xff; - alpha -= (float)index; - /* determine base angle based on quadrant and */ - /* add or subtract table value from base angle based on quadrant */ - base_angle = fast_atan_table[index]; - base_angle += (fast_atan_table[index + 1] - fast_atan_table[index]) * alpha; + /* find index and interpolation value */ + alpha = z * (float)TAN_MAP_SIZE; + index = ((int)alpha) & 0xff; + alpha -= (float)index; + /* determine base angle based on quadrant and */ + /* add or subtract table value from base angle based on quadrant */ + base_angle = fast_atan_table[index]; + base_angle += (fast_atan_table[index + 1] - fast_atan_table[index]) * alpha; } - if(x_abs > y_abs) { /* -45 -> 45 or 135 -> 225 */ - if(x >= 0.0) { /* -45 -> 45 */ - if(y >= 0.0) - angle = base_angle; /* 0 -> 45, angle OK */ - else - angle = -base_angle; /* -45 -> 0, angle = -angle */ - } - else { /* 135 -> 180 or 180 -> -135 */ - angle = 3.14159265358979323846; - if(y >= 0.0) - angle -= base_angle; /* 135 -> 180, angle = 180 - angle */ - else - angle = base_angle - angle; /* 180 -> -135, angle = angle - 180 */ - } - } - else { /* 45 -> 135 or -135 -> -45 */ - if(y >= 0.0) { /* 45 -> 135 */ - angle = 1.57079632679489661923; - if(x >= 0.0) - angle -= base_angle; /* 45 -> 90, angle = 90 - angle */ - else - angle += base_angle; /* 90 -> 135, angle = 90 + angle */ - } - else { /* -135 -> -45 */ - angle = -1.57079632679489661923; - if(x >= 0.0) - angle += base_angle; /* -90 -> -45, angle = -90 + angle */ - else - angle -= base_angle; /* -135 -> -90, angle = -90 - angle */ - } + if (x_abs > y_abs) { /* -45 -> 45 or 135 -> 225 */ + if (x >= 0.0) { /* -45 -> 45 */ + if (y >= 0.0) + angle = base_angle; /* 0 -> 45, angle OK */ + else + angle = -base_angle; /* -45 -> 0, angle = -angle */ + } else { /* 135 -> 180 or 180 -> -135 */ + angle = 3.14159265358979323846; + if (y >= 0.0) + angle -= base_angle; /* 135 -> 180, angle = 180 - angle */ + else + angle = base_angle - angle; /* 180 -> -135, angle = angle - 180 */ + } + } else { /* 45 -> 135 or -135 -> -45 */ + if (y >= 0.0) { /* 45 -> 135 */ + angle = 1.57079632679489661923; + if (x >= 0.0) + angle -= base_angle; /* 45 -> 90, angle = 90 - angle */ + else + angle += base_angle; /* 90 -> 135, angle = 90 + angle */ + } else { /* -135 -> -45 */ + angle = -1.57079632679489661923; + if (x >= 0.0) + angle += base_angle; /* -90 -> -45, angle = -90 + angle */ + else + angle -= base_angle; /* -135 -> -90, angle = -90 - angle */ + } } - #ifdef ZERO_TO_TWOPI +#ifdef ZERO_TO_TWOPI if (angle < 0) - return (angle + TWOPI); + return (angle + TWOPI); else - return (angle); - #else + return (angle); +#else return (angle); - #endif - } +#endif +} } /* namespace gr */ diff --git a/gnuradio-runtime/lib/math/fxpt.cc b/gnuradio-runtime/lib/math/fxpt.cc index b40b082194..ef8d99c35d 100644 --- a/gnuradio-runtime/lib/math/fxpt.cc +++ b/gnuradio-runtime/lib/math/fxpt.cc @@ -28,12 +28,12 @@ namespace gr { - const float fxpt::s_sine_table[1 << NBITS][2] = { - #include "sine_table.h" - }; +const float fxpt::s_sine_table[1 << NBITS][2] = { +#include "sine_table.h" +}; - const float fxpt::PI = 3.14159265358979323846; - const float fxpt::TAU = 2.0 * 3.14159265358979323846; - const float fxpt::TWO_TO_THE_31 = 2147483648.0; +const float fxpt::PI = 3.14159265358979323846; +const float fxpt::TAU = 2.0 * 3.14159265358979323846; +const float fxpt::TWO_TO_THE_31 = 2147483648.0; } /* namespace gr */ diff --git a/gnuradio-runtime/lib/math/qa_fast_atan2f.cc b/gnuradio-runtime/lib/math/qa_fast_atan2f.cc index 423a8bc415..fe41ba7e06 100644 --- a/gnuradio-runtime/lib/math/qa_fast_atan2f.cc +++ b/gnuradio-runtime/lib/math/qa_fast_atan2f.cc @@ -35,98 +35,100 @@ #define ISNAN std::isnan #endif -BOOST_AUTO_TEST_CASE(t1) { - static const unsigned int N = 100; - float c_atan2; - float gr_atan2f; - - for(float i = -N/2; i < N/2; i++) { - for(float j =-N/2; i < N/2; i++) { - float x = i/10.0; - float y = j/10.0; - c_atan2 = atan2(y, x); - - gr_atan2f = gr::fast_atan2f(y, x); - - BOOST_CHECK_CLOSE(c_atan2, gr_atan2f, 0.0); +BOOST_AUTO_TEST_CASE(t1) +{ + static const unsigned int N = 100; + float c_atan2; + float gr_atan2f; + + for (float i = -N / 2; i < N / 2; i++) { + for (float j = -N / 2; i < N / 2; i++) { + float x = i / 10.0; + float y = j / 10.0; + c_atan2 = atan2(y, x); + + gr_atan2f = gr::fast_atan2f(y, x); + + BOOST_CHECK_CLOSE(c_atan2, gr_atan2f, 0.0); + } } - } } -BOOST_AUTO_TEST_CASE(t2) { - float c_atan2; - float gr_atan2f; - float x, y; - - float inf = std::numeric_limits<float>::infinity(); - float nan = std::numeric_limits<float>::quiet_NaN(); - - /* Test x as INF */ - x = inf; - y = 0; - c_atan2 = atan2(y, x); - gr_atan2f = gr::fast_atan2f(y, x); - BOOST_CHECK_CLOSE(c_atan2, gr_atan2f, 0.0); - - x = -inf; - y = 0; - c_atan2 = atan2(y, x); - gr_atan2f = gr::fast_atan2f(y, x); - BOOST_CHECK_CLOSE(c_atan2, gr_atan2f, 0.0); - - - /* Test y as INF */ - x = 0; - y = inf; - c_atan2 = atan2(y, x); - gr_atan2f = gr::fast_atan2f(y, x); - BOOST_CHECK_CLOSE(c_atan2, gr_atan2f, 0.0); - - x = 0; - y = -inf; - c_atan2 = atan2(y, x); - gr_atan2f = gr::fast_atan2f(y, x); - BOOST_CHECK_CLOSE(c_atan2, gr_atan2f, 0.0); - - - /* Test x and y as INF */ - x = inf; - y = inf; - gr_atan2f = gr::fast_atan2f(y, x); - BOOST_CHECK(ISNAN(gr_atan2f)); - - - /* Test x as NAN */ - x = nan; - y = 0; - gr_atan2f = gr::fast_atan2f(y, x); - BOOST_CHECK_CLOSE(0.0f, gr_atan2f, 0.0001); - - x = -nan; - y = 0; - gr_atan2f = gr::fast_atan2f(y, x); - BOOST_CHECK_CLOSE(0.0f, gr_atan2f, 0.0001); - - - /* Test y as NAN */ - x = 0; - y = nan; - gr_atan2f = gr::fast_atan2f(y, x); - BOOST_CHECK_CLOSE(0.0f, gr_atan2f, 0.0001); - - x = 0; - y = -nan; - gr_atan2f = gr::fast_atan2f(y, x); - BOOST_CHECK_CLOSE(0.0f, gr_atan2f, 0.0001); - - /* Test mixed NAN and INF */ - x = inf; - y = nan; - gr_atan2f = gr::fast_atan2f(y, x); - BOOST_CHECK(ISNAN(gr_atan2f)); - - x = nan; - y = inf; - gr_atan2f = gr::fast_atan2f(y, x); - BOOST_CHECK(ISNAN(gr_atan2f)); +BOOST_AUTO_TEST_CASE(t2) +{ + float c_atan2; + float gr_atan2f; + float x, y; + + float inf = std::numeric_limits<float>::infinity(); + float nan = std::numeric_limits<float>::quiet_NaN(); + + /* Test x as INF */ + x = inf; + y = 0; + c_atan2 = atan2(y, x); + gr_atan2f = gr::fast_atan2f(y, x); + BOOST_CHECK_CLOSE(c_atan2, gr_atan2f, 0.0); + + x = -inf; + y = 0; + c_atan2 = atan2(y, x); + gr_atan2f = gr::fast_atan2f(y, x); + BOOST_CHECK_CLOSE(c_atan2, gr_atan2f, 0.0); + + + /* Test y as INF */ + x = 0; + y = inf; + c_atan2 = atan2(y, x); + gr_atan2f = gr::fast_atan2f(y, x); + BOOST_CHECK_CLOSE(c_atan2, gr_atan2f, 0.0); + + x = 0; + y = -inf; + c_atan2 = atan2(y, x); + gr_atan2f = gr::fast_atan2f(y, x); + BOOST_CHECK_CLOSE(c_atan2, gr_atan2f, 0.0); + + + /* Test x and y as INF */ + x = inf; + y = inf; + gr_atan2f = gr::fast_atan2f(y, x); + BOOST_CHECK(ISNAN(gr_atan2f)); + + + /* Test x as NAN */ + x = nan; + y = 0; + gr_atan2f = gr::fast_atan2f(y, x); + BOOST_CHECK_CLOSE(0.0f, gr_atan2f, 0.0001); + + x = -nan; + y = 0; + gr_atan2f = gr::fast_atan2f(y, x); + BOOST_CHECK_CLOSE(0.0f, gr_atan2f, 0.0001); + + + /* Test y as NAN */ + x = 0; + y = nan; + gr_atan2f = gr::fast_atan2f(y, x); + BOOST_CHECK_CLOSE(0.0f, gr_atan2f, 0.0001); + + x = 0; + y = -nan; + gr_atan2f = gr::fast_atan2f(y, x); + BOOST_CHECK_CLOSE(0.0f, gr_atan2f, 0.0001); + + /* Test mixed NAN and INF */ + x = inf; + y = nan; + gr_atan2f = gr::fast_atan2f(y, x); + BOOST_CHECK(ISNAN(gr_atan2f)); + + x = nan; + y = inf; + gr_atan2f = gr::fast_atan2f(y, x); + BOOST_CHECK(ISNAN(gr_atan2f)); } diff --git a/gnuradio-runtime/lib/math/qa_fxpt.cc b/gnuradio-runtime/lib/math/qa_fxpt.cc index ed5ea856d6..16e04b819a 100644 --- a/gnuradio-runtime/lib/math/qa_fxpt.cc +++ b/gnuradio-runtime/lib/math/qa_fxpt.cc @@ -34,61 +34,68 @@ static const float SIN_COS_TOLERANCE = 1e-5; -BOOST_AUTO_TEST_CASE(t0) { - BOOST_CHECK(std::abs(GR_M_PI/2 - gr::fxpt::fixed_to_float(0x40000000)) <= SIN_COS_TOLERANCE); - BOOST_CHECK(std::abs(0.0 - gr::fxpt::fixed_to_float(0x00000000)) <= SIN_COS_TOLERANCE); - BOOST_CHECK(std::abs(-GR_M_PI - gr::fxpt::fixed_to_float(0x80000000)) <= SIN_COS_TOLERANCE); +BOOST_AUTO_TEST_CASE(t0) +{ + BOOST_CHECK(std::abs(GR_M_PI / 2 - gr::fxpt::fixed_to_float(0x40000000)) <= + SIN_COS_TOLERANCE); + BOOST_CHECK(std::abs(0.0 - gr::fxpt::fixed_to_float(0x00000000)) <= + SIN_COS_TOLERANCE); + BOOST_CHECK(std::abs(-GR_M_PI - gr::fxpt::fixed_to_float(0x80000000)) <= + SIN_COS_TOLERANCE); - if(0) { - /* - * These are disabled because of some precision issues. - * - * Different compilers seem to have different opinions on whether - * the calculations are done single or double (or extended) - * precision. Any of the answers are fine for our real purpose, but - * sometimes the answer is off by a few bits at the bottom. - * Hence, the disabled check. - */ - BOOST_CHECK_EQUAL((int32_t)0x40000000, gr::fxpt::float_to_fixed(GR_M_PI/2)); - BOOST_CHECK_EQUAL((int32_t)0, gr::fxpt::float_to_fixed(0)); - BOOST_CHECK_EQUAL((int32_t)0x80000000, gr::fxpt::float_to_fixed(-GR_M_PI)); - } + if (0) { + /* + * These are disabled because of some precision issues. + * + * Different compilers seem to have different opinions on whether + * the calculations are done single or double (or extended) + * precision. Any of the answers are fine for our real purpose, but + * sometimes the answer is off by a few bits at the bottom. + * Hence, the disabled check. + */ + BOOST_CHECK_EQUAL((int32_t)0x40000000, gr::fxpt::float_to_fixed(GR_M_PI / 2)); + BOOST_CHECK_EQUAL((int32_t)0, gr::fxpt::float_to_fixed(0)); + BOOST_CHECK_EQUAL((int32_t)0x80000000, gr::fxpt::float_to_fixed(-GR_M_PI)); + } } -BOOST_AUTO_TEST_CASE(t1) { - BOOST_CHECK(std::abs( 0 - gr::fxpt::sin(0x00000000)) <= SIN_COS_TOLERANCE); - BOOST_CHECK(std::abs( 0.707106781 - gr::fxpt::sin(0x20000000)) <= SIN_COS_TOLERANCE); - BOOST_CHECK(std::abs( 1 - gr::fxpt::sin(0x40000000)) <= SIN_COS_TOLERANCE); - BOOST_CHECK(std::abs( 0.707106781 - gr::fxpt::sin(0x60000000)) <= SIN_COS_TOLERANCE); - BOOST_CHECK(std::abs( 0 - gr::fxpt::sin(0x7fffffff)) <= SIN_COS_TOLERANCE); - BOOST_CHECK(std::abs( 0 - gr::fxpt::sin(0x80000000)) <= SIN_COS_TOLERANCE); - BOOST_CHECK(std::abs( 0 - gr::fxpt::sin(0x80000001)) <= SIN_COS_TOLERANCE); - BOOST_CHECK(std::abs(-1 - gr::fxpt::sin(-0x40000000)) <= SIN_COS_TOLERANCE); - BOOST_CHECK(std::abs(-0.707106781 - gr::fxpt::sin(-0x20000000)) <= SIN_COS_TOLERANCE); +BOOST_AUTO_TEST_CASE(t1) +{ + BOOST_CHECK(std::abs(0 - gr::fxpt::sin(0x00000000)) <= SIN_COS_TOLERANCE); + BOOST_CHECK(std::abs(0.707106781 - gr::fxpt::sin(0x20000000)) <= SIN_COS_TOLERANCE); + BOOST_CHECK(std::abs(1 - gr::fxpt::sin(0x40000000)) <= SIN_COS_TOLERANCE); + BOOST_CHECK(std::abs(0.707106781 - gr::fxpt::sin(0x60000000)) <= SIN_COS_TOLERANCE); + BOOST_CHECK(std::abs(0 - gr::fxpt::sin(0x7fffffff)) <= SIN_COS_TOLERANCE); + BOOST_CHECK(std::abs(0 - gr::fxpt::sin(0x80000000)) <= SIN_COS_TOLERANCE); + BOOST_CHECK(std::abs(0 - gr::fxpt::sin(0x80000001)) <= SIN_COS_TOLERANCE); + BOOST_CHECK(std::abs(-1 - gr::fxpt::sin(-0x40000000)) <= SIN_COS_TOLERANCE); + BOOST_CHECK(std::abs(-0.707106781 - gr::fxpt::sin(-0x20000000)) <= SIN_COS_TOLERANCE); - for(float p = -GR_M_PI; p < GR_M_PI; p += 2 * GR_M_PI / 3600) { - float expected = sin(p); - float actual = gr::fxpt::sin(gr::fxpt::float_to_fixed (p)); - BOOST_CHECK(std::abs(expected - actual) <= SIN_COS_TOLERANCE); - } + for (float p = -GR_M_PI; p < GR_M_PI; p += 2 * GR_M_PI / 3600) { + float expected = sin(p); + float actual = gr::fxpt::sin(gr::fxpt::float_to_fixed(p)); + BOOST_CHECK(std::abs(expected - actual) <= SIN_COS_TOLERANCE); + } } -BOOST_AUTO_TEST_CASE(t2) { - for(float p = -GR_M_PI; p < GR_M_PI; p += 2 * GR_M_PI / 3600) { - float expected = cos(p); - float actual = gr::fxpt::cos(gr::fxpt::float_to_fixed(p)); - BOOST_CHECK(std::abs(expected - actual) <= SIN_COS_TOLERANCE); - } +BOOST_AUTO_TEST_CASE(t2) +{ + for (float p = -GR_M_PI; p < GR_M_PI; p += 2 * GR_M_PI / 3600) { + float expected = cos(p); + float actual = gr::fxpt::cos(gr::fxpt::float_to_fixed(p)); + BOOST_CHECK(std::abs(expected - actual) <= SIN_COS_TOLERANCE); + } } -BOOST_AUTO_TEST_CASE(t3) { - for(float p = -GR_M_PI; p < GR_M_PI; p += 2 * GR_M_PI / 3600) { - float expected_sin = sin(p); - float expected_cos = cos(p); - float actual_sin; - float actual_cos; - gr::fxpt::sincos(gr::fxpt::float_to_fixed (p), &actual_sin, &actual_cos); - BOOST_CHECK(std::abs(expected_sin - actual_sin) <= SIN_COS_TOLERANCE); - BOOST_CHECK(std::abs(expected_cos - actual_cos) <= SIN_COS_TOLERANCE); - } +BOOST_AUTO_TEST_CASE(t3) +{ + for (float p = -GR_M_PI; p < GR_M_PI; p += 2 * GR_M_PI / 3600) { + float expected_sin = sin(p); + float expected_cos = cos(p); + float actual_sin; + float actual_cos; + gr::fxpt::sincos(gr::fxpt::float_to_fixed(p), &actual_sin, &actual_cos); + BOOST_CHECK(std::abs(expected_sin - actual_sin) <= SIN_COS_TOLERANCE); + BOOST_CHECK(std::abs(expected_cos - actual_cos) <= SIN_COS_TOLERANCE); + } } diff --git a/gnuradio-runtime/lib/math/qa_fxpt_nco.cc b/gnuradio-runtime/lib/math/qa_fxpt_nco.cc index da10f49c92..2c4a8c327a 100644 --- a/gnuradio-runtime/lib/math/qa_fxpt_nco.cc +++ b/gnuradio-runtime/lib/math/qa_fxpt_nco.cc @@ -34,76 +34,80 @@ static const float SIN_COS_TOLERANCE = 1e-5; -//static const float SIN_COS_FREQ = 5003; +// static const float SIN_COS_FREQ = 5003; static const float SIN_COS_FREQ = 4096; static const int SIN_COS_BLOCK_SIZE = 100000; -static double max_d(double a, double b) -{ - return fabs(a) > fabs(b) ? a : b; -} +static double max_d(double a, double b) { return fabs(a) > fabs(b) ? a : b; } -BOOST_AUTO_TEST_CASE(t0) { - gr::nco<float,float> ref_nco; - gr::fxpt_nco new_nco; - double max_error = 0, max_phase_error = 0; +BOOST_AUTO_TEST_CASE(t0) +{ + gr::nco<float, float> ref_nco; + gr::fxpt_nco new_nco; + double max_error = 0, max_phase_error = 0; - ref_nco.set_freq((float)(2 * GR_M_PI / SIN_COS_FREQ)); - new_nco.set_freq((float)(2 * GR_M_PI / SIN_COS_FREQ)); + ref_nco.set_freq((float)(2 * GR_M_PI / SIN_COS_FREQ)); + new_nco.set_freq((float)(2 * GR_M_PI / SIN_COS_FREQ)); - BOOST_CHECK(std::abs(ref_nco.get_freq() - new_nco.get_freq()) <= SIN_COS_TOLERANCE); + BOOST_CHECK(std::abs(ref_nco.get_freq() - new_nco.get_freq()) <= SIN_COS_TOLERANCE); - for(int i = 0; i < SIN_COS_BLOCK_SIZE; i++) { - float ref_sin = ref_nco.sin(); - float new_sin = new_nco.sin(); - //printf ("i = %6d\n", i); - BOOST_CHECK(std::abs(ref_sin - new_sin) <= SIN_COS_TOLERANCE); + for (int i = 0; i < SIN_COS_BLOCK_SIZE; i++) { + float ref_sin = ref_nco.sin(); + float new_sin = new_nco.sin(); + // printf ("i = %6d\n", i); + BOOST_CHECK(std::abs(ref_sin - new_sin) <= SIN_COS_TOLERANCE); - max_error = max_d(max_error, ref_sin-new_sin); + max_error = max_d(max_error, ref_sin - new_sin); - float ref_cos = ref_nco.cos(); - float new_cos = new_nco.cos(); - BOOST_CHECK(std::abs(ref_cos - new_cos) <= SIN_COS_TOLERANCE); + float ref_cos = ref_nco.cos(); + float new_cos = new_nco.cos(); + BOOST_CHECK(std::abs(ref_cos - new_cos) <= SIN_COS_TOLERANCE); - max_error = max_d(max_error, ref_cos-new_cos); + max_error = max_d(max_error, ref_cos - new_cos); - ref_nco.step(); - new_nco.step(); + ref_nco.step(); + new_nco.step(); - BOOST_CHECK(std::abs(ref_nco.get_phase() - new_nco.get_phase()) <= SIN_COS_TOLERANCE); + BOOST_CHECK(std::abs(ref_nco.get_phase() - new_nco.get_phase()) <= + SIN_COS_TOLERANCE); - max_phase_error = max_d(max_phase_error, ref_nco.get_phase()-new_nco.get_phase()); - } - // printf ("Fxpt max error %.9f, max phase error %.9f\n", max_error, max_phase_error); + max_phase_error = + max_d(max_phase_error, ref_nco.get_phase() - new_nco.get_phase()); + } + // printf ("Fxpt max error %.9f, max phase error %.9f\n", max_error, + // max_phase_error); } -BOOST_AUTO_TEST_CASE(t1) { - gr::nco<float,float> ref_nco; - gr::fxpt_nco new_nco; - gr_complex* ref_block = new gr_complex[SIN_COS_BLOCK_SIZE]; - gr_complex* new_block = new gr_complex[SIN_COS_BLOCK_SIZE]; - double max_error = 0; +BOOST_AUTO_TEST_CASE(t1) +{ + gr::nco<float, float> ref_nco; + gr::fxpt_nco new_nco; + gr_complex* ref_block = new gr_complex[SIN_COS_BLOCK_SIZE]; + gr_complex* new_block = new gr_complex[SIN_COS_BLOCK_SIZE]; + double max_error = 0; - ref_nco.set_freq((float)(2 * GR_M_PI / SIN_COS_FREQ)); - new_nco.set_freq((float)(2 * GR_M_PI / SIN_COS_FREQ)); + ref_nco.set_freq((float)(2 * GR_M_PI / SIN_COS_FREQ)); + new_nco.set_freq((float)(2 * GR_M_PI / SIN_COS_FREQ)); - BOOST_CHECK(std::abs(ref_nco.get_freq() - new_nco.get_freq()) <= SIN_COS_TOLERANCE); + BOOST_CHECK(std::abs(ref_nco.get_freq() - new_nco.get_freq()) <= SIN_COS_TOLERANCE); - ref_nco.sincos((gr_complex*)ref_block, SIN_COS_BLOCK_SIZE); - new_nco.sincos((gr_complex*)new_block, SIN_COS_BLOCK_SIZE); + ref_nco.sincos((gr_complex*)ref_block, SIN_COS_BLOCK_SIZE); + new_nco.sincos((gr_complex*)new_block, SIN_COS_BLOCK_SIZE); - for(int i = 0; i < SIN_COS_BLOCK_SIZE; i++) { - BOOST_CHECK(std::abs(ref_block[i].real() - new_block[i].real()) <= SIN_COS_TOLERANCE); - max_error = max_d (max_error, ref_block[i].real()-new_block[i].real()); + for (int i = 0; i < SIN_COS_BLOCK_SIZE; i++) { + BOOST_CHECK(std::abs(ref_block[i].real() - new_block[i].real()) <= + SIN_COS_TOLERANCE); + max_error = max_d(max_error, ref_block[i].real() - new_block[i].real()); - BOOST_CHECK(std::abs(ref_block[i].imag() - new_block[i].imag()) <= SIN_COS_TOLERANCE); - max_error = max_d (max_error, ref_block[i].imag()-new_block[i].imag()); - } - BOOST_CHECK(std::abs(ref_nco.get_phase() - new_nco.get_phase()) <= SIN_COS_TOLERANCE); - // printf ("Fxpt max error %.9f, max phase error %.9f\n", max_error, max_phase_error); - delete[] ref_block; - delete[] new_block; + BOOST_CHECK(std::abs(ref_block[i].imag() - new_block[i].imag()) <= + SIN_COS_TOLERANCE); + max_error = max_d(max_error, ref_block[i].imag() - new_block[i].imag()); + } + BOOST_CHECK(std::abs(ref_nco.get_phase() - new_nco.get_phase()) <= SIN_COS_TOLERANCE); + // printf ("Fxpt max error %.9f, max phase error %.9f\n", max_error, + // max_phase_error); + delete[] ref_block; + delete[] new_block; } - diff --git a/gnuradio-runtime/lib/math/qa_fxpt_vco.cc b/gnuradio-runtime/lib/math/qa_fxpt_vco.cc index d4952fe25c..a24e38d63b 100644 --- a/gnuradio-runtime/lib/math/qa_fxpt_vco.cc +++ b/gnuradio-runtime/lib/math/qa_fxpt_vco.cc @@ -39,90 +39,92 @@ static const float SIN_COS_AMPL = 0.8; static const int SIN_COS_BLOCK_SIZE = 100000; -static double max_d(double a, double b) +static double max_d(double a, double b) { return fabs(a) > fabs(b) ? a : b; } + +BOOST_AUTO_TEST_CASE(t0) { - return fabs(a) > fabs(b) ? a : b; -} + gr::vco<float, float> ref_vco; + gr::fxpt_vco new_vco; + double max_error = 0, max_phase_error = 0; + float input[SIN_COS_BLOCK_SIZE]; -BOOST_AUTO_TEST_CASE(t0) { - gr::vco<float,float> ref_vco; - gr::fxpt_vco new_vco; - double max_error = 0, max_phase_error = 0; - float input[SIN_COS_BLOCK_SIZE]; + for (int i = 0; i < SIN_COS_BLOCK_SIZE; i++) { + input[i] = sin(double(i)); + } - for(int i = 0; i < SIN_COS_BLOCK_SIZE; i++) { - input[i] = sin(double(i)); - } + for (int i = 0; i < SIN_COS_BLOCK_SIZE; i++) { + float ref_cos = ref_vco.cos(); + float new_cos = new_vco.cos(); + BOOST_CHECK(std::abs(ref_cos - new_cos) <= SIN_COS_TOLERANCE); - for(int i = 0; i < SIN_COS_BLOCK_SIZE; i++) { - float ref_cos = ref_vco.cos(); - float new_cos = new_vco.cos(); - BOOST_CHECK(std::abs(ref_cos - new_cos) <= SIN_COS_TOLERANCE); + max_error = max_d(max_error, ref_cos - new_cos); - max_error = max_d(max_error, ref_cos-new_cos); + ref_vco.adjust_phase(input[i]); + new_vco.adjust_phase(input[i]); - ref_vco.adjust_phase(input[i]); - new_vco.adjust_phase(input[i]); + BOOST_CHECK(std::abs(ref_vco.get_phase() - new_vco.get_phase()) <= + SIN_COS_TOLERANCE); - BOOST_CHECK(std::abs(ref_vco.get_phase() - new_vco.get_phase()) <= SIN_COS_TOLERANCE); - - max_phase_error = max_d(max_phase_error, ref_vco.get_phase()-new_vco.get_phase()); - } - // printf ("Fxpt max error %.9f, max phase error %.9f\n", max_error, max_phase_error); + max_phase_error = + max_d(max_phase_error, ref_vco.get_phase() - new_vco.get_phase()); + } + // printf ("Fxpt max error %.9f, max phase error %.9f\n", max_error, + // max_phase_error); } -BOOST_AUTO_TEST_CASE(t1) { - gr::vco<float,float> ref_vco; - gr::fxpt_vco new_vco; - float *ref_block = new float[SIN_COS_BLOCK_SIZE]; - float *new_block = new float[SIN_COS_BLOCK_SIZE]; - float *input = new float[SIN_COS_BLOCK_SIZE]; - double max_error = 0; - - for(int i = 0; i < SIN_COS_BLOCK_SIZE; i++) { - input[i] = sin(double(i)); - } - - ref_vco.cos(ref_block, input, SIN_COS_BLOCK_SIZE, SIN_COS_K, SIN_COS_AMPL); - new_vco.cos(new_block, input, SIN_COS_BLOCK_SIZE, SIN_COS_K, SIN_COS_AMPL); - - for(int i = 0; i < SIN_COS_BLOCK_SIZE; i++) { - BOOST_CHECK(std::abs(ref_block[i] - new_block[i]) <= SIN_COS_TOLERANCE); - max_error = max_d(max_error, ref_block[i]-new_block[i]); - } - BOOST_CHECK(std::abs(ref_vco.get_phase() - new_vco.get_phase()) <= SIN_COS_TOLERANCE); - // printf ("Fxpt max error %.9f, max phase error %.9f\n", max_error, ref_vco.get_phase()-new_vco.get_phase()); - delete[] ref_block; - delete[] new_block; - delete[] input; +BOOST_AUTO_TEST_CASE(t1) +{ + gr::vco<float, float> ref_vco; + gr::fxpt_vco new_vco; + float* ref_block = new float[SIN_COS_BLOCK_SIZE]; + float* new_block = new float[SIN_COS_BLOCK_SIZE]; + float* input = new float[SIN_COS_BLOCK_SIZE]; + double max_error = 0; + + for (int i = 0; i < SIN_COS_BLOCK_SIZE; i++) { + input[i] = sin(double(i)); + } + + ref_vco.cos(ref_block, input, SIN_COS_BLOCK_SIZE, SIN_COS_K, SIN_COS_AMPL); + new_vco.cos(new_block, input, SIN_COS_BLOCK_SIZE, SIN_COS_K, SIN_COS_AMPL); + + for (int i = 0; i < SIN_COS_BLOCK_SIZE; i++) { + BOOST_CHECK(std::abs(ref_block[i] - new_block[i]) <= SIN_COS_TOLERANCE); + max_error = max_d(max_error, ref_block[i] - new_block[i]); + } + BOOST_CHECK(std::abs(ref_vco.get_phase() - new_vco.get_phase()) <= SIN_COS_TOLERANCE); + // printf ("Fxpt max error %.9f, max phase error %.9f\n", max_error, + // ref_vco.get_phase()-new_vco.get_phase()); + delete[] ref_block; + delete[] new_block; + delete[] input; } -BOOST_AUTO_TEST_CASE(t2) { - gr::vco<gr_complex,float> ref_vco; - gr::fxpt_vco new_vco; - gr_complex *ref_block = new gr_complex[SIN_COS_BLOCK_SIZE]; - gr_complex *new_block = new gr_complex[SIN_COS_BLOCK_SIZE]; - float *input = new float[SIN_COS_BLOCK_SIZE]; - double max_error = 0; - - for(int i = 0; i < SIN_COS_BLOCK_SIZE; i++) { - input[i] = sin(double(i)); - } - - ref_vco.sincos(ref_block, input, SIN_COS_BLOCK_SIZE, SIN_COS_K, SIN_COS_AMPL); - new_vco.sincos(new_block, input, SIN_COS_BLOCK_SIZE, SIN_COS_K, SIN_COS_AMPL); - - for(int i = 0; i < SIN_COS_BLOCK_SIZE; i++) { - BOOST_CHECK(std::abs(ref_block[i] - new_block[i]) <= SIN_COS_TOLERANCE); - max_error = max_d(max_error, abs(ref_block[i]-new_block[i])); - } - BOOST_CHECK( - std::abs(ref_vco.get_phase() - new_vco.get_phase()) <= SIN_COS_TOLERANCE - ); - // printf ("Fxpt max error %.9f, max phase error %.9f\n", max_error, ref_vco.get_phase()-new_vco.get_phase()); - delete[] ref_block; - delete[] new_block; - delete[] input; +BOOST_AUTO_TEST_CASE(t2) +{ + gr::vco<gr_complex, float> ref_vco; + gr::fxpt_vco new_vco; + gr_complex* ref_block = new gr_complex[SIN_COS_BLOCK_SIZE]; + gr_complex* new_block = new gr_complex[SIN_COS_BLOCK_SIZE]; + float* input = new float[SIN_COS_BLOCK_SIZE]; + double max_error = 0; + + for (int i = 0; i < SIN_COS_BLOCK_SIZE; i++) { + input[i] = sin(double(i)); + } + + ref_vco.sincos(ref_block, input, SIN_COS_BLOCK_SIZE, SIN_COS_K, SIN_COS_AMPL); + new_vco.sincos(new_block, input, SIN_COS_BLOCK_SIZE, SIN_COS_K, SIN_COS_AMPL); + + for (int i = 0; i < SIN_COS_BLOCK_SIZE; i++) { + BOOST_CHECK(std::abs(ref_block[i] - new_block[i]) <= SIN_COS_TOLERANCE); + max_error = max_d(max_error, abs(ref_block[i] - new_block[i])); + } + BOOST_CHECK(std::abs(ref_vco.get_phase() - new_vco.get_phase()) <= SIN_COS_TOLERANCE); + // printf ("Fxpt max error %.9f, max phase error %.9f\n", max_error, + // ref_vco.get_phase()-new_vco.get_phase()); + delete[] ref_block; + delete[] new_block; + delete[] input; } - diff --git a/gnuradio-runtime/lib/math/qa_math.cc b/gnuradio-runtime/lib/math/qa_math.cc index da8322059c..46833286e9 100644 --- a/gnuradio-runtime/lib/math/qa_math.cc +++ b/gnuradio-runtime/lib/math/qa_math.cc @@ -24,76 +24,82 @@ #include <stdio.h> #include <cmath> -BOOST_AUTO_TEST_CASE(test_binary_slicer1) { - float x[5] = {-1, -0.5, 0, 0.5, 1.0}; - unsigned int z[5] = {0, 0, 1, 1, 1}; - unsigned int y; - - //printf("\nBinary\n"); - for(unsigned int i = 0; i < 5; i++) { - y = gr::binary_slicer(x[i]); - //printf("in: %f out: %d desired: %d\n", x[i], y, z[i]); - - BOOST_CHECK_EQUAL(y, z[i]); - } - - //printf("\nBranchless Binary\n"); - for (unsigned int i = 0; i < 5; i++) { - y = gr::branchless_binary_slicer(x[i]); - //printf("in: %f out: %d desired: %d\n", x[i], y, z[i]); - - BOOST_CHECK_EQUAL(y, z[i]); - } +BOOST_AUTO_TEST_CASE(test_binary_slicer1) +{ + float x[5] = { -1, -0.5, 0, 0.5, 1.0 }; + unsigned int z[5] = { 0, 0, 1, 1, 1 }; + unsigned int y; + + // printf("\nBinary\n"); + for (unsigned int i = 0; i < 5; i++) { + y = gr::binary_slicer(x[i]); + // printf("in: %f out: %d desired: %d\n", x[i], y, z[i]); + + BOOST_CHECK_EQUAL(y, z[i]); + } + + // printf("\nBranchless Binary\n"); + for (unsigned int i = 0; i < 5; i++) { + y = gr::branchless_binary_slicer(x[i]); + // printf("in: %f out: %d desired: %d\n", x[i], y, z[i]); + + BOOST_CHECK_EQUAL(y, z[i]); + } } -BOOST_AUTO_TEST_CASE(test_quad_0deg_slicer1) { - gr_complex x[4] = {gr_complex(1, 0), - gr_complex(0, 1), - gr_complex(-1, 0), - gr_complex(0, -1)}; +BOOST_AUTO_TEST_CASE(test_quad_0deg_slicer1) +{ + gr_complex x[4] = { + gr_complex(1, 0), gr_complex(0, 1), gr_complex(-1, 0), gr_complex(0, -1) + }; - unsigned int z[4] = {0, 1, 2, 3}; - unsigned int y; + unsigned int z[4] = { 0, 1, 2, 3 }; + unsigned int y; - //printf("\nQuad0\n"); - for (unsigned int i = 0; i < 4; i++) { - y = gr::quad_0deg_slicer(x[i]); - //printf("in: %.4f+j%.4f out: %d desired: %d\n", x[i].real(), x[i].imag(), y, z[i]); + // printf("\nQuad0\n"); + for (unsigned int i = 0; i < 4; i++) { + y = gr::quad_0deg_slicer(x[i]); + // printf("in: %.4f+j%.4f out: %d desired: %d\n", x[i].real(), x[i].imag(), y, + // z[i]); - BOOST_CHECK_EQUAL(y, z[i]); - } + BOOST_CHECK_EQUAL(y, z[i]); + } - //printf("\nBranchless Quad0\n"); - for (unsigned int i = 0; i < 4; i++) { - y = gr::branchless_quad_0deg_slicer(x[i]); - //printf("in: %.4f+j%.4f out: %d desired: %d\n", x[i].real(), x[i].imag(), y, z[i]); + // printf("\nBranchless Quad0\n"); + for (unsigned int i = 0; i < 4; i++) { + y = gr::branchless_quad_0deg_slicer(x[i]); + // printf("in: %.4f+j%.4f out: %d desired: %d\n", x[i].real(), x[i].imag(), y, + // z[i]); - BOOST_CHECK_EQUAL(y, z[i]); - } + BOOST_CHECK_EQUAL(y, z[i]); + } } -BOOST_AUTO_TEST_CASE(test_quad_45deg_slicer1) { - gr_complex x[4] = {gr_complex(0.707, 0.707), - gr_complex(-0.707, 0.707), - gr_complex(-0.707, -0.707), - gr_complex(0.707, -0.707)}; - - unsigned int z[4] = {0, 1, 2, 3}; - unsigned int y; - - //printf("\nQuad45\n"); - for (unsigned int i = 0; i < 4; i++) { - y = gr::quad_45deg_slicer(x[i]); - //printf("in: %.4f+j%.4f out: %d desired: %d\n", x[i].real(), x[i].imag(), y, z[i]); - - BOOST_CHECK_EQUAL(y, z[i]); - } - - //printf("\nBranchless Quad45\n"); - for (unsigned int i = 0; i < 4; i++) { - y = gr::branchless_quad_45deg_slicer(x[i]); - //printf("in: %.4f+j%.4f out: %d desired: %d\n", x[i].real(), x[i].imag(), y, z[i]); - - BOOST_CHECK_EQUAL(y, z[i]); - } +BOOST_AUTO_TEST_CASE(test_quad_45deg_slicer1) +{ + gr_complex x[4] = { gr_complex(0.707, 0.707), + gr_complex(-0.707, 0.707), + gr_complex(-0.707, -0.707), + gr_complex(0.707, -0.707) }; + + unsigned int z[4] = { 0, 1, 2, 3 }; + unsigned int y; + + // printf("\nQuad45\n"); + for (unsigned int i = 0; i < 4; i++) { + y = gr::quad_45deg_slicer(x[i]); + // printf("in: %.4f+j%.4f out: %d desired: %d\n", x[i].real(), x[i].imag(), y, + // z[i]); + + BOOST_CHECK_EQUAL(y, z[i]); + } + + // printf("\nBranchless Quad45\n"); + for (unsigned int i = 0; i < 4; i++) { + y = gr::branchless_quad_45deg_slicer(x[i]); + // printf("in: %.4f+j%.4f out: %d desired: %d\n", x[i].real(), x[i].imag(), y, + // z[i]); + + BOOST_CHECK_EQUAL(y, z[i]); + } } diff --git a/gnuradio-runtime/lib/math/qa_sincos.cc b/gnuradio-runtime/lib/math/qa_sincos.cc index 4ce81fb4f8..52fbc53d3c 100644 --- a/gnuradio-runtime/lib/math/qa_sincos.cc +++ b/gnuradio-runtime/lib/math/qa_sincos.cc @@ -28,36 +28,38 @@ #include <boost/test/unit_test.hpp> #include <cmath> -BOOST_AUTO_TEST_CASE(t1) { - static const unsigned int N = 1000; - double c_sin, c_cos; - double gr_sin, gr_cos; +BOOST_AUTO_TEST_CASE(t1) +{ + static const unsigned int N = 1000; + double c_sin, c_cos; + double gr_sin, gr_cos; - for(unsigned i = 0; i < N; i++) { - double x = i/100.0; - c_sin = sin(x); - c_cos = cos(x); + for (unsigned i = 0; i < N; i++) { + double x = i / 100.0; + c_sin = sin(x); + c_cos = cos(x); - gr::sincos(x, &gr_sin, &gr_cos); + gr::sincos(x, &gr_sin, &gr_cos); - BOOST_CHECK_CLOSE(c_sin, gr_sin, 0.0001); - BOOST_CHECK_CLOSE(c_cos, gr_cos, 0.0001); - } + BOOST_CHECK_CLOSE(c_sin, gr_sin, 0.0001); + BOOST_CHECK_CLOSE(c_cos, gr_cos, 0.0001); + } } -BOOST_AUTO_TEST_CASE(t2) { - static const unsigned int N = 1000; - float c_sin, c_cos; - float gr_sin, gr_cos; +BOOST_AUTO_TEST_CASE(t2) +{ + static const unsigned int N = 1000; + float c_sin, c_cos; + float gr_sin, gr_cos; - for(unsigned i = 0; i < N; i++) { - float x = i/100.0; - c_sin = sinf(x); - c_cos = cosf(x); + for (unsigned i = 0; i < N; i++) { + float x = i / 100.0; + c_sin = sinf(x); + c_cos = cosf(x); - gr::sincosf(x, &gr_sin, &gr_cos); + gr::sincosf(x, &gr_sin, &gr_cos); - BOOST_CHECK_CLOSE(c_sin, gr_sin, 0.0001); - BOOST_CHECK_CLOSE(c_cos, gr_cos, 0.0001); - } + BOOST_CHECK_CLOSE(c_sin, gr_sin, 0.0001); + BOOST_CHECK_CLOSE(c_cos, gr_cos, 0.0001); + } } diff --git a/gnuradio-runtime/lib/math/random.cc b/gnuradio-runtime/lib/math/random.cc index 6a509f1796..9e30c94399 100644 --- a/gnuradio-runtime/lib/math/random.cc +++ b/gnuradio-runtime/lib/math/random.cc @@ -46,134 +46,124 @@ namespace gr { - random::random(unsigned int seed, int min_integer, int max_integer) - { +random::random(unsigned int seed, int min_integer, int max_integer) +{ d_gauss_stored = false; // set gasdev (gauss distributed numbers) on calculation state // Setup random number generators - d_rng = new boost::mt19937; // random numbers are generated here. - d_uniform = new boost::uniform_real<float>; // map random number to distribution + d_rng = new boost::mt19937; // random numbers are generated here. + d_uniform = new boost::uniform_real<float>; // map random number to distribution d_integer_dis = new boost::uniform_int<>(0, 1); // another "mapper" d_generator = NULL; // MUST be reinstantiated on every call to reseed. - d_integer_generator = NULL; // MUST be reinstantiated on everytime d_rng or d_integer_dis is changed. + d_integer_generator = + NULL; // MUST be reinstantiated on everytime d_rng or d_integer_dis is changed. reseed(seed); // set seed for random number generator set_integer_limits(min_integer, max_integer); - } - - random::~random() - { - delete d_rng; - delete d_uniform; - delete d_integer_dis; - delete d_generator; - delete d_integer_generator; - } - - /* - * Seed is initialized with time if the given seed is 0. Otherwise the seed is taken directly. Sets the seed for the random number generator. - */ - void - random::reseed(unsigned int seed) - { +} + +random::~random() +{ + delete d_rng; + delete d_uniform; + delete d_integer_dis; + delete d_generator; + delete d_integer_generator; +} + +/* + * Seed is initialized with time if the given seed is 0. Otherwise the seed is taken + * directly. Sets the seed for the random number generator. + */ +void random::reseed(unsigned int seed) +{ d_seed = seed; - if (d_seed == 0){ - d_rng->seed(); + if (d_seed == 0) { + d_rng->seed(); } else { - d_rng->seed(d_seed); + d_rng->seed(d_seed); } // reinstantiate generators. Otherwise reseed doesn't take effect. delete d_generator; - d_generator = new boost::variate_generator<boost::mt19937&, boost::uniform_real<float> > (*d_rng,*d_uniform); // create number generator in [0,1) from boost.random + d_generator = + new boost::variate_generator<boost::mt19937&, boost::uniform_real<float>>( + *d_rng, *d_uniform); // create number generator in [0,1) from boost.random delete d_integer_generator; - d_integer_generator = new boost::variate_generator<boost::mt19937&, boost::uniform_int<> >(*d_rng, *d_integer_dis); - } + d_integer_generator = + new boost::variate_generator<boost::mt19937&, boost::uniform_int<>>( + *d_rng, *d_integer_dis); +} - void - random::set_integer_limits(const int minimum, const int maximum){ +void random::set_integer_limits(const int minimum, const int maximum) +{ // boost expects integer limits defined as [minimum, maximum] which is unintuitive. // use the expected half open interval behavior! [minimum, maximum)! delete d_integer_generator; delete d_integer_dis; d_integer_dis = new boost::uniform_int<>(minimum, maximum - 1); - d_integer_generator = new boost::variate_generator<boost::mt19937&, boost::uniform_int<> >(*d_rng, *d_integer_dis); - } - - /*! - * Uniform random integers in the range set by 'set_integer_limits' [min, max). - */ - int - random::ran_int(){ - return (*d_integer_generator)(); - } - - /* - * Returns uniformly distributed numbers in [0,1) taken from boost.random using a Mersenne twister - */ - float - random::ran1() - { - return (*d_generator)(); - } - - /* - * Returns a normally distributed deviate with zero mean and variance 1. - * Used is the Marsaglia polar method. - * Every second call a number is stored because the transformation works only in pairs. Otherwise half calculation is thrown away. - */ - float - random::gasdev() - { - if(d_gauss_stored){ // just return the stored value if available - d_gauss_stored = false; - return d_gauss_value; - } - else{ // generate a pair of gaussian distributed numbers - float x,y,s; - do{ - x = 2.0*ran1()-1.0; - y = 2.0*ran1()-1.0; - s = x*x+y*y; - }while(s >= 1.0f || s == 0.0f); - d_gauss_stored = true; - d_gauss_value = x*sqrtf(-2.0*logf(s)/s); - return y*sqrtf(-2.0*logf(s)/s); - } - } - - float - random::laplacian() - { - float z = ran1(); - if (z > 0.5f){ - return -logf(2.0f * (1.0f - z) ); - } - return logf(2 * z); - } - /* - * Copied from The KC7WW / OH2BNS Channel Simulator - * FIXME Need to check how good this is at some point - */ - // 5 => scratchy, 8 => Geiger - float - random::impulse(float factor = 5) - { + d_integer_generator = + new boost::variate_generator<boost::mt19937&, boost::uniform_int<>>( + *d_rng, *d_integer_dis); +} + +/*! + * Uniform random integers in the range set by 'set_integer_limits' [min, max). + */ +int random::ran_int() { return (*d_integer_generator)(); } + +/* + * Returns uniformly distributed numbers in [0,1) taken from boost.random using a Mersenne + * twister + */ +float random::ran1() { return (*d_generator)(); } + +/* + * Returns a normally distributed deviate with zero mean and variance 1. + * Used is the Marsaglia polar method. + * Every second call a number is stored because the transformation works only in pairs. + * Otherwise half calculation is thrown away. + */ +float random::gasdev() +{ + if (d_gauss_stored) { // just return the stored value if available + d_gauss_stored = false; + return d_gauss_value; + } else { // generate a pair of gaussian distributed numbers + float x, y, s; + do { + x = 2.0 * ran1() - 1.0; + y = 2.0 * ran1() - 1.0; + s = x * x + y * y; + } while (s >= 1.0f || s == 0.0f); + d_gauss_stored = true; + d_gauss_value = x * sqrtf(-2.0 * logf(s) / s); + return y * sqrtf(-2.0 * logf(s) / s); + } +} + +float random::laplacian() +{ + float z = ran1(); + if (z > 0.5f) { + return -logf(2.0f * (1.0f - z)); + } + return logf(2 * z); +} +/* + * Copied from The KC7WW / OH2BNS Channel Simulator + * FIXME Need to check how good this is at some point + */ +// 5 => scratchy, 8 => Geiger +float random::impulse(float factor = 5) +{ float z = -GR_M_SQRT2 * logf(ran1()); - if(fabsf(z) <= factor) - return 0.0; + if (fabsf(z) <= factor) + return 0.0; else - return z; - } - - gr_complex - random::rayleigh_complex() - { - return gr_complex(gasdev(),gasdev()); - } - - float - random::rayleigh() - { - return sqrtf(-2.0 * logf(ran1())); - } + return z; +} + +gr_complex random::rayleigh_complex() { return gr_complex(gasdev(), gasdev()); } + +float random::rayleigh() { return sqrtf(-2.0 * logf(ran1())); } } /* namespace gr */ diff --git a/gnuradio-runtime/lib/math/sincos.cc b/gnuradio-runtime/lib/math/sincos.cc index 49a90d2128..de97fc355e 100644 --- a/gnuradio-runtime/lib/math/sincos.cc +++ b/gnuradio-runtime/lib/math/sincos.cc @@ -25,7 +25,7 @@ #endif #ifndef _GNU_SOURCE -#define _GNU_SOURCE // ask for GNU extensions if available +#define _GNU_SOURCE // ask for GNU extensions if available #endif #include <gnuradio/sincos.h> @@ -33,52 +33,41 @@ namespace gr { -#if defined (HAVE_SINCOS) +#if defined(HAVE_SINCOS) - void - sincos(double x, double *sinx, double *cosx) - { - ::sincos(x, sinx, cosx); - } +void sincos(double x, double* sinx, double* cosx) { ::sincos(x, sinx, cosx); } #else - void - sincos(double x, double *sinx, double *cosx) - { +void sincos(double x, double* sinx, double* cosx) +{ *sinx = ::sin(x); *cosx = ::cos(x); - } +} #endif - // ---------------------------------------------------------------- +// ---------------------------------------------------------------- -#if defined (HAVE_SINCOSF) +#if defined(HAVE_SINCOSF) - void - sincosf(float x, float *sinx, float *cosx) - { - ::sincosf(x, sinx, cosx); - } +void sincosf(float x, float* sinx, float* cosx) { ::sincosf(x, sinx, cosx); } -#elif defined (HAVE_SINF) && defined (HAVE_COSF) +#elif defined(HAVE_SINF) && defined(HAVE_COSF) - void - sincosf(float x, float *sinx, float *cosx) - { +void sincosf(float x, float* sinx, float* cosx) +{ *sinx = ::sinf(x); *cosx = ::cosf(x); - } +} #else - void - sincosf(float x, float *sinx, float *cosx) - { +void sincosf(float x, float* sinx, float* cosx) +{ *sinx = ::sin(x); *cosx = ::cos(x); - } +} #endif diff --git a/gnuradio-runtime/lib/math/sine_table.h b/gnuradio-runtime/lib/math/sine_table.h index 69834943bc..cf6732d78a 100644 --- a/gnuradio-runtime/lib/math/sine_table.h +++ b/gnuradio-runtime/lib/math/sine_table.h @@ -1,1025 +1,1025 @@ - // max_error = 2.353084136763606e-06 - { 2.925817799165007e-09, 7.219194364267018e-09 }, - { 2.925707643778599e-09, 2.526699001579799e-07 }, - { 2.925487337153070e-09, 1.191140162167675e-06 }, - { 2.925156887582842e-09, 3.284585035595589e-06 }, - { 2.924716307509151e-09, 6.994872605695784e-06 }, - { 2.924165613519592e-09, 1.278374920658798e-05 }, - { 2.923504826347475e-09, 2.111280464718590e-05 }, - { 2.922733970871080e-09, 3.244343744537165e-05 }, - { 2.921853076112655e-09, 4.723682007436170e-05 }, - { 2.920862175237416e-09, 6.595386421935634e-05 }, - { 2.919761305552202e-09, 8.905518605213658e-05 }, - { 2.918550508504146e-09, 1.170010715193098e-04 }, - { 2.917229829679050e-09, 1.502514416517192e-04 }, - { 2.915799318799769e-09, 1.892658178912071e-04 }, - { 2.914259029724184e-09, 2.345032874456615e-04 }, - { 2.912609020443340e-09, 2.864224686607020e-04 }, - { 2.910849353079123e-09, 3.454814764261432e-04 }, - { 2.908980093882049e-09, 4.121378876027343e-04 }, - { 2.907001313228646e-09, 4.868487064877691e-04 }, - { 2.904913085618902e-09, 5.700703303049837e-04 }, - { 2.902715489673383e-09, 6.622585147355725e-04 }, - { 2.900408608130373e-09, 7.638683394782519e-04 }, - { 2.897992527842612e-09, 8.753541738578119e-04 }, - { 2.895467339774186e-09, 9.971696424604937e-04 }, - { 2.892833138996999e-09, 1.129767590823255e-03 }, - { 2.890090024687216e-09, 1.273600051161478e-03 }, - { 2.887238100121550e-09, 1.429118208142094e-03 }, - { 2.884277472673313e-09, 1.596772364709564e-03 }, - { 2.881208253808507e-09, 1.777011907950626e-03 }, - { 2.878030559081432e-09, 1.970285275029487e-03 }, - { 2.874744508130554e-09, 2.177039919152579e-03 }, - { 2.871350224673798e-09, 2.397722275614272e-03 }, - { 2.867847836504030e-09, 2.632777727878843e-03 }, - { 2.864237475484149e-09, 2.882650573737405e-03 }, - { 2.860519277542297e-09, 3.147783991507308e-03 }, - { 2.856693382666432e-09, 3.428620006328931e-03 }, - { 2.852759934899389e-09, 3.725599456482154e-03 }, - { 2.848719082333207e-09, 4.039161959812243e-03 }, - { 2.844570977103752e-09, 4.369745880190706e-03 }, - { 2.840315775384800e-09, 4.717788294077374e-03 }, - { 2.835953637382310e-09, 5.083724957128360e-03 }, - { 2.831484727328322e-09, 5.467990270896617e-03 }, - { 2.826909213474759e-09, 5.871017249604038e-03 }, - { 2.822227268087134e-09, 6.293237486988512e-03 }, - { 2.817439067438018e-09, 6.735081123237729e-03 }, - { 2.812544791800534e-09, 7.196976811989608e-03 }, - { 2.807544625441273e-09, 7.679351687456759e-03 }, - { 2.802438756613836e-09, 8.182631331563162e-03 }, - { 2.797227377551135e-09, 8.707239741274575e-03 }, - { 2.791910684458716e-09, 9.253599295902304e-03 }, - { 2.786488877507140e-09, 9.822130724578715e-03 }, - { 2.780962160824228e-09, 1.041325307382490e-02 }, - { 2.775330742487884e-09, 1.102738367513773e-02 }, - { 2.769594834517682e-09, 1.166493811278924e-02 }, - { 2.763754652867477e-09, 1.232633019159818e-02 }, - { 2.757810417416620e-09, 1.301197190494069e-02 }, - { 2.751762351962413e-09, 1.372227340270610e-02 }, - { 2.745610684210923e-09, 1.445764295952962e-02 }, - { 2.739355645769094e-09, 1.521848694296229e-02 }, - { 2.732997472135539e-09, 1.600520978188769e-02 }, - { 2.726536402691907e-09, 1.681821393496225e-02 }, - { 2.719972680693777e-09, 1.765789985920713e-02 }, - { 2.713306553261610e-09, 1.852466597868779e-02 }, - { 2.706538271371373e-09, 1.941890865333146e-02 }, - { 2.699668089844909e-09, 2.034102214787814e-02 }, - { 2.692696267340880e-09, 2.129139860085272e-02 }, - { 2.685623066344263e-09, 2.227042799383416e-02 }, - { 2.678448753157212e-09, 2.327849812064098e-02 }, - { 2.671173597888530e-09, 2.431599455681316e-02 }, - { 2.663797874443630e-09, 2.538330062913108e-02 }, - { 2.656321860514457e-09, 2.648079738524795e-02 }, - { 2.648745837568575e-09, 2.760886356354952e-02 }, - { 2.641070090839117e-09, 2.876787556300114e-02 }, - { 2.633294909313421e-09, 2.995820741329835e-02 }, - { 2.625420585722845e-09, 3.118023074495535e-02 }, - { 2.617447416531143e-09, 3.243431475972608e-02 }, - { 2.609375701923643e-09, 3.372082620101990e-02 }, - { 2.601205745795833e-09, 3.504012932452527e-02 }, - { 2.592937855741933e-09, 3.639258586895711e-02 }, - { 2.584572343043400e-09, 3.777855502693250e-02 }, - { 2.576109522656942e-09, 3.919839341605197e-02 }, - { 2.567549713203028e-09, 4.065245505002102e-02 }, - { 2.558893236953688e-09, 4.214109131001403e-02 }, - { 2.550140419820252e-09, 4.366465091617666e-02 }, - { 2.541291591341445e-09, 4.522347989919473e-02 }, - { 2.532347084670572e-09, 4.681792157215026e-02 }, - { 2.523307236563343e-09, 4.844831650239501e-02 }, - { 2.514172387364900e-09, 5.011500248369893e-02 }, - { 2.504942880997064e-09, 5.181831450849345e-02 }, - { 2.495619064945627e-09, 5.355858474024022e-02 }, - { 2.486201290246928e-09, 5.533614248606705e-02 }, - { 2.476689911475047e-09, 5.715131416942842e-02 }, - { 2.467085286727668e-09, 5.900442330315692e-02 }, - { 2.457387777613798e-09, 6.089579046229943e-02 }, - { 2.447597749239101e-09, 6.282573325755320e-02 }, - { 2.437715570192557e-09, 6.479456630859221e-02 }, - { 2.427741612532542e-09, 6.680260121764925e-02 }, - { 2.417676251773166e-09, 6.885014654319160e-02 }, - { 2.407519866869294e-09, 7.093750777401114e-02 }, - { 2.397272840203310e-09, 7.306498730310884e-02 }, - { 2.386935557569868e-09, 7.523288440214027e-02 }, - { 2.376508408161815e-09, 7.744149519577415e-02 }, - { 2.365991784555363e-09, 7.969111263635709e-02 }, - { 2.355386082695641e-09, 8.198202647865405e-02 }, - { 2.344691701881232e-09, 8.431452325495814e-02 }, - { 2.333909044749407e-09, 8.668888625021409e-02 }, - { 2.323038517261246e-09, 8.910539547731611e-02 }, - { 2.312080528685971e-09, 9.156432765274414e-02 }, - { 2.301035491585642e-09, 9.406595617227698e-02 }, - { 2.289903821799651e-09, 9.661055108691619e-02 }, - { 2.278685938428940e-09, 9.919837907903295e-02 }, - { 2.267382263820762e-09, 1.018297034385580e-01 }, - { 2.255993223551837e-09, 1.045047840397028e-01 }, - { 2.244519246413220e-09, 1.072238773174577e-01 }, - { 2.232960764393620e-09, 1.099872362446146e-01 }, - { 2.221318212663309e-09, 1.127951103088245e-01 }, - { 2.209592029557811e-09, 1.156477454898748e-01 }, - { 2.197782656561395e-09, 1.185453842371912e-01 }, - { 2.185890538290176e-09, 1.214882654476019e-01 }, - { 2.173916122475606e-09, 1.244766244431883e-01 }, - { 2.161859859947797e-09, 1.275106929493488e-01 }, - { 2.149722204618256e-09, 1.305906990731841e-01 }, - { 2.137503613462743e-09, 1.337168672820376e-01 }, - { 2.125204546504321e-09, 1.368894183821595e-01 }, - { 2.112825466795944e-09, 1.401085694976751e-01 }, - { 2.100366840402933e-09, 1.433745340497602e-01 }, - { 2.087829136385612e-09, 1.466875217359607e-01 }, - { 2.075212826781308e-09, 1.500477385098620e-01 }, - { 2.062518386587093e-09, 1.534553865607503e-01 }, - { 2.049746293741359e-09, 1.569106642937665e-01 }, - { 2.036897029106193e-09, 1.604137663100403e-01 }, - { 2.023971076449323e-09, 1.639648833871233e-01 }, - { 2.010968922425217e-09, 1.675642024598467e-01 }, - { 1.997891056557933e-09, 1.712119066008896e-01 }, - { 1.984737971221581e-09, 1.749081750021970e-01 }, - { 1.971510161622434e-09, 1.786531829561379e-01 }, - { 1.958208125780130e-09, 1.824471018371070e-01 }, - { 1.944832364508511e-09, 1.862900990834311e-01 }, - { 1.931383381397782e-09, 1.901823381790926e-01 }, - { 1.917861682794392e-09, 1.941239786363039e-01 }, - { 1.904267777782611e-09, 1.981151759777950e-01 }, - { 1.890602178165317e-09, 2.021560817195309e-01 }, - { 1.876865398444616e-09, 2.062468433536743e-01 }, - { 1.863057955802572e-09, 2.103876043317229e-01 }, - { 1.849180370081465e-09, 2.145785040479915e-01 }, - { 1.835233163764673e-09, 2.188196778231083e-01 }, - { 1.821216861956509e-09, 2.231112568880342e-01 }, - { 1.807131992362945e-09, 2.274533683680190e-01 }, - { 1.792979085271234e-09, 2.318461352671018e-01 }, - { 1.778758673530482e-09, 2.362896764525300e-01 }, - { 1.764471292530943e-09, 2.407841066397789e-01 }, - { 1.750117480184598e-09, 2.453295363773890e-01 }, - { 1.735697776904342e-09, 2.499260720324433e-01 }, - { 1.721212725583874e-09, 2.545738157760434e-01 }, - { 1.706662871577097e-09, 2.592728655691494e-01 }, - { 1.692048762677849e-09, 2.640233151485341e-01 }, - { 1.677370949099090e-09, 2.688252540131204e-01 }, - { 1.662629983452104e-09, 2.736787674105404e-01 }, - { 1.647826420726167e-09, 2.785839363237506e-01 }, - { 1.632960818266680e-09, 2.835408374583758e-01 }, - { 1.618033735755429e-09, 2.885495432295704e-01 }, - { 1.603045735188609e-09, 2.936101217498361e-01 }, - { 1.587997380855918e-09, 2.987226368167127e-01 }, - { 1.572889239319430e-09, 3.038871479007593e-01 }, - { 1.557721879392051e-09, 3.091037101339017e-01 }, - { 1.542495872116447e-09, 3.143723742978435e-01 }, - { 1.527211790743024e-09, 3.196931868130269e-01 }, - { 1.511870210708909e-09, 3.250661897274744e-01 }, - { 1.496471709615926e-09, 3.304914207062036e-01 }, - { 1.481016867208896e-09, 3.359689130207621e-01 }, - { 1.465506265353924e-09, 3.414986955389885e-01 }, - { 1.449940488016384e-09, 3.470807927151147e-01 }, - { 1.434320121238994e-09, 3.527152245800635e-01 }, - { 1.418645753119802e-09, 3.584020067320109e-01 }, - { 1.402917973789838e-09, 3.641411503272979e-01 }, - { 1.387137375391042e-09, 3.699326620714776e-01 }, - { 1.371304552054134e-09, 3.757765442106153e-01 }, - { 1.355420099875958e-09, 3.816727945230153e-01 }, - { 1.339484616897137e-09, 3.876214063110671e-01 }, - { 1.323498703079580e-09, 3.936223683933865e-01 }, - { 1.307462960283922e-09, 3.996756650972121e-01 }, - { 1.291377992246768e-09, 4.057812762511174e-01 }, - { 1.275244404558188e-09, 4.119391771778626e-01 }, - { 1.259062804638585e-09, 4.181493386877248e-01 }, - { 1.242833801715929e-09, 4.244117270719281e-01 }, - { 1.226558006803155e-09, 4.307263040962509e-01 }, - { 1.210236032674760e-09, 4.370930269951803e-01 }, - { 1.193868493843725e-09, 4.435118484661861e-01 }, - { 1.177456006538695e-09, 4.499827166641340e-01 }, - { 1.160999188680582e-09, 4.565055751961679e-01 }, - { 1.144498659859216e-09, 4.630803631168164e-01 }, - { 1.127955041310214e-09, 4.697070149232604e-01 }, - { 1.111368955891417e-09, 4.763854605510119e-01 }, - { 1.094741028059551e-09, 4.831156253697562e-01 }, - { 1.078071883846871e-09, 4.898974301794375e-01 }, - { 1.061362150836978e-09, 4.967307912069362e-01 }, - { 1.044612458142151e-09, 5.036156201023686e-01 }, - { 1.027823436378632e-09, 5.105518239364775e-01 }, - { 1.010995717643647e-09, 5.175393051975563e-01 }, - { 9.941299354913699e-10, 5.245779617890562e-01 }, - { 9.772267249089968e-10, 5.316676870274011e-01 }, - { 9.602867222926046e-10, 5.388083696401416e-01 }, - { 9.433105654240147e-10, 5.459998937639375e-01 }, - { 9.262988934458084e-10, 5.532421389435711e-01 }, - { 9.092523468378193e-10, 5.605349801305876e-01 }, - { 8.921715673928355e-10, 5.678782876825250e-01 }, - { 8.750571981926701e-10, 5.752719273622372e-01 }, - { 8.579098835836508e-10, 5.827157603377209e-01 }, - { 8.407302691522673e-10, 5.902096431821322e-01 }, - { 8.235190017016133e-10, 5.977534278737073e-01 }, - { 8.062767292259225e-10, 6.053469617967722e-01 }, - { 7.890041008871165e-10, 6.129900877421282e-01 }, - { 7.717017669898175e-10, 6.206826439083659e-01 }, - { 7.543703789572603e-10, 6.284244639030392e-01 }, - { 7.370105893063053e-10, 6.362153767444958e-01 }, - { 7.196230516231919e-10, 6.440552068636356e-01 }, - { 7.022084205389746e-10, 6.519437741060674e-01 }, - { 6.847673517046416e-10, 6.598808937346672e-01 }, - { 6.673005017664976e-10, 6.678663764322770e-01 }, - { 6.498085283416530e-10, 6.759000283046127e-01 }, - { 6.322920899929834e-10, 6.839816508836737e-01 }, - { 6.147518462045659e-10, 6.921110411311926e-01 }, - { 5.971884573565851e-10, 7.002879914425926e-01 }, - { 5.796025847007168e-10, 7.085122896509806e-01 }, - { 5.619948903351406e-10, 7.167837190315758e-01 }, - { 5.443660371796048e-10, 7.251020583063744e-01 }, - { 5.267166889504394e-10, 7.334670816491009e-01 }, - { 5.090475101356742e-10, 7.418785586903696e-01 }, - { 4.913591659698399e-10, 7.503362545232619e-01 }, - { 4.736523224091392e-10, 7.588399297089872e-01 }, - { 4.559276461062478e-10, 7.673893402829834e-01 }, - { 4.381858043851147e-10, 7.759842377612828e-01 }, - { 4.204274652161870e-10, 7.846243691469355e-01 }, - { 4.026532971908398e-10, 7.933094769370790e-01 }, - { 3.848639694963359e-10, 8.020392991300200e-01 }, - { 3.670601518910503e-10, 8.108135692324444e-01 }, - { 3.492425146784233e-10, 8.196320162675177e-01 }, - { 3.314117286825031e-10, 8.284943647824689e-01 }, - { 3.135684652223755e-10, 8.374003348569865e-01 }, - { 2.957133960867535e-10, 8.463496421118015e-01 }, - { 2.778471935089361e-10, 8.553419977173513e-01 }, - { 2.599705301412391e-10, 8.643771084029740e-01 }, - { 2.420840790301135e-10, 8.734546764660205e-01 }, - { 2.241885135902046e-10, 8.825743997817682e-01 }, - { 2.062845075795238e-10, 8.917359718130367e-01 }, - { 1.883727350736140e-10, 9.009390816205823e-01 }, - { 1.704538704408269e-10, 9.101834138731877e-01 }, - { 1.525285883160648e-10, 9.194686488588080e-01 }, - { 1.345975635762696e-10, 9.287944624950824e-01 }, - { 1.166614713141648e-10, 9.381605263410157e-01 }, - { 9.872098681369190e-11, 9.475665076080466e-01 }, - { 8.077678552380464e-11, 9.570120691722380e-01 }, - { 6.282954303364090e-11, 9.664968695860140e-01 }, - { 4.487993504668797e-11, 9.760205630906909e-01 }, - { 2.692863735553042e-11, 9.855827996289697e-01 }, - { 8.976325816439114e-12, 9.951832248577780e-01 }, - { -8.976323676304494e-12, 1.004821480161519e+00 }, - { -2.692863521550168e-11, 1.014497202665280e+00 }, - { -4.487993290681805e-11, 1.024210025248670e+00 }, - { -6.282954089398273e-11, 1.033959576559617e+00 }, - { -8.077678338451706e-11, 1.043745481028715e+00 }, - { -9.872098467477489e-11, 1.053567358883467e+00 }, - { -1.166614691757772e-10, 1.063424826163223e+00 }, - { -1.345975614383584e-10, 1.073317494734013e+00 }, - { -1.525285861788948e-10, 1.083244972303963e+00 }, - { -1.704538683042922e-10, 1.093206862438572e+00 }, - { -1.883727329379793e-10, 1.103202764576806e+00 }, - { -2.062845054446831e-10, 1.113232274046796e+00 }, - { -2.241885114563697e-10, 1.123294982082432e+00 }, - { -2.420840768973375e-10, 1.133390475839767e+00 }, - { -2.599705280096278e-10, 1.143518338413855e+00 }, - { -2.778471913784365e-10, 1.153678148855860e+00 }, - { -2.957133939575774e-10, 1.163869482190458e+00 }, - { -3.135684630945758e-10, 1.174091909433296e+00 }, - { -3.314117265561857e-10, 1.184344997608959e+00 }, - { -3.492425125535882e-10, 1.194628309769018e+00 }, - { -3.670601497678034e-10, 1.204941405010466e+00 }, - { -3.848639673748360e-10, 1.215283838494269e+00 }, - { -4.026532950710339e-10, 1.225655161464298e+00 }, - { -4.204274630982869e-10, 1.236054921266445e+00 }, - { -4.381858022691734e-10, 1.246482661367958e+00 }, - { -4.559276439922654e-10, 1.256937921377146e+00 }, - { -4.736523202972214e-10, 1.267420237063216e+00 }, - { -4.913591638600925e-10, 1.277929140376502e+00 }, - { -5.090475080282032e-10, 1.288464159468706e+00 }, - { -5.267166868452449e-10, 1.299024818713528e+00 }, - { -5.443660350768455e-10, 1.309610638727845e+00 }, - { -5.619948882348695e-10, 1.320221136392390e+00 }, - { -5.796025826029868e-10, 1.330855824873457e+00 }, - { -5.971884552615020e-10, 1.341514213644420e+00 }, - { -6.147518441122357e-10, 1.352195808507556e+00 }, - { -6.322920879034590e-10, 1.362900111616144e+00 }, - { -6.498085262549874e-10, 1.373626621496939e+00 }, - { -6.673004996827436e-10, 1.384374833072571e+00 }, - { -6.847673496239581e-10, 1.395144237684605e+00 }, - { -7.022084184613616e-10, 1.405934323116231e+00 }, - { -7.196230495488082e-10, 1.416744573616104e+00 }, - { -7.370105872352039e-10, 1.427574469921397e+00 }, - { -7.543703768894941e-10, 1.438423489281758e+00 }, - { -7.717017649255453e-10, 1.449291105483472e+00 }, - { -7.890040988262324e-10, 1.460176788873383e+00 }, - { -8.062767271686383e-10, 1.471080006383765e+00 }, - { -8.235189996479819e-10, 1.482000221556656e+00 }, - { -8.407302671024475e-10, 1.492936894569018e+00 }, - { -8.579098815375368e-10, 1.503889482257845e+00 }, - { -8.750571961505266e-10, 1.514857438145604e+00 }, - { -8.921715653546624e-10, 1.525840212465756e+00 }, - { -9.092523448036167e-10, 1.536837252188703e+00 }, - { -9.262988914157881e-10, 1.547848001047890e+00 }, - { -9.433105633981766e-10, 1.558871899565883e+00 }, - { -9.602867202711075e-10, 1.569908385081254e+00 }, - { -9.772267228916820e-10, 1.580956891774897e+00 }, - { -9.941299334786078e-10, 1.592016850697478e+00 }, - { -1.010995715635332e-09, 1.603087689796053e+00 }, - { -1.027823434374870e-09, 1.614168833942028e+00 }, - { -1.044612456143047e-09, 1.625259704958335e+00 }, - { -1.061362148842745e-09, 1.636359721647526e+00 }, - { -1.078071881857297e-09, 1.647468299819543e+00 }, - { -1.094741026074900e-09, 1.658584852320419e+00 }, - { -1.111368953911690e-09, 1.669708789060341e+00 }, - { -1.127955039335462e-09, 1.680839517042381e+00 }, - { -1.144498657889600e-09, 1.691976440391624e+00 }, - { -1.160999186716154e-09, 1.703118960383971e+00 }, - { -1.177456004579561e-09, 1.714266475475616e+00 }, - { -1.193868491889832e-09, 1.725418381332405e+00 }, - { -1.210236030726319e-09, 1.736574070859850e+00 }, - { -1.226558004860220e-09, 1.747732934232508e+00 }, - { -1.242833799778447e-09, 1.758894358924547e+00 }, - { -1.259062802706714e-09, 1.770057729740021e+00 }, - { -1.275244402631982e-09, 1.781222428842935e+00 }, - { -1.291377990326492e-09, 1.792387835788660e+00 }, - { -1.307462958369363e-09, 1.803553327553897e+00 }, - { -1.323498701170897e-09, 1.814718278568759e+00 }, - { -1.339484614994490e-09, 1.825882060747428e+00 }, - { -1.355420097979292e-09, 1.837044043519582e+00 }, - { -1.371304550163662e-09, 1.848203593862598e+00 }, - { -1.387137373506711e-09, 1.859360076332671e+00 }, - { -1.402917971911754e-09, 1.870512853097495e+00 }, - { -1.418645751248018e-09, 1.881661283967967e+00 }, - { -1.434320119373722e-09, 1.892804726431080e+00 }, - { -1.449940486157623e-09, 1.903942535681972e+00 }, - { -1.465506263501516e-09, 1.915074064656886e+00 }, - { -1.481016865363264e-09, 1.926198664066737e+00 }, - { -1.496471707776859e-09, 1.937315682428795e+00 }, - { -1.511870208876724e-09, 1.948424466101625e+00 }, - { -1.527211788917509e-09, 1.959524359317042e+00 }, - { -1.542495870297867e-09, 1.970614704215133e+00 }, - { -1.557721877580406e-09, 1.981694840876775e+00 }, - { -1.572889237514880e-09, 1.992764107358707e+00 }, - { -1.587997379058514e-09, 2.003821839726753e+00 }, - { -1.603045733398246e-09, 2.014867372090665e+00 }, - { -1.618033733972424e-09, 2.025900036638798e+00 }, - { -1.632960816490822e-09, 2.036919163671778e+00 }, - { -1.647826418957721e-09, 2.047924081638631e+00 }, - { -1.662629981691070e-09, 2.058914117170269e+00 }, - { -1.677370947345626e-09, 2.069888595116115e+00 }, - { -1.692048760931849e-09, 2.080846838577820e+00 }, - { -1.706662869838827e-09, 2.091788168946183e+00 }, - { -1.721212723853279e-09, 2.102711905935372e+00 }, - { -1.735697775181424e-09, 2.113617367619504e+00 }, - { -1.750117478469621e-09, 2.124503870468520e+00 }, - { -1.764471290823748e-09, 2.135370729383332e+00 }, - { -1.778758671831281e-09, 2.146217257733207e+00 }, - { -1.792979083579974e-09, 2.157042767390815e+00 }, - { -1.807131990679890e-09, 2.167846568770014e+00 }, - { -1.821216860281448e-09, 2.178627970860822e+00 }, - { -1.835233162097977e-09, 2.189386281268046e+00 }, - { -1.849180368423027e-09, 2.200120806246095e+00 }, - { -1.863057954152340e-09, 2.210830850737588e+00 }, - { -1.876865396802907e-09, 2.221515718409926e+00 }, - { -1.890602176531920e-09, 2.232174711691990e+00 }, - { -1.904267776157843e-09, 2.242807131812679e+00 }, - { -1.917861681178094e-09, 2.253412278837029e+00 }, - { -1.931383379790273e-09, 2.263989451705295e+00 }, - { -1.944832362909578e-09, 2.274537948269257e+00 }, - { -1.958208124189984e-09, 2.285057065331676e+00 }, - { -1.971510160041235e-09, 2.295546098682665e+00 }, - { -1.984737969649064e-09, 2.306004343138794e+00 }, - { -1.997891054994522e-09, 2.316431092581699e+00 }, - { -2.010968920870647e-09, 2.326825639994779e+00 }, - { -2.023971074903858e-09, 2.337187277503834e+00 }, - { -2.036897027569834e-09, 2.347515296413520e+00 }, - { -2.049746292214264e-09, 2.357808987247877e+00 }, - { -2.062518385069210e-09, 2.368067639787542e+00 }, - { -2.075212825272584e-09, 2.378290543109652e+00 }, - { -2.087829134886364e-09, 2.388476985626922e+00 }, - { -2.100366838912949e-09, 2.398626255125417e+00 }, - { -2.112825465315542e-09, 2.408737638805759e+00 }, - { -2.125204545033289e-09, 2.418810423320288e+00 }, - { -2.137503612001452e-09, 2.428843894814472e+00 }, - { -2.149722203166389e-09, 2.438837338964302e+00 }, - { -2.161859858505829e-09, 2.448790041018174e+00 }, - { -2.173916121043380e-09, 2.458701285834241e+00 }, - { -2.185890536867478e-09, 2.468570357921585e+00 }, - { -2.197782655148702e-09, 2.478396541480230e+00 }, - { -2.209592028154913e-09, 2.488179120439544e+00 }, - { -2.221318211270522e-09, 2.497917378500214e+00 }, - { -2.232960763010574e-09, 2.507610599172123e+00 }, - { -2.244519245040444e-09, 2.517258065817044e+00 }, - { -2.255993222189014e-09, 2.526859061686102e+00 }, - { -2.267382262468209e-09, 2.536412869962689e+00 }, - { -2.278685937086658e-09, 2.545918773800664e+00 }, - { -2.289903820467374e-09, 2.555376056366064e+00 }, - { -2.301035490263848e-09, 2.564784000877677e+00 }, - { -2.312080527374447e-09, 2.574141890646339e+00 }, - { -2.323038515960257e-09, 2.583449009117307e+00 }, - { -2.333909043458635e-09, 2.592704639909166e+00 }, - { -2.344691700601153e-09, 2.601908066856634e+00 }, - { -2.355386081425938e-09, 2.611058574048749e+00 }, - { -2.365991783296513e-09, 2.620155445872768e+00 }, - { -2.376508406913500e-09, 2.629197967052127e+00 }, - { -2.386935556332088e-09, 2.638185422689490e+00 }, - { -2.397272838976436e-09, 2.647117098307332e+00 }, - { -2.407519865653114e-09, 2.655992279887846e+00 }, - { -2.417676250567891e-09, 2.664810253915885e+00 }, - { -2.427741611338014e-09, 2.673570307418169e+00 }, - { -2.437715569009093e-09, 2.682271728006635e+00 }, - { -2.447597748066437e-09, 2.690913803917100e+00 }, - { -2.457387776452357e-09, 2.699495824053297e+00 }, - { -2.467085285577292e-09, 2.708017078025636e+00 }, - { -2.476689910335470e-09, 2.716476856194105e+00 }, - { -2.486201289118733e-09, 2.724874449709689e+00 }, - { -2.495619063828443e-09, 2.733209150554255e+00 }, - { -2.504942879891263e-09, 2.741480251583985e+00 }, - { -2.514172386270163e-09, 2.749687046568741e+00 }, - { -2.523307235480146e-09, 2.757828830235740e+00 }, - { -2.532347083598520e-09, 2.765904898308531e+00 }, - { -2.541291590280960e-09, 2.773914547551261e+00 }, - { -2.550140418771202e-09, 2.781857075807392e+00 }, - { -2.558893235915887e-09, 2.789731782043156e+00 }, - { -2.567549712176927e-09, 2.797537966388929e+00 }, - { -2.576109521642196e-09, 2.805274930179221e+00 }, - { -2.584572342040407e-09, 2.812941975996573e+00 }, - { -2.592937854750428e-09, 2.820538407710556e+00 }, - { -2.601205744816134e-09, 2.828063530521908e+00 }, - { -2.609375700955458e-09, 2.835516651001539e+00 }, - { -2.617447415574869e-09, 2.842897077134583e+00 }, - { -2.625420584778350e-09, 2.850204118359573e+00 }, - { -2.633294908380520e-09, 2.857437085611509e+00 }, - { -2.641070089918234e-09, 2.864595291363663e+00 }, - { -2.648745836659391e-09, 2.871678049666939e+00 }, - { -2.656321859617343e-09, 2.878684676194483e+00 }, - { -2.663797873558322e-09, 2.885614488280000e+00 }, - { -2.671173597015318e-09, 2.892466804962122e+00 }, - { -2.678448752295859e-09, 2.899240947023252e+00 }, - { -2.685623065495139e-09, 2.905936237033475e+00 }, - { -2.692696266503800e-09, 2.912551999389617e+00 }, - { -2.699668089019767e-09, 2.919087560358171e+00 }, - { -2.706538270558513e-09, 2.925542248116882e+00 }, - { -2.713306552460767e-09, 2.931915392794031e+00 }, - { -2.719972679905295e-09, 2.938206326512581e+00 }, - { -2.726536401915442e-09, 2.944414383428562e+00 }, - { -2.732997471371516e-09, 2.950538899775061e+00 }, - { -2.739355645017194e-09, 2.956579213900666e+00 }, - { -2.745610683471516e-09, 2.962534666313284e+00 }, - { -2.751762351235315e-09, 2.968404599718795e+00 }, - { -2.757810416701751e-09, 2.974188359063684e+00 }, - { -2.763754652165128e-09, 2.979885291576143e+00 }, - { -2.769594833827588e-09, 2.985494746805227e+00 }, - { -2.775330741810390e-09, 2.991016076664491e+00 }, - { -2.780962160159068e-09, 2.996448635469842e+00 }, - { -2.786488876854607e-09, 3.001791779983262e+00 }, - { -2.791910683818570e-09, 3.007044869450794e+00 }, - { -2.797227376923695e-09, 3.012207265645876e+00 }, - { -2.802438755998943e-09, 3.017278332907412e+00 }, - { -2.807544624838820e-09, 3.022257438182037e+00 }, - { -2.812544791210840e-09, 3.027143951064684e+00 }, - { -2.817439066860792e-09, 3.031937243837070e+00 }, - { -2.822227267522746e-09, 3.036636691510884e+00 }, - { -2.826909212922864e-09, 3.041241671864994e+00 }, - { -2.831484726789317e-09, 3.045751565488710e+00 }, - { -2.835953636855826e-09, 3.050165755818853e+00 }, - { -2.840315774871260e-09, 3.054483629182857e+00 }, - { -2.844570976602957e-09, 3.058704574835744e+00 }, - { -2.848719081844986e-09, 3.062827985002047e+00 }, - { -2.852759934424164e-09, 3.066853254915581e+00 }, - { -2.856693382203833e-09, 3.070779782857041e+00 }, - { -2.860519277092708e-09, 3.074606970196721e+00 }, - { -2.864237475047239e-09, 3.078334221430809e+00 }, - { -2.867847836080156e-09, 3.081960944223928e+00 }, - { -2.871350224262603e-09, 3.085486549445314e+00 }, - { -2.874744507732462e-09, 3.088910451211251e+00 }, - { -2.878030558696270e-09, 3.092232066921130e+00 }, - { -2.881208253436038e-09, 3.095450817298478e+00 }, - { -2.884277472313999e-09, 3.098566126429974e+00 }, - { -2.887238099774968e-09, 3.101577421802070e+00 }, - { -2.890090024353816e-09, 3.104484134342861e+00 }, - { -2.892833138676371e-09, 3.107285698457308e+00 }, - { -2.895467339466766e-09, 3.109981552069083e+00 }, - { -2.897992527547963e-09, 3.112571136655481e+00 }, - { -2.900408607848946e-09, 3.115053897289195e+00 }, - { -2.902715489404992e-09, 3.117429282673042e+00 }, - { -2.904913085363323e-09, 3.119696745180238e+00 }, - { -2.907001312986328e-09, 3.121855740892224e+00 }, - { -2.908980093652563e-09, 3.123905729634218e+00 }, - { -2.910849352862924e-09, 3.125846175016163e+00 }, - { -2.912609020239985e-09, 3.127676544466606e+00 }, - { -2.914259029534118e-09, 3.129396309273659e+00 }, - { -2.915799318622574e-09, 3.131004944618667e+00 }, - { -2.917229829515169e-09, 3.132501929616775e+00 }, - { -2.918550508353347e-09, 3.133886747350606e+00 }, - { -2.919761305414294e-09, 3.135158884909254e+00 }, - { -2.920862175112829e-09, 3.136317833424958e+00 }, - { -2.921853076000972e-09, 3.137363088107359e+00 }, - { -2.922733970772719e-09, 3.138294148283254e+00 }, - { -2.923504826262027e-09, 3.139110517429204e+00 }, - { -2.924165613447473e-09, 3.139811703211207e+00 }, - { -2.924716307449950e-09, 3.140397217517018e+00 }, - { -2.925156887536978e-09, 3.140866576495489e+00 }, - { -2.925487337120335e-09, 3.141219300588825e+00 }, - { -2.925707643758784e-09, 3.141454914570261e+00 }, - { -2.925817799158535e-09, 3.141572947579352e+00 }, - { -2.925817799171455e-09, 3.141572933154836e+00 }, - { -2.925707643798390e-09, 3.141454409272987e+00 }, - { -2.925487337185779e-09, 3.141216918378770e+00 }, - { -2.925156887628892e-09, 3.140860007424112e+00 }, - { -2.924716307568119e-09, 3.140383227898687e+00 }, - { -2.924165613591896e-09, 3.139786135867868e+00 }, - { -2.923504826432903e-09, 3.139068292003385e+00 }, - { -2.922733970969412e-09, 3.138229261619561e+00 }, - { -2.921853076224321e-09, 3.137268614707029e+00 }, - { -2.920862175361976e-09, 3.136185925964038e+00 }, - { -2.919761305690083e-09, 3.134980774833275e+00 }, - { -2.918550508654911e-09, 3.133652745531368e+00 }, - { -2.917229829843137e-09, 3.132201427085629e+00 }, - { -2.915799318976726e-09, 3.130626413363146e+00 }, - { -2.914259029914435e-09, 3.128927303107136e+00 }, - { -2.912609020646661e-09, 3.127103699965947e+00 }, - { -2.910849353295315e-09, 3.125155212527586e+00 }, - { -2.908980094111509e-09, 3.123081454351802e+00 }, - { -2.907001313470937e-09, 3.120882043999591e+00 }, - { -2.904913085874448e-09, 3.118556605068443e+00 }, - { -2.902715489941767e-09, 3.116104766219928e+00 }, - { -2.900408608411958e-09, 3.113526161214776e+00 }, - { -2.897992528137022e-09, 3.110820428940251e+00 }, - { -2.895467340081818e-09, 3.107987213444579e+00 }, - { -2.892833139317615e-09, 3.105026163964191e+00 }, - { -2.890090025020589e-09, 3.101936934956479e+00 }, - { -2.887238100468092e-09, 3.098719186130021e+00 }, - { -2.884277473032614e-09, 3.095372582472161e+00 }, - { -2.881208254180937e-09, 3.091896794282404e+00 }, - { -2.878030559466594e-09, 3.088291497198199e+00 }, - { -2.874744508528832e-09, 3.084556372228054e+00 }, - { -2.871350225084755e-09, 3.080691105776848e+00 }, - { -2.867847836928063e-09, 3.076695389678615e+00 }, - { -2.864237475921086e-09, 3.072568921221621e+00 }, - { -2.860519277991847e-09, 3.068311403179147e+00 }, - { -2.856693383129018e-09, 3.063922543837792e+00 }, - { -2.852759935374575e-09, 3.059402057023109e+00 }, - { -2.848719082821403e-09, 3.054749662130841e+00 }, - { -2.844570977604520e-09, 3.049965084150782e+00 }, - { -2.840315775898525e-09, 3.045048053697736e+00 }, - { -2.835953637908582e-09, 3.039998307034967e+00 }, - { -2.831484727867511e-09, 3.034815586104635e+00 }, - { -2.826909214026628e-09, 3.029499638550941e+00 }, - { -2.822227268651470e-09, 3.024050217748861e+00 }, - { -2.817439068015245e-09, 3.018467082830179e+00 }, - { -2.812544792390175e-09, 3.012749998707001e+00 }, - { -2.807544626043751e-09, 3.006898736100911e+00 }, - { -2.802438757228650e-09, 3.000913071564665e+00 }, - { -2.797227378178760e-09, 2.994792787510961e+00 }, - { -2.791910685098702e-09, 2.988537672233504e+00 }, - { -2.786488878159805e-09, 2.982147519935565e+00 }, - { -2.780962161489413e-09, 2.975622130750641e+00 }, - { -2.775330743165298e-09, 2.968961310769028e+00 }, - { -2.769594835207775e-09, 2.962164872061613e+00 }, - { -2.763754653569747e-09, 2.955232632701135e+00 }, - { -2.757810418131543e-09, 2.948164416789036e+00 }, - { -2.751762352689432e-09, 2.940960054474719e+00 }, - { -2.745610684950541e-09, 2.933619381982341e+00 }, - { -2.739355646520809e-09, 2.926142241629213e+00 }, - { -2.732997472899722e-09, 2.918528481852205e+00 }, - { -2.726536403468318e-09, 2.910777957226018e+00 }, - { -2.719972681482232e-09, 2.902890528487386e+00 }, - { -2.713306554062453e-09, 2.894866062556452e+00 }, - { -2.706538272184154e-09, 2.886704432555728e+00 }, - { -2.699668090670078e-09, 2.878405517834426e+00 }, - { -2.692696268177908e-09, 2.869969203985464e+00 }, - { -2.685623067193599e-09, 2.861395382869544e+00 }, - { -2.678448754018380e-09, 2.852683952631486e+00 }, - { -2.671173598761847e-09, 2.843834817723832e+00 }, - { -2.663797875328991e-09, 2.834847888922988e+00 }, - { -2.656321861411517e-09, 2.825723083350459e+00 }, - { -2.648745838477759e-09, 2.816460324492298e+00 }, - { -2.641070091759922e-09, 2.807059542215146e+00 }, - { -2.633294910246296e-09, 2.797520672788269e+00 }, - { -2.625420586667340e-09, 2.787843658897949e+00 }, - { -2.617447417487602e-09, 2.778028449668942e+00 }, - { -2.609375702891616e-09, 2.768075000678399e+00 }, - { -2.601205746775692e-09, 2.757983273976943e+00 }, - { -2.592937856733464e-09, 2.747753238101915e+00 }, - { -2.584572344046340e-09, 2.737384868096553e+00 }, - { -2.576109523671634e-09, 2.726878145526201e+00 }, - { -2.567549714229129e-09, 2.716233058492422e+00 }, - { -2.558893237991435e-09, 2.705449601651722e+00 }, - { -2.550140420869302e-09, 2.694527776227857e+00 }, - { -2.541291592402089e-09, 2.683467590030445e+00 }, - { -2.532347085742440e-09, 2.672269057466213e+00 }, - { -2.523307237646751e-09, 2.660932199557362e+00 }, - { -2.514172388459584e-09, 2.649457043952206e+00 }, - { -2.504942882102813e-09, 2.637843624941622e+00 }, - { -2.495619066062810e-09, 2.626091983472908e+00 }, - { -2.486201291375123e-09, 2.614202167160335e+00 }, - { -2.476689912614465e-09, 2.602174230302269e+00 }, - { -2.467085287878098e-09, 2.590008233889805e+00 }, - { -2.457387778775451e-09, 2.577704245623143e+00 }, - { -2.447597750411553e-09, 2.565262339920002e+00 }, - { -2.437715571376127e-09, 2.552682597931055e+00 }, - { -2.427741613727123e-09, 2.539965107548168e+00 }, - { -2.417676252978335e-09, 2.527109963417675e+00 }, - { -2.407519868085581e-09, 2.514117266951687e+00 }, - { -2.397272841430131e-09, 2.500987126335739e+00 }, - { -2.386935558807595e-09, 2.487719656543254e+00 }, - { -2.376508409410024e-09, 2.474314979341178e+00 }, - { -2.365991785814531e-09, 2.460773223303822e+00 }, - { -2.355386083965131e-09, 2.447094523817833e+00 }, - { -2.344691703161363e-09, 2.433279023095734e+00 }, - { -2.333909046040126e-09, 2.419326870180582e+00 }, - { -2.323038518562289e-09, 2.405238220956597e+00 }, - { -2.312080529997549e-09, 2.391013238157397e+00 }, - { -2.301035492907384e-09, 2.376652091371587e+00 }, - { -2.289903823131822e-09, 2.362154957053137e+00 }, - { -2.278685939771276e-09, 2.347522018525197e+00 }, - { -2.267382265173420e-09, 2.332753465990296e+00 }, - { -2.255993224914501e-09, 2.317849496533128e+00 }, - { -2.244519247786155e-09, 2.302810314130351e+00 }, - { -2.232960765776561e-09, 2.287636129652823e+00 }, - { -2.221318214056095e-09, 2.272327160873552e+00 }, - { -2.209592030960763e-09, 2.256883632472565e+00 }, - { -2.197782657974034e-09, 2.241305776039511e+00 }, - { -2.185890539712767e-09, 2.225593830081461e+00 }, - { -2.173916123907886e-09, 2.209748040023618e+00 }, - { -2.161859861389976e-09, 2.193768658216360e+00 }, - { -2.149722206070124e-09, 2.177655943935795e+00 }, - { -2.137503614923981e-09, 2.161410163388424e+00 }, - { -2.125204547975352e-09, 2.145031589714984e+00 }, - { -2.112825468276292e-09, 2.128520502989477e+00 }, - { -2.100366841892917e-09, 2.111877190225612e+00 }, - { -2.087829137884807e-09, 2.095101945374541e+00 }, - { -2.075212828290086e-09, 2.078195069329960e+00 }, - { -2.062518388104923e-09, 2.061156869925600e+00 }, - { -2.049746295268559e-09, 2.043987661939897e+00 }, - { -2.036897030642658e-09, 2.026687767092888e+00 }, - { -2.023971077994576e-09, 2.009257514048162e+00 }, - { -2.010968923979840e-09, 1.991697238413571e+00 }, - { -1.997891058121344e-09, 1.974007282737320e+00 }, - { -1.984737972794098e-09, 1.956187996511354e+00 }, - { -1.971510163203686e-09, 1.938239736166060e+00 }, - { -1.958208127370276e-09, 1.920162865072273e+00 }, - { -1.944832366107339e-09, 1.901957753535934e+00 }, - { -1.931383383005451e-09, 1.883624778799427e+00 }, - { -1.917861684410531e-09, 1.865164325035177e+00 }, - { -1.904267779407432e-09, 1.846576783346324e+00 }, - { -1.890602179798714e-09, 1.827862551760622e+00 }, - { -1.876865400086483e-09, 1.809022035228338e+00 }, - { -1.863057957452539e-09, 1.790055645617624e+00 }, - { -1.849180371740008e-09, 1.770963801711725e+00 }, - { -1.835233165431475e-09, 1.751746929201178e+00 }, - { -1.821216863631569e-09, 1.732405460681919e+00 }, - { -1.807131994045840e-09, 1.712939835648088e+00 }, - { -1.792979086962494e-09, 1.693350500488565e+00 }, - { -1.778758675229683e-09, 1.673637908477153e+00 }, - { -1.764471294238191e-09, 1.653802519770021e+00 }, - { -1.750117481899733e-09, 1.633844801396848e+00 }, - { -1.735697778626995e-09, 1.613765227254186e+00 }, - { -1.721212727314574e-09, 1.593564278099856e+00 }, - { -1.706662873315474e-09, 1.573242441540939e+00 }, - { -1.692048764423848e-09, 1.552800212030258e+00 }, - { -1.677370950852395e-09, 1.532238090855187e+00 }, - { -1.662629985213192e-09, 1.511556586131055e+00 }, - { -1.647826422494560e-09, 1.490756212788764e+00 }, - { -1.632960820042537e-09, 1.469837492568651e+00 }, - { -1.618033737538645e-09, 1.448800954008929e+00 }, - { -1.603045736978760e-09, 1.427647132435469e+00 }, - { -1.587997382653428e-09, 1.406376569953373e+00 }, - { -1.572889241124034e-09, 1.384989815432507e+00 }, - { -1.557721881203696e-09, 1.363487424499449e+00 }, - { -1.542495873934815e-09, 1.341869959524515e+00 }, - { -1.527211792568486e-09, 1.320137989611176e+00 }, - { -1.511870212541253e-09, 1.298292090581491e+00 }, - { -1.496471711454994e-09, 1.276332844965754e+00 }, - { -1.481016869054634e-09, 1.254260841988828e+00 }, - { -1.465506267206068e-09, 1.232076677556547e+00 }, - { -1.449940489875303e-09, 1.209780954243628e+00 }, - { -1.434320123104372e-09, 1.187374281276747e+00 }, - { -1.418645754991533e-09, 1.164857274523495e+00 }, - { -1.402917975667710e-09, 1.142230556475749e+00 }, - { -1.387137377275425e-09, 1.119494756236361e+00 }, - { -1.371304553944712e-09, 1.096650509501278e+00 }, - { -1.355420101772623e-09, 1.073698458546610e+00 }, - { -1.339484618799891e-09, 1.050639252211352e+00 }, - { -1.323498704988051e-09, 1.027473545880543e+00 }, - { -1.307462962198534e-09, 1.004202001471034e+00 }, - { -1.291377994167204e-09, 9.808252874104182e-01 }, - { -1.275244406484394e-09, 9.573440786237052e-01 }, - { -1.259062806570190e-09, 9.337590565128454e-01 }, - { -1.242833803653464e-09, 9.100709089414796e-01 }, - { -1.226558008746195e-09, 8.862803302125812e-01 }, - { -1.210236034623253e-09, 8.623880210538113e-01 }, - { -1.193868495797618e-09, 8.383946885959868e-01 }, - { -1.177456008497777e-09, 8.143010463544786e-01 }, - { -1.160999190645010e-09, 7.901078142102129e-01 }, - { -1.144498661828833e-09, 7.658157183877095e-01 }, - { -1.127955043284965e-09, 7.414254914366063e-01 }, - { -1.111368957870986e-09, 7.169378722095157e-01 }, - { -1.094741030044308e-09, 6.923536058430697e-01 }, - { -1.078071885836393e-09, 6.676734437331688e-01 }, - { -1.061362152831423e-09, 6.428981435165511e-01 }, - { -1.044612460141255e-09, 6.180284690466404e-01 }, - { -1.027823438382183e-09, 5.930651903718045e-01 }, - { -1.010995719652015e-09, 5.680090837138436e-01 }, - { -9.941299375042378e-10, 5.428609314418970e-01 }, - { -9.772267269262058e-10, 5.176215220520872e-01 }, - { -9.602867243141016e-10, 4.922916501421032e-01 }, - { -9.433105674499058e-10, 4.668721163885412e-01 }, - { -9.262988954758817e-10, 4.413637275202624e-01 }, - { -9.092523488719689e-10, 4.157672962958654e-01 }, - { -8.921715694311144e-10, 3.900836414778084e-01 }, - { -8.750572002347607e-10, 3.643135878065193e-01 }, - { -8.579098856296589e-10, 3.384579659762392e-01 }, - { -8.407302712022458e-10, 3.125176126069478e-01 }, - { -8.235190037551917e-10, 2.864933702193017e-01 }, - { -8.062767312831008e-10, 2.603860872080448e-01 }, - { -7.890041029479477e-10, 2.341966178147619e-01 }, - { -7.717017690542486e-10, 2.079258220999725e-01 }, - { -7.543703810250266e-10, 1.815745659161734e-01 }, - { -7.370105913774597e-10, 1.551437208801425e-01 }, - { -7.196230536974697e-10, 1.286341643433767e-01 }, - { -7.022084226165876e-10, 1.020467793657360e-01 }, - { -6.847673537853251e-10, 7.538245468350446e-02 }, - { -6.673005038502516e-10, 4.864208468284503e-02 }, - { -6.498085304282128e-10, 2.182656936863137e-02 }, - { -6.322920920826137e-10, -5.063185663820913e-03 }, - { -6.147518482969490e-10, -3.202626926150343e-02 }, - { -5.971884594516681e-10, -5.906176474160862e-02 }, - { -5.796025867984469e-10, -8.616874992366363e-02 }, - { -5.619948924353588e-10, -1.133462971605448e-01 }, - { -5.443660392823640e-10, -1.405934733692621e-01 }, - { -5.267166910556339e-10, -1.679093400638023e-01 }, - { -5.090475122431451e-10, -1.952929533862739e-01 }, - { -4.913591680795342e-10, -2.227433641394564e-01 }, - { -4.736523245210571e-10, -2.502596178194491e-01 }, - { -4.559276482202303e-10, -2.778407546490776e-01 }, - { -4.381858065011618e-10, -3.054858096104932e-01 }, - { -4.204274673340870e-10, -3.331938124792702e-01 }, - { -4.026532993105397e-10, -3.609637878577768e-01 }, - { -3.848639716178888e-10, -3.887947552098022e-01 }, - { -3.670601540142443e-10, -4.166857288948674e-01 }, - { -3.492425168032583e-10, -4.446357182029681e-01 }, - { -3.314117308088734e-10, -4.726437273896633e-01 }, - { -3.135684673501752e-10, -5.007087557112619e-01 }, - { -2.957133982159296e-10, -5.288297974607742e-01 }, - { -2.778471956393828e-10, -5.570058420037128e-01 }, - { -2.599705322729564e-10, -5.852358738143247e-01 }, - { -2.420840811628366e-10, -6.135188725122560e-01 }, - { -2.241885157240923e-10, -6.418538128986450e-01 }, - { -2.062845097142585e-10, -6.702396649949099e-01 }, - { -1.883727372093546e-10, -6.986753940779493e-01 }, - { -1.704538725773087e-10, -7.271599607197149e-01 }, - { -1.525285904532877e-10, -7.556923208240308e-01 }, - { -1.345975657140748e-10, -7.842714256651911e-01 }, - { -1.166614734526054e-10, -8.128962219265712e-01 }, - { -9.872098895260891e-11, -8.415656517393372e-01 }, - { -8.077678766314517e-11, -8.702786527215916e-01 }, - { -6.282954517324612e-11, -8.990341580176152e-01 }, - { -4.487993718655790e-11, -9.278310963373758e-01 }, - { -2.692863949561210e-11, -9.566683919968972e-01 }, - { -8.976327956520795e-12, -9.855449649582175e-01 }, - { 8.976321536169872e-12, -1.014459730869357e+00 }, - { 2.692863307547294e-11, -1.043411601105914e+00 }, - { 4.487993076694813e-11, -1.072399482811314e+00 }, - { 6.282953875437751e-11, -1.101422278938424e+00 }, - { 8.077678124517653e-11, -1.130478888291020e+00 }, - { 9.872098253591082e-11, -1.159568205565684e+00 }, - { 1.166614670373367e-10, -1.188689121393192e+00 }, - { 1.345975593005002e-10, -1.217840522381901e+00 }, - { 1.525285840416718e-10, -1.247021291159495e+00 }, - { 1.704538661678104e-10, -1.276230306415868e+00 }, - { 1.883727308022916e-10, -1.305466442946703e+00 }, - { 2.062845033098954e-10, -1.334728571696106e+00 }, - { 2.241885093225349e-10, -1.364015559800721e+00 }, - { 2.420840747645085e-10, -1.393326270633325e+00 }, - { 2.599705258779635e-10, -1.422659563847049e+00 }, - { 2.778471892479898e-10, -1.452014295419243e+00 }, - { 2.957133918284542e-10, -1.481389317696831e+00 }, - { 3.135684609667761e-10, -1.510783479440191e+00 }, - { 3.314117244297624e-10, -1.540195625869043e+00 }, - { 3.492425104288060e-10, -1.569624598707558e+00 }, - { 3.670601476445565e-10, -1.599069236228850e+00 }, - { 3.848639652533361e-10, -1.628528373302631e+00 }, - { 4.026532929512281e-10, -1.658000841439269e+00 }, - { 4.204274609803869e-10, -1.687485468837799e+00 }, - { 4.381858001531792e-10, -1.716981080430596e+00 }, - { 4.559276418782829e-10, -1.746486497931567e+00 }, - { 4.736523181853565e-10, -1.776000539882225e+00 }, - { 4.913591617503452e-10, -1.805522021699094e+00 }, - { 5.090475059206794e-10, -1.835049755721194e+00 }, - { 5.267166847401562e-10, -1.864582551257262e+00 }, - { 5.443660329740862e-10, -1.894119214633676e+00 }, - { 5.619948861345454e-10, -1.923658549242818e+00 }, - { 5.796025805053097e-10, -1.953199355591180e+00 }, - { 5.971884531664190e-10, -1.982740431347091e+00 }, - { 6.147518420199055e-10, -2.012280571390674e+00 }, - { 6.322920858139346e-10, -2.041818567861395e+00 }, - { 6.498085241682158e-10, -2.071353210208005e+00 }, - { 6.673004975990425e-10, -2.100883285238127e+00 }, - { 6.847673475432746e-10, -2.130407577166309e+00 }, - { 7.022084163838545e-10, -2.159924867664933e+00 }, - { 7.196230474743716e-10, -2.189433935913779e+00 }, - { 7.370105851640495e-10, -2.218933558650552e+00 }, - { 7.543703748217808e-10, -2.248422510220072e+00 }, - { 7.717017628611672e-10, -2.277899562625407e+00 }, - { 7.890040967654542e-10, -2.307363485579104e+00 }, - { 8.062767251113011e-10, -2.336813046552684e+00 }, - { 8.235189975944034e-10, -2.366247010829556e+00 }, - { 8.407302650525749e-10, -2.395664141553858e+00 }, - { 8.579098794915287e-10, -2.425063199784153e+00 }, - { 8.750571941082773e-10, -2.454442944543319e+00 }, - { 8.921715633164894e-10, -2.483802132872044e+00 }, - { 9.092523427695200e-10, -2.513139519878584e+00 }, - { 9.262988893857148e-10, -2.542453858792682e+00 }, - { 9.433105613723914e-10, -2.571743901017465e+00 }, - { 9.602867182493987e-10, -2.601008396180870e+00 }, - { 9.772267208744730e-10, -2.630246092190425e+00 }, - { 9.941299314658458e-10, -2.659455735283526e+00 }, - { 1.010995713627070e-09, -2.688636070081818e+00 }, - { 1.027823432371055e-09, -2.717785839644439e+00 }, - { 1.044612454143997e-09, -2.746903785521352e+00 }, - { 1.061362146848353e-09, -2.775988647805256e+00 }, - { 1.078071879867828e-09, -2.805039165187255e+00 }, - { 1.094741024090249e-09, -2.834054075009077e+00 }, - { 1.111368951931856e-09, -2.863032113318052e+00 }, - { 1.127955037360817e-09, -2.891972014920939e+00 }, - { 1.144498655920037e-09, -2.920872513436805e+00 }, - { 1.160999184751779e-09, -2.949732341353290e+00 }, - { 1.177456002620215e-09, -2.978550230079517e+00 }, - { 1.193868489936097e-09, -3.007324910002949e+00 }, - { 1.210236028777826e-09, -3.036055110540183e+00 }, - { 1.226558002917232e-09, -3.064739560196251e+00 }, - { 1.242833797841123e-09, -3.093376986616735e+00 }, - { 1.259062800774685e-09, -3.121966116643377e+00 }, - { 1.275244400705935e-09, -3.150505676371791e+00 }, - { 1.291377988406056e-09, -3.178994391202159e+00 }, - { 1.307462956454857e-09, -3.207430985899192e+00 }, - { 1.323498699262108e-09, -3.235814184645077e+00 }, - { 1.339484613091842e-09, -3.264142711097884e+00 }, - { 1.355420096082785e-09, -3.292415288443373e+00 }, - { 1.371304548273191e-09, -3.320630639454825e+00 }, - { 1.387137371622433e-09, -3.348787486547389e+00 }, - { 1.402917970033511e-09, -3.376884551834256e+00 }, - { 1.418645749376393e-09, -3.404920557184582e+00 }, - { 1.434320117508396e-09, -3.432894224276359e+00 }, - { 1.449940484298756e-09, -3.460804274656981e+00 }, - { 1.465506261649108e-09, -3.488649429796768e+00 }, - { 1.481016863517580e-09, -3.516428411149154e+00 }, - { 1.496471705937951e-09, -3.544139940202303e+00 }, - { 1.511870207044433e-09, -3.571782738540999e+00 }, - { 1.527211787092206e-09, -3.599355527901174e+00 }, - { 1.542495868479076e-09, -3.626857030226671e+00 }, - { 1.557721875768920e-09, -3.654285967729458e+00 }, - { 1.572889235710329e-09, -3.681641062941412e+00 }, - { 1.587997377261005e-09, -3.708921038776707e+00 }, - { 1.603045731607830e-09, -3.736124618586623e+00 }, - { 1.618033732189314e-09, -3.763250526218862e+00 }, - { 1.632960814715177e-09, -3.790297486071938e+00 }, - { 1.647826417189275e-09, -3.817264223155802e+00 }, - { 1.662629979930247e-09, -3.844149463148589e+00 }, - { 1.677370945591844e-09, -3.870951932452996e+00 }, - { 1.692048759186008e-09, -3.897670358257890e+00 }, - { 1.706662868100504e-09, -3.924303468590212e+00 }, - { 1.721212722122685e-09, -3.950849992378278e+00 }, - { 1.735697773458400e-09, -3.977308659506432e+00 }, - { 1.750117476754591e-09, -4.003678200876669e+00 }, - { 1.764471289116712e-09, -4.029957348461003e+00 }, - { 1.778758670132079e-09, -4.056144835364877e+00 }, - { 1.792979081888926e-09, -4.082239395882965e+00 }, - { 1.807131988996465e-09, -4.108239765556996e+00 }, - { 1.821216858606652e-09, -4.134144681236933e+00 }, - { 1.835233160431175e-09, -4.159952881133585e+00 }, - { 1.849180366764537e-09, -4.185663104882633e+00 }, - { 1.863057952502055e-09, -4.211274093599509e+00 }, - { 1.876865395161145e-09, -4.236784589940537e+00 }, - { 1.890602174898734e-09, -4.262193338157148e+00 }, - { 1.904267774533022e-09, -4.287499084158302e+00 }, - { 1.917861679562008e-09, -4.312700575567174e+00 }, - { 1.931383378182392e-09, -4.337796561778708e+00 }, - { 1.944832361310856e-09, -4.362785794021793e+00 }, - { 1.958208122599839e-09, -4.387667025411434e+00 }, - { 1.971510158459931e-09, -4.412439011013396e+00 }, - { 1.984737968076495e-09, -4.437100507898339e+00 }, - { 1.997891053431005e-09, -4.461650275204912e+00 }, - { 2.010968919316289e-09, -4.486087074191693e+00 }, - { 2.023971073358447e-09, -4.510409668301784e+00 }, - { 2.036897026033634e-09, -4.534616823217992e+00 }, - { 2.049746290686799e-09, -4.558707306921882e+00 }, - { 2.062518383551274e-09, -4.582679889754607e+00 }, - { 2.075212823764071e-09, -4.606533344469879e+00 }, - { 2.087829133387063e-09, -4.630266446298172e+00 }, - { 2.100366837422912e-09, -4.653877973001258e+00 }, - { 2.112825463835087e-09, -4.677366704934605e+00 }, - { 2.125204543562522e-09, -4.700731425099899e+00 }, - { 2.137503610540056e-09, -4.723970919208608e+00 }, - { 2.149722201714786e-09, -4.747083975738060e+00 }, - { 2.161859857063438e-09, -4.770069385989595e+00 }, - { 2.173916119610994e-09, -4.792925944149308e+00 }, - { 2.185890535445098e-09, -4.815652447340950e+00 }, - { 2.197782653735957e-09, -4.838247695689436e+00 }, - { 2.209592026751962e-09, -4.860710492376411e+00 }, - { 2.221318209877576e-09, -4.883039643700314e+00 }, - { 2.232960761627846e-09, -4.905233959130168e+00 }, - { 2.244519243667616e-09, -4.927292251368517e+00 }, - { 2.255993220826402e-09, -4.949213336406265e+00 }, - { 2.267382261115285e-09, -4.970996033581527e+00 }, - { 2.278685935744269e-09, -4.992639165639563e+00 }, - { 2.289903819135414e-09, -5.014141558784778e+00 }, - { 2.301035488942000e-09, -5.035502042744443e+00 }, - { 2.312080526062763e-09, -5.056719450823151e+00 }, - { 2.323038514659161e-09, -5.077792619963239e+00 }, - { 2.333909042168180e-09, -5.098720390796817e+00 }, - { 2.344691699320969e-09, -5.119501607709159e+00 }, - { 2.355386080156553e-09, -5.140135118892792e+00 }, - { 2.365991782037187e-09, -5.160619776404897e+00 }, - { 2.376508405665132e-09, -5.180954436227641e+00 }, - { 2.386935555094626e-09, -5.201137958319343e+00 }, - { 2.397272837749508e-09, -5.221169206676762e+00 }, - { 2.407519864436774e-09, -5.241047049389645e+00 }, - { 2.417676249362563e-09, -5.260770358700167e+00 }, - { 2.427741610143750e-09, -5.280338011053974e+00 }, - { 2.437715567825576e-09, -5.299748887163106e+00 }, - { 2.447597746894037e-09, -5.319001872058887e+00 }, - { 2.457387775290440e-09, -5.338095855149190e+00 }, - { 2.467085284426756e-09, -5.357029730277389e+00 }, - { 2.476689909196263e-09, -5.375802395772283e+00 }, - { 2.486201287990485e-09, -5.394412754510426e+00 }, - { 2.495619062711154e-09, -5.412859713968929e+00 }, - { 2.504942878785408e-09, -5.431142186284682e+00 }, - { 2.514172385175743e-09, -5.449259088303476e+00 }, - { 2.523307234396791e-09, -5.467209341642627e+00 }, - { 2.532347082526785e-09, -5.484991872743321e+00 }, - { 2.541291589219998e-09, -5.502605612925014e+00 }, - { 2.550140417722072e-09, -5.520049498445633e+00 }, - { 2.558893234878378e-09, -5.537322470548212e+00 }, - { 2.567549711150773e-09, -5.554423475524196e+00 }, - { 2.576109520627371e-09, -5.571351464763084e+00 }, - { 2.584572341037361e-09, -5.588105394812198e+00 }, - { 2.592937853759161e-09, -5.604684227423386e+00 }, - { 2.601205743836355e-09, -5.621086929615246e+00 }, - { 2.609375699987564e-09, -5.637312473723475e+00 }, - { 2.617447414618146e-09, -5.653359837454964e+00 }, - { 2.625420583833750e-09, -5.669228003945694e+00 }, - { 2.633294907447937e-09, -5.684915961806963e+00 }, - { 2.641070088997271e-09, -5.700422705186584e+00 }, - { 2.648745835750128e-09, -5.715747233817712e+00 }, - { 2.656321858720176e-09, -5.730888553077074e+00 }, - { 2.663797872673252e-09, -5.745845674030161e+00 }, - { 2.671173596142054e-09, -5.760617613492118e+00 }, - { 2.678448751434797e-09, -5.775203394076705e+00 }, - { 2.685623064645538e-09, -5.789602044248679e+00 }, - { 2.692696265666640e-09, -5.803812598380606e+00 }, - { 2.699668088194915e-09, -5.817834096797069e+00 }, - { 2.706538269745573e-09, -5.831665585834668e+00 }, - { 2.713306551659817e-09, -5.845306117889361e+00 }, - { 2.719972679116734e-09, -5.858754751472542e+00 }, - { 2.726536401139295e-09, -5.872010551255358e+00 }, - { 2.732997470607439e-09, -5.885072588127400e+00 }, - { 2.739355644265558e-09, -5.897939939244211e+00 }, - { 2.745610682731633e-09, -5.910611688078208e+00 }, - { 2.751762350508137e-09, -5.923086924473290e+00 }, - { 2.757810415987146e-09, -5.935364744687794e+00 }, - { 2.763754651462700e-09, -5.947444251452243e+00 }, - { 2.769594833137415e-09, -5.959324554015538e+00 }, - { 2.775330741132843e-09, -5.971004768198829e+00 }, - { 2.780962159494174e-09, -5.982484016437981e+00 }, - { 2.786488876202047e-09, -5.993761427840588e+00 }, - { 2.791910683178690e-09, -6.004836138231525e+00 }, - { 2.797227376295779e-09, -6.015707290202086e+00 }, - { 2.802438755383971e-09, -6.026374033162623e+00 }, - { 2.807544624236659e-09, -6.036835523383457e+00 }, - { 2.812544790621093e-09, -6.047090924050914e+00 }, - { 2.817439066283459e-09, -6.057139405311101e+00 }, - { 2.822227266958278e-09, -6.066980144322601e+00 }, - { 2.826909212371261e-09, -6.076612325295799e+00 }, - { 2.831484726250221e-09, -6.086035139548830e+00 }, - { 2.835953636329660e-09, -6.095247785550617e+00 }, - { 2.840315774357203e-09, -6.104249468967751e+00 }, - { 2.844570976102082e-09, -6.113039402715685e+00 }, - { 2.848719081357095e-09, -6.121616806996519e+00 }, - { 2.852759933948860e-09, -6.129980909353977e+00 }, - { 2.856693381741114e-09, -6.138130944714082e+00 }, - { 2.860519276643053e-09, -6.146066155436312e+00 }, - { 2.864237474610633e-09, -6.153785791350256e+00 }, - { 2.867847835656203e-09, -6.161289109809551e+00 }, - { 2.871350223851726e-09, -6.168575375732642e+00 }, - { 2.874744507333867e-09, -6.175643861647406e+00 }, - { 2.878030558310989e-09, -6.182493847739853e+00 }, - { 2.881208253063899e-09, -6.189124621889823e+00 }, - { 2.884277471954592e-09, -6.195535479723423e+00 }, - { 2.887238099428306e-09, -6.201725724651554e+00 }, - { 2.890090024020323e-09, -6.207694667918394e+00 }, - { 2.892833138356060e-09, -6.213441628635915e+00 }, - { 2.895467339159240e-09, -6.218965933835304e+00 }, - { 2.897992527253659e-09, -6.224266918505075e+00 }, - { 2.900408607567016e-09, -6.229343925633495e+00 }, - { 2.902715489136496e-09, -6.234196306254763e+00 }, - { 2.904913085108075e-09, -6.238823419482017e+00 }, - { 2.907001312743911e-09, -6.243224632557377e+00 }, - { 2.908980093422997e-09, -6.247399320887848e+00 }, - { 2.910849352646620e-09, -6.251346868091392e+00 }, - { 2.912609020036956e-09, -6.255066666028537e+00 }, - { 2.914259029343965e-09, -6.258558114851525e+00 }, - { 2.915799318445710e-09, -6.261820623039620e+00 }, - { 2.917229829350759e-09, -6.264853607438842e+00 }, - { 2.918550508202463e-09, -6.267656493305673e+00 }, - { 2.919761305276718e-09, -6.270228714337005e+00 }, - { 2.920862174988150e-09, -6.272569712717951e+00 }, - { 2.921853075889193e-09, -6.274678939154603e+00 }, - { 2.922733970674264e-09, -6.276555852917634e+00 }, - { 2.923504826176907e-09, -6.278199921870962e+00 }, - { 2.924165613375264e-09, -6.279610622518139e+00 }, - { 2.924716307391075e-09, -6.280787440034993e+00 }, - { 2.925156887490598e-09, -6.281729868306345e+00 }, - { 2.925487337087508e-09, -6.282437409966992e+00 }, - { 2.925707643739298e-09, -6.282909576428774e+00 }, - { 2.925817799151970e-09, -6.283145887925411e+00 }, +// max_error = 2.353084136763606e-06 +{ 2.925817799165007e-09, 7.219194364267018e-09 }, + { 2.925707643778599e-09, 2.526699001579799e-07 }, + { 2.925487337153070e-09, 1.191140162167675e-06 }, + { 2.925156887582842e-09, 3.284585035595589e-06 }, + { 2.924716307509151e-09, 6.994872605695784e-06 }, + { 2.924165613519592e-09, 1.278374920658798e-05 }, + { 2.923504826347475e-09, 2.111280464718590e-05 }, + { 2.922733970871080e-09, 3.244343744537165e-05 }, + { 2.921853076112655e-09, 4.723682007436170e-05 }, + { 2.920862175237416e-09, 6.595386421935634e-05 }, + { 2.919761305552202e-09, 8.905518605213658e-05 }, + { 2.918550508504146e-09, 1.170010715193098e-04 }, + { 2.917229829679050e-09, 1.502514416517192e-04 }, + { 2.915799318799769e-09, 1.892658178912071e-04 }, + { 2.914259029724184e-09, 2.345032874456615e-04 }, + { 2.912609020443340e-09, 2.864224686607020e-04 }, + { 2.910849353079123e-09, 3.454814764261432e-04 }, + { 2.908980093882049e-09, 4.121378876027343e-04 }, + { 2.907001313228646e-09, 4.868487064877691e-04 }, + { 2.904913085618902e-09, 5.700703303049837e-04 }, + { 2.902715489673383e-09, 6.622585147355725e-04 }, + { 2.900408608130373e-09, 7.638683394782519e-04 }, + { 2.897992527842612e-09, 8.753541738578119e-04 }, + { 2.895467339774186e-09, 9.971696424604937e-04 }, + { 2.892833138996999e-09, 1.129767590823255e-03 }, + { 2.890090024687216e-09, 1.273600051161478e-03 }, + { 2.887238100121550e-09, 1.429118208142094e-03 }, + { 2.884277472673313e-09, 1.596772364709564e-03 }, + { 2.881208253808507e-09, 1.777011907950626e-03 }, + { 2.878030559081432e-09, 1.970285275029487e-03 }, + { 2.874744508130554e-09, 2.177039919152579e-03 }, + { 2.871350224673798e-09, 2.397722275614272e-03 }, + { 2.867847836504030e-09, 2.632777727878843e-03 }, + { 2.864237475484149e-09, 2.882650573737405e-03 }, + { 2.860519277542297e-09, 3.147783991507308e-03 }, + { 2.856693382666432e-09, 3.428620006328931e-03 }, + { 2.852759934899389e-09, 3.725599456482154e-03 }, + { 2.848719082333207e-09, 4.039161959812243e-03 }, + { 2.844570977103752e-09, 4.369745880190706e-03 }, + { 2.840315775384800e-09, 4.717788294077374e-03 }, + { 2.835953637382310e-09, 5.083724957128360e-03 }, + { 2.831484727328322e-09, 5.467990270896617e-03 }, + { 2.826909213474759e-09, 5.871017249604038e-03 }, + { 2.822227268087134e-09, 6.293237486988512e-03 }, + { 2.817439067438018e-09, 6.735081123237729e-03 }, + { 2.812544791800534e-09, 7.196976811989608e-03 }, + { 2.807544625441273e-09, 7.679351687456759e-03 }, + { 2.802438756613836e-09, 8.182631331563162e-03 }, + { 2.797227377551135e-09, 8.707239741274575e-03 }, + { 2.791910684458716e-09, 9.253599295902304e-03 }, + { 2.786488877507140e-09, 9.822130724578715e-03 }, + { 2.780962160824228e-09, 1.041325307382490e-02 }, + { 2.775330742487884e-09, 1.102738367513773e-02 }, + { 2.769594834517682e-09, 1.166493811278924e-02 }, + { 2.763754652867477e-09, 1.232633019159818e-02 }, + { 2.757810417416620e-09, 1.301197190494069e-02 }, + { 2.751762351962413e-09, 1.372227340270610e-02 }, + { 2.745610684210923e-09, 1.445764295952962e-02 }, + { 2.739355645769094e-09, 1.521848694296229e-02 }, + { 2.732997472135539e-09, 1.600520978188769e-02 }, + { 2.726536402691907e-09, 1.681821393496225e-02 }, + { 2.719972680693777e-09, 1.765789985920713e-02 }, + { 2.713306553261610e-09, 1.852466597868779e-02 }, + { 2.706538271371373e-09, 1.941890865333146e-02 }, + { 2.699668089844909e-09, 2.034102214787814e-02 }, + { 2.692696267340880e-09, 2.129139860085272e-02 }, + { 2.685623066344263e-09, 2.227042799383416e-02 }, + { 2.678448753157212e-09, 2.327849812064098e-02 }, + { 2.671173597888530e-09, 2.431599455681316e-02 }, + { 2.663797874443630e-09, 2.538330062913108e-02 }, + { 2.656321860514457e-09, 2.648079738524795e-02 }, + { 2.648745837568575e-09, 2.760886356354952e-02 }, + { 2.641070090839117e-09, 2.876787556300114e-02 }, + { 2.633294909313421e-09, 2.995820741329835e-02 }, + { 2.625420585722845e-09, 3.118023074495535e-02 }, + { 2.617447416531143e-09, 3.243431475972608e-02 }, + { 2.609375701923643e-09, 3.372082620101990e-02 }, + { 2.601205745795833e-09, 3.504012932452527e-02 }, + { 2.592937855741933e-09, 3.639258586895711e-02 }, + { 2.584572343043400e-09, 3.777855502693250e-02 }, + { 2.576109522656942e-09, 3.919839341605197e-02 }, + { 2.567549713203028e-09, 4.065245505002102e-02 }, + { 2.558893236953688e-09, 4.214109131001403e-02 }, + { 2.550140419820252e-09, 4.366465091617666e-02 }, + { 2.541291591341445e-09, 4.522347989919473e-02 }, + { 2.532347084670572e-09, 4.681792157215026e-02 }, + { 2.523307236563343e-09, 4.844831650239501e-02 }, + { 2.514172387364900e-09, 5.011500248369893e-02 }, + { 2.504942880997064e-09, 5.181831450849345e-02 }, + { 2.495619064945627e-09, 5.355858474024022e-02 }, + { 2.486201290246928e-09, 5.533614248606705e-02 }, + { 2.476689911475047e-09, 5.715131416942842e-02 }, + { 2.467085286727668e-09, 5.900442330315692e-02 }, + { 2.457387777613798e-09, 6.089579046229943e-02 }, + { 2.447597749239101e-09, 6.282573325755320e-02 }, + { 2.437715570192557e-09, 6.479456630859221e-02 }, + { 2.427741612532542e-09, 6.680260121764925e-02 }, + { 2.417676251773166e-09, 6.885014654319160e-02 }, + { 2.407519866869294e-09, 7.093750777401114e-02 }, + { 2.397272840203310e-09, 7.306498730310884e-02 }, + { 2.386935557569868e-09, 7.523288440214027e-02 }, + { 2.376508408161815e-09, 7.744149519577415e-02 }, + { 2.365991784555363e-09, 7.969111263635709e-02 }, + { 2.355386082695641e-09, 8.198202647865405e-02 }, + { 2.344691701881232e-09, 8.431452325495814e-02 }, + { 2.333909044749407e-09, 8.668888625021409e-02 }, + { 2.323038517261246e-09, 8.910539547731611e-02 }, + { 2.312080528685971e-09, 9.156432765274414e-02 }, + { 2.301035491585642e-09, 9.406595617227698e-02 }, + { 2.289903821799651e-09, 9.661055108691619e-02 }, + { 2.278685938428940e-09, 9.919837907903295e-02 }, + { 2.267382263820762e-09, 1.018297034385580e-01 }, + { 2.255993223551837e-09, 1.045047840397028e-01 }, + { 2.244519246413220e-09, 1.072238773174577e-01 }, + { 2.232960764393620e-09, 1.099872362446146e-01 }, + { 2.221318212663309e-09, 1.127951103088245e-01 }, + { 2.209592029557811e-09, 1.156477454898748e-01 }, + { 2.197782656561395e-09, 1.185453842371912e-01 }, + { 2.185890538290176e-09, 1.214882654476019e-01 }, + { 2.173916122475606e-09, 1.244766244431883e-01 }, + { 2.161859859947797e-09, 1.275106929493488e-01 }, + { 2.149722204618256e-09, 1.305906990731841e-01 }, + { 2.137503613462743e-09, 1.337168672820376e-01 }, + { 2.125204546504321e-09, 1.368894183821595e-01 }, + { 2.112825466795944e-09, 1.401085694976751e-01 }, + { 2.100366840402933e-09, 1.433745340497602e-01 }, + { 2.087829136385612e-09, 1.466875217359607e-01 }, + { 2.075212826781308e-09, 1.500477385098620e-01 }, + { 2.062518386587093e-09, 1.534553865607503e-01 }, + { 2.049746293741359e-09, 1.569106642937665e-01 }, + { 2.036897029106193e-09, 1.604137663100403e-01 }, + { 2.023971076449323e-09, 1.639648833871233e-01 }, + { 2.010968922425217e-09, 1.675642024598467e-01 }, + { 1.997891056557933e-09, 1.712119066008896e-01 }, + { 1.984737971221581e-09, 1.749081750021970e-01 }, + { 1.971510161622434e-09, 1.786531829561379e-01 }, + { 1.958208125780130e-09, 1.824471018371070e-01 }, + { 1.944832364508511e-09, 1.862900990834311e-01 }, + { 1.931383381397782e-09, 1.901823381790926e-01 }, + { 1.917861682794392e-09, 1.941239786363039e-01 }, + { 1.904267777782611e-09, 1.981151759777950e-01 }, + { 1.890602178165317e-09, 2.021560817195309e-01 }, + { 1.876865398444616e-09, 2.062468433536743e-01 }, + { 1.863057955802572e-09, 2.103876043317229e-01 }, + { 1.849180370081465e-09, 2.145785040479915e-01 }, + { 1.835233163764673e-09, 2.188196778231083e-01 }, + { 1.821216861956509e-09, 2.231112568880342e-01 }, + { 1.807131992362945e-09, 2.274533683680190e-01 }, + { 1.792979085271234e-09, 2.318461352671018e-01 }, + { 1.778758673530482e-09, 2.362896764525300e-01 }, + { 1.764471292530943e-09, 2.407841066397789e-01 }, + { 1.750117480184598e-09, 2.453295363773890e-01 }, + { 1.735697776904342e-09, 2.499260720324433e-01 }, + { 1.721212725583874e-09, 2.545738157760434e-01 }, + { 1.706662871577097e-09, 2.592728655691494e-01 }, + { 1.692048762677849e-09, 2.640233151485341e-01 }, + { 1.677370949099090e-09, 2.688252540131204e-01 }, + { 1.662629983452104e-09, 2.736787674105404e-01 }, + { 1.647826420726167e-09, 2.785839363237506e-01 }, + { 1.632960818266680e-09, 2.835408374583758e-01 }, + { 1.618033735755429e-09, 2.885495432295704e-01 }, + { 1.603045735188609e-09, 2.936101217498361e-01 }, + { 1.587997380855918e-09, 2.987226368167127e-01 }, + { 1.572889239319430e-09, 3.038871479007593e-01 }, + { 1.557721879392051e-09, 3.091037101339017e-01 }, + { 1.542495872116447e-09, 3.143723742978435e-01 }, + { 1.527211790743024e-09, 3.196931868130269e-01 }, + { 1.511870210708909e-09, 3.250661897274744e-01 }, + { 1.496471709615926e-09, 3.304914207062036e-01 }, + { 1.481016867208896e-09, 3.359689130207621e-01 }, + { 1.465506265353924e-09, 3.414986955389885e-01 }, + { 1.449940488016384e-09, 3.470807927151147e-01 }, + { 1.434320121238994e-09, 3.527152245800635e-01 }, + { 1.418645753119802e-09, 3.584020067320109e-01 }, + { 1.402917973789838e-09, 3.641411503272979e-01 }, + { 1.387137375391042e-09, 3.699326620714776e-01 }, + { 1.371304552054134e-09, 3.757765442106153e-01 }, + { 1.355420099875958e-09, 3.816727945230153e-01 }, + { 1.339484616897137e-09, 3.876214063110671e-01 }, + { 1.323498703079580e-09, 3.936223683933865e-01 }, + { 1.307462960283922e-09, 3.996756650972121e-01 }, + { 1.291377992246768e-09, 4.057812762511174e-01 }, + { 1.275244404558188e-09, 4.119391771778626e-01 }, + { 1.259062804638585e-09, 4.181493386877248e-01 }, + { 1.242833801715929e-09, 4.244117270719281e-01 }, + { 1.226558006803155e-09, 4.307263040962509e-01 }, + { 1.210236032674760e-09, 4.370930269951803e-01 }, + { 1.193868493843725e-09, 4.435118484661861e-01 }, + { 1.177456006538695e-09, 4.499827166641340e-01 }, + { 1.160999188680582e-09, 4.565055751961679e-01 }, + { 1.144498659859216e-09, 4.630803631168164e-01 }, + { 1.127955041310214e-09, 4.697070149232604e-01 }, + { 1.111368955891417e-09, 4.763854605510119e-01 }, + { 1.094741028059551e-09, 4.831156253697562e-01 }, + { 1.078071883846871e-09, 4.898974301794375e-01 }, + { 1.061362150836978e-09, 4.967307912069362e-01 }, + { 1.044612458142151e-09, 5.036156201023686e-01 }, + { 1.027823436378632e-09, 5.105518239364775e-01 }, + { 1.010995717643647e-09, 5.175393051975563e-01 }, + { 9.941299354913699e-10, 5.245779617890562e-01 }, + { 9.772267249089968e-10, 5.316676870274011e-01 }, + { 9.602867222926046e-10, 5.388083696401416e-01 }, + { 9.433105654240147e-10, 5.459998937639375e-01 }, + { 9.262988934458084e-10, 5.532421389435711e-01 }, + { 9.092523468378193e-10, 5.605349801305876e-01 }, + { 8.921715673928355e-10, 5.678782876825250e-01 }, + { 8.750571981926701e-10, 5.752719273622372e-01 }, + { 8.579098835836508e-10, 5.827157603377209e-01 }, + { 8.407302691522673e-10, 5.902096431821322e-01 }, + { 8.235190017016133e-10, 5.977534278737073e-01 }, + { 8.062767292259225e-10, 6.053469617967722e-01 }, + { 7.890041008871165e-10, 6.129900877421282e-01 }, + { 7.717017669898175e-10, 6.206826439083659e-01 }, + { 7.543703789572603e-10, 6.284244639030392e-01 }, + { 7.370105893063053e-10, 6.362153767444958e-01 }, + { 7.196230516231919e-10, 6.440552068636356e-01 }, + { 7.022084205389746e-10, 6.519437741060674e-01 }, + { 6.847673517046416e-10, 6.598808937346672e-01 }, + { 6.673005017664976e-10, 6.678663764322770e-01 }, + { 6.498085283416530e-10, 6.759000283046127e-01 }, + { 6.322920899929834e-10, 6.839816508836737e-01 }, + { 6.147518462045659e-10, 6.921110411311926e-01 }, + { 5.971884573565851e-10, 7.002879914425926e-01 }, + { 5.796025847007168e-10, 7.085122896509806e-01 }, + { 5.619948903351406e-10, 7.167837190315758e-01 }, + { 5.443660371796048e-10, 7.251020583063744e-01 }, + { 5.267166889504394e-10, 7.334670816491009e-01 }, + { 5.090475101356742e-10, 7.418785586903696e-01 }, + { 4.913591659698399e-10, 7.503362545232619e-01 }, + { 4.736523224091392e-10, 7.588399297089872e-01 }, + { 4.559276461062478e-10, 7.673893402829834e-01 }, + { 4.381858043851147e-10, 7.759842377612828e-01 }, + { 4.204274652161870e-10, 7.846243691469355e-01 }, + { 4.026532971908398e-10, 7.933094769370790e-01 }, + { 3.848639694963359e-10, 8.020392991300200e-01 }, + { 3.670601518910503e-10, 8.108135692324444e-01 }, + { 3.492425146784233e-10, 8.196320162675177e-01 }, + { 3.314117286825031e-10, 8.284943647824689e-01 }, + { 3.135684652223755e-10, 8.374003348569865e-01 }, + { 2.957133960867535e-10, 8.463496421118015e-01 }, + { 2.778471935089361e-10, 8.553419977173513e-01 }, + { 2.599705301412391e-10, 8.643771084029740e-01 }, + { 2.420840790301135e-10, 8.734546764660205e-01 }, + { 2.241885135902046e-10, 8.825743997817682e-01 }, + { 2.062845075795238e-10, 8.917359718130367e-01 }, + { 1.883727350736140e-10, 9.009390816205823e-01 }, + { 1.704538704408269e-10, 9.101834138731877e-01 }, + { 1.525285883160648e-10, 9.194686488588080e-01 }, + { 1.345975635762696e-10, 9.287944624950824e-01 }, + { 1.166614713141648e-10, 9.381605263410157e-01 }, + { 9.872098681369190e-11, 9.475665076080466e-01 }, + { 8.077678552380464e-11, 9.570120691722380e-01 }, + { 6.282954303364090e-11, 9.664968695860140e-01 }, + { 4.487993504668797e-11, 9.760205630906909e-01 }, + { 2.692863735553042e-11, 9.855827996289697e-01 }, + { 8.976325816439114e-12, 9.951832248577780e-01 }, + { -8.976323676304494e-12, 1.004821480161519e+00 }, + { -2.692863521550168e-11, 1.014497202665280e+00 }, + { -4.487993290681805e-11, 1.024210025248670e+00 }, + { -6.282954089398273e-11, 1.033959576559617e+00 }, + { -8.077678338451706e-11, 1.043745481028715e+00 }, + { -9.872098467477489e-11, 1.053567358883467e+00 }, + { -1.166614691757772e-10, 1.063424826163223e+00 }, + { -1.345975614383584e-10, 1.073317494734013e+00 }, + { -1.525285861788948e-10, 1.083244972303963e+00 }, + { -1.704538683042922e-10, 1.093206862438572e+00 }, + { -1.883727329379793e-10, 1.103202764576806e+00 }, + { -2.062845054446831e-10, 1.113232274046796e+00 }, + { -2.241885114563697e-10, 1.123294982082432e+00 }, + { -2.420840768973375e-10, 1.133390475839767e+00 }, + { -2.599705280096278e-10, 1.143518338413855e+00 }, + { -2.778471913784365e-10, 1.153678148855860e+00 }, + { -2.957133939575774e-10, 1.163869482190458e+00 }, + { -3.135684630945758e-10, 1.174091909433296e+00 }, + { -3.314117265561857e-10, 1.184344997608959e+00 }, + { -3.492425125535882e-10, 1.194628309769018e+00 }, + { -3.670601497678034e-10, 1.204941405010466e+00 }, + { -3.848639673748360e-10, 1.215283838494269e+00 }, + { -4.026532950710339e-10, 1.225655161464298e+00 }, + { -4.204274630982869e-10, 1.236054921266445e+00 }, + { -4.381858022691734e-10, 1.246482661367958e+00 }, + { -4.559276439922654e-10, 1.256937921377146e+00 }, + { -4.736523202972214e-10, 1.267420237063216e+00 }, + { -4.913591638600925e-10, 1.277929140376502e+00 }, + { -5.090475080282032e-10, 1.288464159468706e+00 }, + { -5.267166868452449e-10, 1.299024818713528e+00 }, + { -5.443660350768455e-10, 1.309610638727845e+00 }, + { -5.619948882348695e-10, 1.320221136392390e+00 }, + { -5.796025826029868e-10, 1.330855824873457e+00 }, + { -5.971884552615020e-10, 1.341514213644420e+00 }, + { -6.147518441122357e-10, 1.352195808507556e+00 }, + { -6.322920879034590e-10, 1.362900111616144e+00 }, + { -6.498085262549874e-10, 1.373626621496939e+00 }, + { -6.673004996827436e-10, 1.384374833072571e+00 }, + { -6.847673496239581e-10, 1.395144237684605e+00 }, + { -7.022084184613616e-10, 1.405934323116231e+00 }, + { -7.196230495488082e-10, 1.416744573616104e+00 }, + { -7.370105872352039e-10, 1.427574469921397e+00 }, + { -7.543703768894941e-10, 1.438423489281758e+00 }, + { -7.717017649255453e-10, 1.449291105483472e+00 }, + { -7.890040988262324e-10, 1.460176788873383e+00 }, + { -8.062767271686383e-10, 1.471080006383765e+00 }, + { -8.235189996479819e-10, 1.482000221556656e+00 }, + { -8.407302671024475e-10, 1.492936894569018e+00 }, + { -8.579098815375368e-10, 1.503889482257845e+00 }, + { -8.750571961505266e-10, 1.514857438145604e+00 }, + { -8.921715653546624e-10, 1.525840212465756e+00 }, + { -9.092523448036167e-10, 1.536837252188703e+00 }, + { -9.262988914157881e-10, 1.547848001047890e+00 }, + { -9.433105633981766e-10, 1.558871899565883e+00 }, + { -9.602867202711075e-10, 1.569908385081254e+00 }, + { -9.772267228916820e-10, 1.580956891774897e+00 }, + { -9.941299334786078e-10, 1.592016850697478e+00 }, + { -1.010995715635332e-09, 1.603087689796053e+00 }, + { -1.027823434374870e-09, 1.614168833942028e+00 }, + { -1.044612456143047e-09, 1.625259704958335e+00 }, + { -1.061362148842745e-09, 1.636359721647526e+00 }, + { -1.078071881857297e-09, 1.647468299819543e+00 }, + { -1.094741026074900e-09, 1.658584852320419e+00 }, + { -1.111368953911690e-09, 1.669708789060341e+00 }, + { -1.127955039335462e-09, 1.680839517042381e+00 }, + { -1.144498657889600e-09, 1.691976440391624e+00 }, + { -1.160999186716154e-09, 1.703118960383971e+00 }, + { -1.177456004579561e-09, 1.714266475475616e+00 }, + { -1.193868491889832e-09, 1.725418381332405e+00 }, + { -1.210236030726319e-09, 1.736574070859850e+00 }, + { -1.226558004860220e-09, 1.747732934232508e+00 }, + { -1.242833799778447e-09, 1.758894358924547e+00 }, + { -1.259062802706714e-09, 1.770057729740021e+00 }, + { -1.275244402631982e-09, 1.781222428842935e+00 }, + { -1.291377990326492e-09, 1.792387835788660e+00 }, + { -1.307462958369363e-09, 1.803553327553897e+00 }, + { -1.323498701170897e-09, 1.814718278568759e+00 }, + { -1.339484614994490e-09, 1.825882060747428e+00 }, + { -1.355420097979292e-09, 1.837044043519582e+00 }, + { -1.371304550163662e-09, 1.848203593862598e+00 }, + { -1.387137373506711e-09, 1.859360076332671e+00 }, + { -1.402917971911754e-09, 1.870512853097495e+00 }, + { -1.418645751248018e-09, 1.881661283967967e+00 }, + { -1.434320119373722e-09, 1.892804726431080e+00 }, + { -1.449940486157623e-09, 1.903942535681972e+00 }, + { -1.465506263501516e-09, 1.915074064656886e+00 }, + { -1.481016865363264e-09, 1.926198664066737e+00 }, + { -1.496471707776859e-09, 1.937315682428795e+00 }, + { -1.511870208876724e-09, 1.948424466101625e+00 }, + { -1.527211788917509e-09, 1.959524359317042e+00 }, + { -1.542495870297867e-09, 1.970614704215133e+00 }, + { -1.557721877580406e-09, 1.981694840876775e+00 }, + { -1.572889237514880e-09, 1.992764107358707e+00 }, + { -1.587997379058514e-09, 2.003821839726753e+00 }, + { -1.603045733398246e-09, 2.014867372090665e+00 }, + { -1.618033733972424e-09, 2.025900036638798e+00 }, + { -1.632960816490822e-09, 2.036919163671778e+00 }, + { -1.647826418957721e-09, 2.047924081638631e+00 }, + { -1.662629981691070e-09, 2.058914117170269e+00 }, + { -1.677370947345626e-09, 2.069888595116115e+00 }, + { -1.692048760931849e-09, 2.080846838577820e+00 }, + { -1.706662869838827e-09, 2.091788168946183e+00 }, + { -1.721212723853279e-09, 2.102711905935372e+00 }, + { -1.735697775181424e-09, 2.113617367619504e+00 }, + { -1.750117478469621e-09, 2.124503870468520e+00 }, + { -1.764471290823748e-09, 2.135370729383332e+00 }, + { -1.778758671831281e-09, 2.146217257733207e+00 }, + { -1.792979083579974e-09, 2.157042767390815e+00 }, + { -1.807131990679890e-09, 2.167846568770014e+00 }, + { -1.821216860281448e-09, 2.178627970860822e+00 }, + { -1.835233162097977e-09, 2.189386281268046e+00 }, + { -1.849180368423027e-09, 2.200120806246095e+00 }, + { -1.863057954152340e-09, 2.210830850737588e+00 }, + { -1.876865396802907e-09, 2.221515718409926e+00 }, + { -1.890602176531920e-09, 2.232174711691990e+00 }, + { -1.904267776157843e-09, 2.242807131812679e+00 }, + { -1.917861681178094e-09, 2.253412278837029e+00 }, + { -1.931383379790273e-09, 2.263989451705295e+00 }, + { -1.944832362909578e-09, 2.274537948269257e+00 }, + { -1.958208124189984e-09, 2.285057065331676e+00 }, + { -1.971510160041235e-09, 2.295546098682665e+00 }, + { -1.984737969649064e-09, 2.306004343138794e+00 }, + { -1.997891054994522e-09, 2.316431092581699e+00 }, + { -2.010968920870647e-09, 2.326825639994779e+00 }, + { -2.023971074903858e-09, 2.337187277503834e+00 }, + { -2.036897027569834e-09, 2.347515296413520e+00 }, + { -2.049746292214264e-09, 2.357808987247877e+00 }, + { -2.062518385069210e-09, 2.368067639787542e+00 }, + { -2.075212825272584e-09, 2.378290543109652e+00 }, + { -2.087829134886364e-09, 2.388476985626922e+00 }, + { -2.100366838912949e-09, 2.398626255125417e+00 }, + { -2.112825465315542e-09, 2.408737638805759e+00 }, + { -2.125204545033289e-09, 2.418810423320288e+00 }, + { -2.137503612001452e-09, 2.428843894814472e+00 }, + { -2.149722203166389e-09, 2.438837338964302e+00 }, + { -2.161859858505829e-09, 2.448790041018174e+00 }, + { -2.173916121043380e-09, 2.458701285834241e+00 }, + { -2.185890536867478e-09, 2.468570357921585e+00 }, + { -2.197782655148702e-09, 2.478396541480230e+00 }, + { -2.209592028154913e-09, 2.488179120439544e+00 }, + { -2.221318211270522e-09, 2.497917378500214e+00 }, + { -2.232960763010574e-09, 2.507610599172123e+00 }, + { -2.244519245040444e-09, 2.517258065817044e+00 }, + { -2.255993222189014e-09, 2.526859061686102e+00 }, + { -2.267382262468209e-09, 2.536412869962689e+00 }, + { -2.278685937086658e-09, 2.545918773800664e+00 }, + { -2.289903820467374e-09, 2.555376056366064e+00 }, + { -2.301035490263848e-09, 2.564784000877677e+00 }, + { -2.312080527374447e-09, 2.574141890646339e+00 }, + { -2.323038515960257e-09, 2.583449009117307e+00 }, + { -2.333909043458635e-09, 2.592704639909166e+00 }, + { -2.344691700601153e-09, 2.601908066856634e+00 }, + { -2.355386081425938e-09, 2.611058574048749e+00 }, + { -2.365991783296513e-09, 2.620155445872768e+00 }, + { -2.376508406913500e-09, 2.629197967052127e+00 }, + { -2.386935556332088e-09, 2.638185422689490e+00 }, + { -2.397272838976436e-09, 2.647117098307332e+00 }, + { -2.407519865653114e-09, 2.655992279887846e+00 }, + { -2.417676250567891e-09, 2.664810253915885e+00 }, + { -2.427741611338014e-09, 2.673570307418169e+00 }, + { -2.437715569009093e-09, 2.682271728006635e+00 }, + { -2.447597748066437e-09, 2.690913803917100e+00 }, + { -2.457387776452357e-09, 2.699495824053297e+00 }, + { -2.467085285577292e-09, 2.708017078025636e+00 }, + { -2.476689910335470e-09, 2.716476856194105e+00 }, + { -2.486201289118733e-09, 2.724874449709689e+00 }, + { -2.495619063828443e-09, 2.733209150554255e+00 }, + { -2.504942879891263e-09, 2.741480251583985e+00 }, + { -2.514172386270163e-09, 2.749687046568741e+00 }, + { -2.523307235480146e-09, 2.757828830235740e+00 }, + { -2.532347083598520e-09, 2.765904898308531e+00 }, + { -2.541291590280960e-09, 2.773914547551261e+00 }, + { -2.550140418771202e-09, 2.781857075807392e+00 }, + { -2.558893235915887e-09, 2.789731782043156e+00 }, + { -2.567549712176927e-09, 2.797537966388929e+00 }, + { -2.576109521642196e-09, 2.805274930179221e+00 }, + { -2.584572342040407e-09, 2.812941975996573e+00 }, + { -2.592937854750428e-09, 2.820538407710556e+00 }, + { -2.601205744816134e-09, 2.828063530521908e+00 }, + { -2.609375700955458e-09, 2.835516651001539e+00 }, + { -2.617447415574869e-09, 2.842897077134583e+00 }, + { -2.625420584778350e-09, 2.850204118359573e+00 }, + { -2.633294908380520e-09, 2.857437085611509e+00 }, + { -2.641070089918234e-09, 2.864595291363663e+00 }, + { -2.648745836659391e-09, 2.871678049666939e+00 }, + { -2.656321859617343e-09, 2.878684676194483e+00 }, + { -2.663797873558322e-09, 2.885614488280000e+00 }, + { -2.671173597015318e-09, 2.892466804962122e+00 }, + { -2.678448752295859e-09, 2.899240947023252e+00 }, + { -2.685623065495139e-09, 2.905936237033475e+00 }, + { -2.692696266503800e-09, 2.912551999389617e+00 }, + { -2.699668089019767e-09, 2.919087560358171e+00 }, + { -2.706538270558513e-09, 2.925542248116882e+00 }, + { -2.713306552460767e-09, 2.931915392794031e+00 }, + { -2.719972679905295e-09, 2.938206326512581e+00 }, + { -2.726536401915442e-09, 2.944414383428562e+00 }, + { -2.732997471371516e-09, 2.950538899775061e+00 }, + { -2.739355645017194e-09, 2.956579213900666e+00 }, + { -2.745610683471516e-09, 2.962534666313284e+00 }, + { -2.751762351235315e-09, 2.968404599718795e+00 }, + { -2.757810416701751e-09, 2.974188359063684e+00 }, + { -2.763754652165128e-09, 2.979885291576143e+00 }, + { -2.769594833827588e-09, 2.985494746805227e+00 }, + { -2.775330741810390e-09, 2.991016076664491e+00 }, + { -2.780962160159068e-09, 2.996448635469842e+00 }, + { -2.786488876854607e-09, 3.001791779983262e+00 }, + { -2.791910683818570e-09, 3.007044869450794e+00 }, + { -2.797227376923695e-09, 3.012207265645876e+00 }, + { -2.802438755998943e-09, 3.017278332907412e+00 }, + { -2.807544624838820e-09, 3.022257438182037e+00 }, + { -2.812544791210840e-09, 3.027143951064684e+00 }, + { -2.817439066860792e-09, 3.031937243837070e+00 }, + { -2.822227267522746e-09, 3.036636691510884e+00 }, + { -2.826909212922864e-09, 3.041241671864994e+00 }, + { -2.831484726789317e-09, 3.045751565488710e+00 }, + { -2.835953636855826e-09, 3.050165755818853e+00 }, + { -2.840315774871260e-09, 3.054483629182857e+00 }, + { -2.844570976602957e-09, 3.058704574835744e+00 }, + { -2.848719081844986e-09, 3.062827985002047e+00 }, + { -2.852759934424164e-09, 3.066853254915581e+00 }, + { -2.856693382203833e-09, 3.070779782857041e+00 }, + { -2.860519277092708e-09, 3.074606970196721e+00 }, + { -2.864237475047239e-09, 3.078334221430809e+00 }, + { -2.867847836080156e-09, 3.081960944223928e+00 }, + { -2.871350224262603e-09, 3.085486549445314e+00 }, + { -2.874744507732462e-09, 3.088910451211251e+00 }, + { -2.878030558696270e-09, 3.092232066921130e+00 }, + { -2.881208253436038e-09, 3.095450817298478e+00 }, + { -2.884277472313999e-09, 3.098566126429974e+00 }, + { -2.887238099774968e-09, 3.101577421802070e+00 }, + { -2.890090024353816e-09, 3.104484134342861e+00 }, + { -2.892833138676371e-09, 3.107285698457308e+00 }, + { -2.895467339466766e-09, 3.109981552069083e+00 }, + { -2.897992527547963e-09, 3.112571136655481e+00 }, + { -2.900408607848946e-09, 3.115053897289195e+00 }, + { -2.902715489404992e-09, 3.117429282673042e+00 }, + { -2.904913085363323e-09, 3.119696745180238e+00 }, + { -2.907001312986328e-09, 3.121855740892224e+00 }, + { -2.908980093652563e-09, 3.123905729634218e+00 }, + { -2.910849352862924e-09, 3.125846175016163e+00 }, + { -2.912609020239985e-09, 3.127676544466606e+00 }, + { -2.914259029534118e-09, 3.129396309273659e+00 }, + { -2.915799318622574e-09, 3.131004944618667e+00 }, + { -2.917229829515169e-09, 3.132501929616775e+00 }, + { -2.918550508353347e-09, 3.133886747350606e+00 }, + { -2.919761305414294e-09, 3.135158884909254e+00 }, + { -2.920862175112829e-09, 3.136317833424958e+00 }, + { -2.921853076000972e-09, 3.137363088107359e+00 }, + { -2.922733970772719e-09, 3.138294148283254e+00 }, + { -2.923504826262027e-09, 3.139110517429204e+00 }, + { -2.924165613447473e-09, 3.139811703211207e+00 }, + { -2.924716307449950e-09, 3.140397217517018e+00 }, + { -2.925156887536978e-09, 3.140866576495489e+00 }, + { -2.925487337120335e-09, 3.141219300588825e+00 }, + { -2.925707643758784e-09, 3.141454914570261e+00 }, + { -2.925817799158535e-09, 3.141572947579352e+00 }, + { -2.925817799171455e-09, 3.141572933154836e+00 }, + { -2.925707643798390e-09, 3.141454409272987e+00 }, + { -2.925487337185779e-09, 3.141216918378770e+00 }, + { -2.925156887628892e-09, 3.140860007424112e+00 }, + { -2.924716307568119e-09, 3.140383227898687e+00 }, + { -2.924165613591896e-09, 3.139786135867868e+00 }, + { -2.923504826432903e-09, 3.139068292003385e+00 }, + { -2.922733970969412e-09, 3.138229261619561e+00 }, + { -2.921853076224321e-09, 3.137268614707029e+00 }, + { -2.920862175361976e-09, 3.136185925964038e+00 }, + { -2.919761305690083e-09, 3.134980774833275e+00 }, + { -2.918550508654911e-09, 3.133652745531368e+00 }, + { -2.917229829843137e-09, 3.132201427085629e+00 }, + { -2.915799318976726e-09, 3.130626413363146e+00 }, + { -2.914259029914435e-09, 3.128927303107136e+00 }, + { -2.912609020646661e-09, 3.127103699965947e+00 }, + { -2.910849353295315e-09, 3.125155212527586e+00 }, + { -2.908980094111509e-09, 3.123081454351802e+00 }, + { -2.907001313470937e-09, 3.120882043999591e+00 }, + { -2.904913085874448e-09, 3.118556605068443e+00 }, + { -2.902715489941767e-09, 3.116104766219928e+00 }, + { -2.900408608411958e-09, 3.113526161214776e+00 }, + { -2.897992528137022e-09, 3.110820428940251e+00 }, + { -2.895467340081818e-09, 3.107987213444579e+00 }, + { -2.892833139317615e-09, 3.105026163964191e+00 }, + { -2.890090025020589e-09, 3.101936934956479e+00 }, + { -2.887238100468092e-09, 3.098719186130021e+00 }, + { -2.884277473032614e-09, 3.095372582472161e+00 }, + { -2.881208254180937e-09, 3.091896794282404e+00 }, + { -2.878030559466594e-09, 3.088291497198199e+00 }, + { -2.874744508528832e-09, 3.084556372228054e+00 }, + { -2.871350225084755e-09, 3.080691105776848e+00 }, + { -2.867847836928063e-09, 3.076695389678615e+00 }, + { -2.864237475921086e-09, 3.072568921221621e+00 }, + { -2.860519277991847e-09, 3.068311403179147e+00 }, + { -2.856693383129018e-09, 3.063922543837792e+00 }, + { -2.852759935374575e-09, 3.059402057023109e+00 }, + { -2.848719082821403e-09, 3.054749662130841e+00 }, + { -2.844570977604520e-09, 3.049965084150782e+00 }, + { -2.840315775898525e-09, 3.045048053697736e+00 }, + { -2.835953637908582e-09, 3.039998307034967e+00 }, + { -2.831484727867511e-09, 3.034815586104635e+00 }, + { -2.826909214026628e-09, 3.029499638550941e+00 }, + { -2.822227268651470e-09, 3.024050217748861e+00 }, + { -2.817439068015245e-09, 3.018467082830179e+00 }, + { -2.812544792390175e-09, 3.012749998707001e+00 }, + { -2.807544626043751e-09, 3.006898736100911e+00 }, + { -2.802438757228650e-09, 3.000913071564665e+00 }, + { -2.797227378178760e-09, 2.994792787510961e+00 }, + { -2.791910685098702e-09, 2.988537672233504e+00 }, + { -2.786488878159805e-09, 2.982147519935565e+00 }, + { -2.780962161489413e-09, 2.975622130750641e+00 }, + { -2.775330743165298e-09, 2.968961310769028e+00 }, + { -2.769594835207775e-09, 2.962164872061613e+00 }, + { -2.763754653569747e-09, 2.955232632701135e+00 }, + { -2.757810418131543e-09, 2.948164416789036e+00 }, + { -2.751762352689432e-09, 2.940960054474719e+00 }, + { -2.745610684950541e-09, 2.933619381982341e+00 }, + { -2.739355646520809e-09, 2.926142241629213e+00 }, + { -2.732997472899722e-09, 2.918528481852205e+00 }, + { -2.726536403468318e-09, 2.910777957226018e+00 }, + { -2.719972681482232e-09, 2.902890528487386e+00 }, + { -2.713306554062453e-09, 2.894866062556452e+00 }, + { -2.706538272184154e-09, 2.886704432555728e+00 }, + { -2.699668090670078e-09, 2.878405517834426e+00 }, + { -2.692696268177908e-09, 2.869969203985464e+00 }, + { -2.685623067193599e-09, 2.861395382869544e+00 }, + { -2.678448754018380e-09, 2.852683952631486e+00 }, + { -2.671173598761847e-09, 2.843834817723832e+00 }, + { -2.663797875328991e-09, 2.834847888922988e+00 }, + { -2.656321861411517e-09, 2.825723083350459e+00 }, + { -2.648745838477759e-09, 2.816460324492298e+00 }, + { -2.641070091759922e-09, 2.807059542215146e+00 }, + { -2.633294910246296e-09, 2.797520672788269e+00 }, + { -2.625420586667340e-09, 2.787843658897949e+00 }, + { -2.617447417487602e-09, 2.778028449668942e+00 }, + { -2.609375702891616e-09, 2.768075000678399e+00 }, + { -2.601205746775692e-09, 2.757983273976943e+00 }, + { -2.592937856733464e-09, 2.747753238101915e+00 }, + { -2.584572344046340e-09, 2.737384868096553e+00 }, + { -2.576109523671634e-09, 2.726878145526201e+00 }, + { -2.567549714229129e-09, 2.716233058492422e+00 }, + { -2.558893237991435e-09, 2.705449601651722e+00 }, + { -2.550140420869302e-09, 2.694527776227857e+00 }, + { -2.541291592402089e-09, 2.683467590030445e+00 }, + { -2.532347085742440e-09, 2.672269057466213e+00 }, + { -2.523307237646751e-09, 2.660932199557362e+00 }, + { -2.514172388459584e-09, 2.649457043952206e+00 }, + { -2.504942882102813e-09, 2.637843624941622e+00 }, + { -2.495619066062810e-09, 2.626091983472908e+00 }, + { -2.486201291375123e-09, 2.614202167160335e+00 }, + { -2.476689912614465e-09, 2.602174230302269e+00 }, + { -2.467085287878098e-09, 2.590008233889805e+00 }, + { -2.457387778775451e-09, 2.577704245623143e+00 }, + { -2.447597750411553e-09, 2.565262339920002e+00 }, + { -2.437715571376127e-09, 2.552682597931055e+00 }, + { -2.427741613727123e-09, 2.539965107548168e+00 }, + { -2.417676252978335e-09, 2.527109963417675e+00 }, + { -2.407519868085581e-09, 2.514117266951687e+00 }, + { -2.397272841430131e-09, 2.500987126335739e+00 }, + { -2.386935558807595e-09, 2.487719656543254e+00 }, + { -2.376508409410024e-09, 2.474314979341178e+00 }, + { -2.365991785814531e-09, 2.460773223303822e+00 }, + { -2.355386083965131e-09, 2.447094523817833e+00 }, + { -2.344691703161363e-09, 2.433279023095734e+00 }, + { -2.333909046040126e-09, 2.419326870180582e+00 }, + { -2.323038518562289e-09, 2.405238220956597e+00 }, + { -2.312080529997549e-09, 2.391013238157397e+00 }, + { -2.301035492907384e-09, 2.376652091371587e+00 }, + { -2.289903823131822e-09, 2.362154957053137e+00 }, + { -2.278685939771276e-09, 2.347522018525197e+00 }, + { -2.267382265173420e-09, 2.332753465990296e+00 }, + { -2.255993224914501e-09, 2.317849496533128e+00 }, + { -2.244519247786155e-09, 2.302810314130351e+00 }, + { -2.232960765776561e-09, 2.287636129652823e+00 }, + { -2.221318214056095e-09, 2.272327160873552e+00 }, + { -2.209592030960763e-09, 2.256883632472565e+00 }, + { -2.197782657974034e-09, 2.241305776039511e+00 }, + { -2.185890539712767e-09, 2.225593830081461e+00 }, + { -2.173916123907886e-09, 2.209748040023618e+00 }, + { -2.161859861389976e-09, 2.193768658216360e+00 }, + { -2.149722206070124e-09, 2.177655943935795e+00 }, + { -2.137503614923981e-09, 2.161410163388424e+00 }, + { -2.125204547975352e-09, 2.145031589714984e+00 }, + { -2.112825468276292e-09, 2.128520502989477e+00 }, + { -2.100366841892917e-09, 2.111877190225612e+00 }, + { -2.087829137884807e-09, 2.095101945374541e+00 }, + { -2.075212828290086e-09, 2.078195069329960e+00 }, + { -2.062518388104923e-09, 2.061156869925600e+00 }, + { -2.049746295268559e-09, 2.043987661939897e+00 }, + { -2.036897030642658e-09, 2.026687767092888e+00 }, + { -2.023971077994576e-09, 2.009257514048162e+00 }, + { -2.010968923979840e-09, 1.991697238413571e+00 }, + { -1.997891058121344e-09, 1.974007282737320e+00 }, + { -1.984737972794098e-09, 1.956187996511354e+00 }, + { -1.971510163203686e-09, 1.938239736166060e+00 }, + { -1.958208127370276e-09, 1.920162865072273e+00 }, + { -1.944832366107339e-09, 1.901957753535934e+00 }, + { -1.931383383005451e-09, 1.883624778799427e+00 }, + { -1.917861684410531e-09, 1.865164325035177e+00 }, + { -1.904267779407432e-09, 1.846576783346324e+00 }, + { -1.890602179798714e-09, 1.827862551760622e+00 }, + { -1.876865400086483e-09, 1.809022035228338e+00 }, + { -1.863057957452539e-09, 1.790055645617624e+00 }, + { -1.849180371740008e-09, 1.770963801711725e+00 }, + { -1.835233165431475e-09, 1.751746929201178e+00 }, + { -1.821216863631569e-09, 1.732405460681919e+00 }, + { -1.807131994045840e-09, 1.712939835648088e+00 }, + { -1.792979086962494e-09, 1.693350500488565e+00 }, + { -1.778758675229683e-09, 1.673637908477153e+00 }, + { -1.764471294238191e-09, 1.653802519770021e+00 }, + { -1.750117481899733e-09, 1.633844801396848e+00 }, + { -1.735697778626995e-09, 1.613765227254186e+00 }, + { -1.721212727314574e-09, 1.593564278099856e+00 }, + { -1.706662873315474e-09, 1.573242441540939e+00 }, + { -1.692048764423848e-09, 1.552800212030258e+00 }, + { -1.677370950852395e-09, 1.532238090855187e+00 }, + { -1.662629985213192e-09, 1.511556586131055e+00 }, + { -1.647826422494560e-09, 1.490756212788764e+00 }, + { -1.632960820042537e-09, 1.469837492568651e+00 }, + { -1.618033737538645e-09, 1.448800954008929e+00 }, + { -1.603045736978760e-09, 1.427647132435469e+00 }, + { -1.587997382653428e-09, 1.406376569953373e+00 }, + { -1.572889241124034e-09, 1.384989815432507e+00 }, + { -1.557721881203696e-09, 1.363487424499449e+00 }, + { -1.542495873934815e-09, 1.341869959524515e+00 }, + { -1.527211792568486e-09, 1.320137989611176e+00 }, + { -1.511870212541253e-09, 1.298292090581491e+00 }, + { -1.496471711454994e-09, 1.276332844965754e+00 }, + { -1.481016869054634e-09, 1.254260841988828e+00 }, + { -1.465506267206068e-09, 1.232076677556547e+00 }, + { -1.449940489875303e-09, 1.209780954243628e+00 }, + { -1.434320123104372e-09, 1.187374281276747e+00 }, + { -1.418645754991533e-09, 1.164857274523495e+00 }, + { -1.402917975667710e-09, 1.142230556475749e+00 }, + { -1.387137377275425e-09, 1.119494756236361e+00 }, + { -1.371304553944712e-09, 1.096650509501278e+00 }, + { -1.355420101772623e-09, 1.073698458546610e+00 }, + { -1.339484618799891e-09, 1.050639252211352e+00 }, + { -1.323498704988051e-09, 1.027473545880543e+00 }, + { -1.307462962198534e-09, 1.004202001471034e+00 }, + { -1.291377994167204e-09, 9.808252874104182e-01 }, + { -1.275244406484394e-09, 9.573440786237052e-01 }, + { -1.259062806570190e-09, 9.337590565128454e-01 }, + { -1.242833803653464e-09, 9.100709089414796e-01 }, + { -1.226558008746195e-09, 8.862803302125812e-01 }, + { -1.210236034623253e-09, 8.623880210538113e-01 }, + { -1.193868495797618e-09, 8.383946885959868e-01 }, + { -1.177456008497777e-09, 8.143010463544786e-01 }, + { -1.160999190645010e-09, 7.901078142102129e-01 }, + { -1.144498661828833e-09, 7.658157183877095e-01 }, + { -1.127955043284965e-09, 7.414254914366063e-01 }, + { -1.111368957870986e-09, 7.169378722095157e-01 }, + { -1.094741030044308e-09, 6.923536058430697e-01 }, + { -1.078071885836393e-09, 6.676734437331688e-01 }, + { -1.061362152831423e-09, 6.428981435165511e-01 }, + { -1.044612460141255e-09, 6.180284690466404e-01 }, + { -1.027823438382183e-09, 5.930651903718045e-01 }, + { -1.010995719652015e-09, 5.680090837138436e-01 }, + { -9.941299375042378e-10, 5.428609314418970e-01 }, + { -9.772267269262058e-10, 5.176215220520872e-01 }, + { -9.602867243141016e-10, 4.922916501421032e-01 }, + { -9.433105674499058e-10, 4.668721163885412e-01 }, + { -9.262988954758817e-10, 4.413637275202624e-01 }, + { -9.092523488719689e-10, 4.157672962958654e-01 }, + { -8.921715694311144e-10, 3.900836414778084e-01 }, + { -8.750572002347607e-10, 3.643135878065193e-01 }, + { -8.579098856296589e-10, 3.384579659762392e-01 }, + { -8.407302712022458e-10, 3.125176126069478e-01 }, + { -8.235190037551917e-10, 2.864933702193017e-01 }, + { -8.062767312831008e-10, 2.603860872080448e-01 }, + { -7.890041029479477e-10, 2.341966178147619e-01 }, + { -7.717017690542486e-10, 2.079258220999725e-01 }, + { -7.543703810250266e-10, 1.815745659161734e-01 }, + { -7.370105913774597e-10, 1.551437208801425e-01 }, + { -7.196230536974697e-10, 1.286341643433767e-01 }, + { -7.022084226165876e-10, 1.020467793657360e-01 }, + { -6.847673537853251e-10, 7.538245468350446e-02 }, + { -6.673005038502516e-10, 4.864208468284503e-02 }, + { -6.498085304282128e-10, 2.182656936863137e-02 }, + { -6.322920920826137e-10, -5.063185663820913e-03 }, + { -6.147518482969490e-10, -3.202626926150343e-02 }, + { -5.971884594516681e-10, -5.906176474160862e-02 }, + { -5.796025867984469e-10, -8.616874992366363e-02 }, + { -5.619948924353588e-10, -1.133462971605448e-01 }, + { -5.443660392823640e-10, -1.405934733692621e-01 }, + { -5.267166910556339e-10, -1.679093400638023e-01 }, + { -5.090475122431451e-10, -1.952929533862739e-01 }, + { -4.913591680795342e-10, -2.227433641394564e-01 }, + { -4.736523245210571e-10, -2.502596178194491e-01 }, + { -4.559276482202303e-10, -2.778407546490776e-01 }, + { -4.381858065011618e-10, -3.054858096104932e-01 }, + { -4.204274673340870e-10, -3.331938124792702e-01 }, + { -4.026532993105397e-10, -3.609637878577768e-01 }, + { -3.848639716178888e-10, -3.887947552098022e-01 }, + { -3.670601540142443e-10, -4.166857288948674e-01 }, + { -3.492425168032583e-10, -4.446357182029681e-01 }, + { -3.314117308088734e-10, -4.726437273896633e-01 }, + { -3.135684673501752e-10, -5.007087557112619e-01 }, + { -2.957133982159296e-10, -5.288297974607742e-01 }, + { -2.778471956393828e-10, -5.570058420037128e-01 }, + { -2.599705322729564e-10, -5.852358738143247e-01 }, + { -2.420840811628366e-10, -6.135188725122560e-01 }, + { -2.241885157240923e-10, -6.418538128986450e-01 }, + { -2.062845097142585e-10, -6.702396649949099e-01 }, + { -1.883727372093546e-10, -6.986753940779493e-01 }, + { -1.704538725773087e-10, -7.271599607197149e-01 }, + { -1.525285904532877e-10, -7.556923208240308e-01 }, + { -1.345975657140748e-10, -7.842714256651911e-01 }, + { -1.166614734526054e-10, -8.128962219265712e-01 }, + { -9.872098895260891e-11, -8.415656517393372e-01 }, + { -8.077678766314517e-11, -8.702786527215916e-01 }, + { -6.282954517324612e-11, -8.990341580176152e-01 }, + { -4.487993718655790e-11, -9.278310963373758e-01 }, + { -2.692863949561210e-11, -9.566683919968972e-01 }, + { -8.976327956520795e-12, -9.855449649582175e-01 }, + { 8.976321536169872e-12, -1.014459730869357e+00 }, + { 2.692863307547294e-11, -1.043411601105914e+00 }, + { 4.487993076694813e-11, -1.072399482811314e+00 }, + { 6.282953875437751e-11, -1.101422278938424e+00 }, + { 8.077678124517653e-11, -1.130478888291020e+00 }, + { 9.872098253591082e-11, -1.159568205565684e+00 }, + { 1.166614670373367e-10, -1.188689121393192e+00 }, + { 1.345975593005002e-10, -1.217840522381901e+00 }, + { 1.525285840416718e-10, -1.247021291159495e+00 }, + { 1.704538661678104e-10, -1.276230306415868e+00 }, + { 1.883727308022916e-10, -1.305466442946703e+00 }, + { 2.062845033098954e-10, -1.334728571696106e+00 }, + { 2.241885093225349e-10, -1.364015559800721e+00 }, + { 2.420840747645085e-10, -1.393326270633325e+00 }, + { 2.599705258779635e-10, -1.422659563847049e+00 }, + { 2.778471892479898e-10, -1.452014295419243e+00 }, + { 2.957133918284542e-10, -1.481389317696831e+00 }, + { 3.135684609667761e-10, -1.510783479440191e+00 }, + { 3.314117244297624e-10, -1.540195625869043e+00 }, + { 3.492425104288060e-10, -1.569624598707558e+00 }, + { 3.670601476445565e-10, -1.599069236228850e+00 }, + { 3.848639652533361e-10, -1.628528373302631e+00 }, + { 4.026532929512281e-10, -1.658000841439269e+00 }, + { 4.204274609803869e-10, -1.687485468837799e+00 }, + { 4.381858001531792e-10, -1.716981080430596e+00 }, + { 4.559276418782829e-10, -1.746486497931567e+00 }, + { 4.736523181853565e-10, -1.776000539882225e+00 }, + { 4.913591617503452e-10, -1.805522021699094e+00 }, + { 5.090475059206794e-10, -1.835049755721194e+00 }, + { 5.267166847401562e-10, -1.864582551257262e+00 }, + { 5.443660329740862e-10, -1.894119214633676e+00 }, + { 5.619948861345454e-10, -1.923658549242818e+00 }, + { 5.796025805053097e-10, -1.953199355591180e+00 }, + { 5.971884531664190e-10, -1.982740431347091e+00 }, + { 6.147518420199055e-10, -2.012280571390674e+00 }, + { 6.322920858139346e-10, -2.041818567861395e+00 }, + { 6.498085241682158e-10, -2.071353210208005e+00 }, + { 6.673004975990425e-10, -2.100883285238127e+00 }, + { 6.847673475432746e-10, -2.130407577166309e+00 }, + { 7.022084163838545e-10, -2.159924867664933e+00 }, + { 7.196230474743716e-10, -2.189433935913779e+00 }, + { 7.370105851640495e-10, -2.218933558650552e+00 }, + { 7.543703748217808e-10, -2.248422510220072e+00 }, + { 7.717017628611672e-10, -2.277899562625407e+00 }, + { 7.890040967654542e-10, -2.307363485579104e+00 }, + { 8.062767251113011e-10, -2.336813046552684e+00 }, + { 8.235189975944034e-10, -2.366247010829556e+00 }, + { 8.407302650525749e-10, -2.395664141553858e+00 }, + { 8.579098794915287e-10, -2.425063199784153e+00 }, + { 8.750571941082773e-10, -2.454442944543319e+00 }, + { 8.921715633164894e-10, -2.483802132872044e+00 }, + { 9.092523427695200e-10, -2.513139519878584e+00 }, + { 9.262988893857148e-10, -2.542453858792682e+00 }, + { 9.433105613723914e-10, -2.571743901017465e+00 }, + { 9.602867182493987e-10, -2.601008396180870e+00 }, + { 9.772267208744730e-10, -2.630246092190425e+00 }, + { 9.941299314658458e-10, -2.659455735283526e+00 }, + { 1.010995713627070e-09, -2.688636070081818e+00 }, + { 1.027823432371055e-09, -2.717785839644439e+00 }, + { 1.044612454143997e-09, -2.746903785521352e+00 }, + { 1.061362146848353e-09, -2.775988647805256e+00 }, + { 1.078071879867828e-09, -2.805039165187255e+00 }, + { 1.094741024090249e-09, -2.834054075009077e+00 }, + { 1.111368951931856e-09, -2.863032113318052e+00 }, + { 1.127955037360817e-09, -2.891972014920939e+00 }, + { 1.144498655920037e-09, -2.920872513436805e+00 }, + { 1.160999184751779e-09, -2.949732341353290e+00 }, + { 1.177456002620215e-09, -2.978550230079517e+00 }, + { 1.193868489936097e-09, -3.007324910002949e+00 }, + { 1.210236028777826e-09, -3.036055110540183e+00 }, + { 1.226558002917232e-09, -3.064739560196251e+00 }, + { 1.242833797841123e-09, -3.093376986616735e+00 }, + { 1.259062800774685e-09, -3.121966116643377e+00 }, + { 1.275244400705935e-09, -3.150505676371791e+00 }, + { 1.291377988406056e-09, -3.178994391202159e+00 }, + { 1.307462956454857e-09, -3.207430985899192e+00 }, + { 1.323498699262108e-09, -3.235814184645077e+00 }, + { 1.339484613091842e-09, -3.264142711097884e+00 }, + { 1.355420096082785e-09, -3.292415288443373e+00 }, + { 1.371304548273191e-09, -3.320630639454825e+00 }, + { 1.387137371622433e-09, -3.348787486547389e+00 }, + { 1.402917970033511e-09, -3.376884551834256e+00 }, + { 1.418645749376393e-09, -3.404920557184582e+00 }, + { 1.434320117508396e-09, -3.432894224276359e+00 }, + { 1.449940484298756e-09, -3.460804274656981e+00 }, + { 1.465506261649108e-09, -3.488649429796768e+00 }, + { 1.481016863517580e-09, -3.516428411149154e+00 }, + { 1.496471705937951e-09, -3.544139940202303e+00 }, + { 1.511870207044433e-09, -3.571782738540999e+00 }, + { 1.527211787092206e-09, -3.599355527901174e+00 }, + { 1.542495868479076e-09, -3.626857030226671e+00 }, + { 1.557721875768920e-09, -3.654285967729458e+00 }, + { 1.572889235710329e-09, -3.681641062941412e+00 }, + { 1.587997377261005e-09, -3.708921038776707e+00 }, + { 1.603045731607830e-09, -3.736124618586623e+00 }, + { 1.618033732189314e-09, -3.763250526218862e+00 }, + { 1.632960814715177e-09, -3.790297486071938e+00 }, + { 1.647826417189275e-09, -3.817264223155802e+00 }, + { 1.662629979930247e-09, -3.844149463148589e+00 }, + { 1.677370945591844e-09, -3.870951932452996e+00 }, + { 1.692048759186008e-09, -3.897670358257890e+00 }, + { 1.706662868100504e-09, -3.924303468590212e+00 }, + { 1.721212722122685e-09, -3.950849992378278e+00 }, + { 1.735697773458400e-09, -3.977308659506432e+00 }, + { 1.750117476754591e-09, -4.003678200876669e+00 }, + { 1.764471289116712e-09, -4.029957348461003e+00 }, + { 1.778758670132079e-09, -4.056144835364877e+00 }, + { 1.792979081888926e-09, -4.082239395882965e+00 }, + { 1.807131988996465e-09, -4.108239765556996e+00 }, + { 1.821216858606652e-09, -4.134144681236933e+00 }, + { 1.835233160431175e-09, -4.159952881133585e+00 }, + { 1.849180366764537e-09, -4.185663104882633e+00 }, + { 1.863057952502055e-09, -4.211274093599509e+00 }, + { 1.876865395161145e-09, -4.236784589940537e+00 }, + { 1.890602174898734e-09, -4.262193338157148e+00 }, + { 1.904267774533022e-09, -4.287499084158302e+00 }, + { 1.917861679562008e-09, -4.312700575567174e+00 }, + { 1.931383378182392e-09, -4.337796561778708e+00 }, + { 1.944832361310856e-09, -4.362785794021793e+00 }, + { 1.958208122599839e-09, -4.387667025411434e+00 }, + { 1.971510158459931e-09, -4.412439011013396e+00 }, + { 1.984737968076495e-09, -4.437100507898339e+00 }, + { 1.997891053431005e-09, -4.461650275204912e+00 }, + { 2.010968919316289e-09, -4.486087074191693e+00 }, + { 2.023971073358447e-09, -4.510409668301784e+00 }, + { 2.036897026033634e-09, -4.534616823217992e+00 }, + { 2.049746290686799e-09, -4.558707306921882e+00 }, + { 2.062518383551274e-09, -4.582679889754607e+00 }, + { 2.075212823764071e-09, -4.606533344469879e+00 }, + { 2.087829133387063e-09, -4.630266446298172e+00 }, + { 2.100366837422912e-09, -4.653877973001258e+00 }, + { 2.112825463835087e-09, -4.677366704934605e+00 }, + { 2.125204543562522e-09, -4.700731425099899e+00 }, + { 2.137503610540056e-09, -4.723970919208608e+00 }, + { 2.149722201714786e-09, -4.747083975738060e+00 }, + { 2.161859857063438e-09, -4.770069385989595e+00 }, + { 2.173916119610994e-09, -4.792925944149308e+00 }, + { 2.185890535445098e-09, -4.815652447340950e+00 }, + { 2.197782653735957e-09, -4.838247695689436e+00 }, + { 2.209592026751962e-09, -4.860710492376411e+00 }, + { 2.221318209877576e-09, -4.883039643700314e+00 }, + { 2.232960761627846e-09, -4.905233959130168e+00 }, + { 2.244519243667616e-09, -4.927292251368517e+00 }, + { 2.255993220826402e-09, -4.949213336406265e+00 }, + { 2.267382261115285e-09, -4.970996033581527e+00 }, + { 2.278685935744269e-09, -4.992639165639563e+00 }, + { 2.289903819135414e-09, -5.014141558784778e+00 }, + { 2.301035488942000e-09, -5.035502042744443e+00 }, + { 2.312080526062763e-09, -5.056719450823151e+00 }, + { 2.323038514659161e-09, -5.077792619963239e+00 }, + { 2.333909042168180e-09, -5.098720390796817e+00 }, + { 2.344691699320969e-09, -5.119501607709159e+00 }, + { 2.355386080156553e-09, -5.140135118892792e+00 }, + { 2.365991782037187e-09, -5.160619776404897e+00 }, + { 2.376508405665132e-09, -5.180954436227641e+00 }, + { 2.386935555094626e-09, -5.201137958319343e+00 }, + { 2.397272837749508e-09, -5.221169206676762e+00 }, + { 2.407519864436774e-09, -5.241047049389645e+00 }, + { 2.417676249362563e-09, -5.260770358700167e+00 }, + { 2.427741610143750e-09, -5.280338011053974e+00 }, + { 2.437715567825576e-09, -5.299748887163106e+00 }, + { 2.447597746894037e-09, -5.319001872058887e+00 }, + { 2.457387775290440e-09, -5.338095855149190e+00 }, + { 2.467085284426756e-09, -5.357029730277389e+00 }, + { 2.476689909196263e-09, -5.375802395772283e+00 }, + { 2.486201287990485e-09, -5.394412754510426e+00 }, + { 2.495619062711154e-09, -5.412859713968929e+00 }, + { 2.504942878785408e-09, -5.431142186284682e+00 }, + { 2.514172385175743e-09, -5.449259088303476e+00 }, + { 2.523307234396791e-09, -5.467209341642627e+00 }, + { 2.532347082526785e-09, -5.484991872743321e+00 }, + { 2.541291589219998e-09, -5.502605612925014e+00 }, + { 2.550140417722072e-09, -5.520049498445633e+00 }, + { 2.558893234878378e-09, -5.537322470548212e+00 }, + { 2.567549711150773e-09, -5.554423475524196e+00 }, + { 2.576109520627371e-09, -5.571351464763084e+00 }, + { 2.584572341037361e-09, -5.588105394812198e+00 }, + { 2.592937853759161e-09, -5.604684227423386e+00 }, + { 2.601205743836355e-09, -5.621086929615246e+00 }, + { 2.609375699987564e-09, -5.637312473723475e+00 }, + { 2.617447414618146e-09, -5.653359837454964e+00 }, + { 2.625420583833750e-09, -5.669228003945694e+00 }, + { 2.633294907447937e-09, -5.684915961806963e+00 }, + { 2.641070088997271e-09, -5.700422705186584e+00 }, + { 2.648745835750128e-09, -5.715747233817712e+00 }, + { 2.656321858720176e-09, -5.730888553077074e+00 }, + { 2.663797872673252e-09, -5.745845674030161e+00 }, + { 2.671173596142054e-09, -5.760617613492118e+00 }, + { 2.678448751434797e-09, -5.775203394076705e+00 }, + { 2.685623064645538e-09, -5.789602044248679e+00 }, + { 2.692696265666640e-09, -5.803812598380606e+00 }, + { 2.699668088194915e-09, -5.817834096797069e+00 }, + { 2.706538269745573e-09, -5.831665585834668e+00 }, + { 2.713306551659817e-09, -5.845306117889361e+00 }, + { 2.719972679116734e-09, -5.858754751472542e+00 }, + { 2.726536401139295e-09, -5.872010551255358e+00 }, + { 2.732997470607439e-09, -5.885072588127400e+00 }, + { 2.739355644265558e-09, -5.897939939244211e+00 }, + { 2.745610682731633e-09, -5.910611688078208e+00 }, + { 2.751762350508137e-09, -5.923086924473290e+00 }, + { 2.757810415987146e-09, -5.935364744687794e+00 }, + { 2.763754651462700e-09, -5.947444251452243e+00 }, + { 2.769594833137415e-09, -5.959324554015538e+00 }, + { 2.775330741132843e-09, -5.971004768198829e+00 }, + { 2.780962159494174e-09, -5.982484016437981e+00 }, + { 2.786488876202047e-09, -5.993761427840588e+00 }, + { 2.791910683178690e-09, -6.004836138231525e+00 }, + { 2.797227376295779e-09, -6.015707290202086e+00 }, + { 2.802438755383971e-09, -6.026374033162623e+00 }, + { 2.807544624236659e-09, -6.036835523383457e+00 }, + { 2.812544790621093e-09, -6.047090924050914e+00 }, + { 2.817439066283459e-09, -6.057139405311101e+00 }, + { 2.822227266958278e-09, -6.066980144322601e+00 }, + { 2.826909212371261e-09, -6.076612325295799e+00 }, + { 2.831484726250221e-09, -6.086035139548830e+00 }, + { 2.835953636329660e-09, -6.095247785550617e+00 }, + { 2.840315774357203e-09, -6.104249468967751e+00 }, + { 2.844570976102082e-09, -6.113039402715685e+00 }, + { 2.848719081357095e-09, -6.121616806996519e+00 }, + { 2.852759933948860e-09, -6.129980909353977e+00 }, + { 2.856693381741114e-09, -6.138130944714082e+00 }, + { 2.860519276643053e-09, -6.146066155436312e+00 }, + { 2.864237474610633e-09, -6.153785791350256e+00 }, + { 2.867847835656203e-09, -6.161289109809551e+00 }, + { 2.871350223851726e-09, -6.168575375732642e+00 }, + { 2.874744507333867e-09, -6.175643861647406e+00 }, + { 2.878030558310989e-09, -6.182493847739853e+00 }, + { 2.881208253063899e-09, -6.189124621889823e+00 }, + { 2.884277471954592e-09, -6.195535479723423e+00 }, + { 2.887238099428306e-09, -6.201725724651554e+00 }, + { 2.890090024020323e-09, -6.207694667918394e+00 }, + { 2.892833138356060e-09, -6.213441628635915e+00 }, + { 2.895467339159240e-09, -6.218965933835304e+00 }, + { 2.897992527253659e-09, -6.224266918505075e+00 }, + { 2.900408607567016e-09, -6.229343925633495e+00 }, + { 2.902715489136496e-09, -6.234196306254763e+00 }, + { 2.904913085108075e-09, -6.238823419482017e+00 }, + { 2.907001312743911e-09, -6.243224632557377e+00 }, + { 2.908980093422997e-09, -6.247399320887848e+00 }, + { 2.910849352646620e-09, -6.251346868091392e+00 }, + { 2.912609020036956e-09, -6.255066666028537e+00 }, + { 2.914259029343965e-09, -6.258558114851525e+00 }, + { 2.915799318445710e-09, -6.261820623039620e+00 }, + { 2.917229829350759e-09, -6.264853607438842e+00 }, + { 2.918550508202463e-09, -6.267656493305673e+00 }, + { 2.919761305276718e-09, -6.270228714337005e+00 }, + { 2.920862174988150e-09, -6.272569712717951e+00 }, + { 2.921853075889193e-09, -6.274678939154603e+00 }, + { 2.922733970674264e-09, -6.276555852917634e+00 }, + { 2.923504826176907e-09, -6.278199921870962e+00 }, + { 2.924165613375264e-09, -6.279610622518139e+00 }, + { 2.924716307391075e-09, -6.280787440034993e+00 }, + { 2.925156887490598e-09, -6.281729868306345e+00 }, + { 2.925487337087508e-09, -6.282437409966992e+00 }, + { 2.925707643739298e-09, -6.282909576428774e+00 }, + { 2.925817799151970e-09, -6.283145887925411e+00 }, diff --git a/gnuradio-runtime/lib/math/vco.h b/gnuradio-runtime/lib/math/vco.h index 7ac1e1ca6d..1687de6af7 100644 --- a/gnuradio-runtime/lib/math/vco.h +++ b/gnuradio-runtime/lib/math/vco.h @@ -32,83 +32,85 @@ namespace gr { - /*! - * \brief base class template for Voltage Controlled Oscillator (VCO) - * \ingroup misc - */ - template<class o_type, class i_type> - class vco - { - public: +/*! + * \brief base class template for Voltage Controlled Oscillator (VCO) + * \ingroup misc + */ +template <class o_type, class i_type> +class vco +{ +public: vco() : d_phase(0) {} virtual ~vco() {} // radians - void set_phase(double angle) { - d_phase = angle; - } + void set_phase(double angle) { d_phase = angle; } - void adjust_phase(double delta_phase) { - d_phase += delta_phase; - if(fabs (d_phase) > GR_M_PI){ + void adjust_phase(double delta_phase) + { + d_phase += delta_phase; + if (fabs(d_phase) > GR_M_PI) { - while(d_phase > GR_M_PI) - d_phase -= 2*GR_M_PI; + while (d_phase > GR_M_PI) + d_phase -= 2 * GR_M_PI; - while(d_phase < -GR_M_PI) - d_phase += 2*GR_M_PI; - } + while (d_phase < -GR_M_PI) + d_phase += 2 * GR_M_PI; + } } double get_phase() const { return d_phase; } // compute sin and cos for current phase angle - void sincos(float *sinx, float *cosx) const; + void sincos(float* sinx, float* cosx) const; - void sincos(gr_complex *output, const float *input, - int noutput_items, double k, double ampl = 1.0); + void sincos(gr_complex* output, + const float* input, + int noutput_items, + double k, + double ampl = 1.0); // compute cos or sin for current phase angle float cos() const { return std::cos(d_phase); } float sin() const { return std::sin(d_phase); } // compute a block at a time - void cos(float *output, const float *input, - int noutput_items, double k, double ampl = 1.0); + void cos(float* output, + const float* input, + int noutput_items, + double k, + double ampl = 1.0); - protected: +protected: double d_phase; - }; +}; - template<class o_type, class i_type> - void - vco<o_type,i_type>::sincos(float *sinx, float *cosx) const - { +template <class o_type, class i_type> +void vco<o_type, i_type>::sincos(float* sinx, float* cosx) const +{ gr::sincosf(d_phase, sinx, cosx); - } - - template<class o_type, class i_type> - void - vco<o_type,i_type>::sincos(gr_complex *output, const float *input, - int noutput_items, double k, double ampl) - { - for(int i = 0; i < noutput_items; i++) { - output[i] = gr_complex(cos() * ampl, sin() * ampl); - adjust_phase(input[i] * k); +} + +template <class o_type, class i_type> +void vco<o_type, i_type>::sincos( + gr_complex* output, const float* input, int noutput_items, double k, double ampl) +{ + for (int i = 0; i < noutput_items; i++) { + output[i] = gr_complex(cos() * ampl, sin() * ampl); + adjust_phase(input[i] * k); } - } - - template<class o_type, class i_type> - void - vco<o_type,i_type>::cos(float *output, const float *input, - int noutput_items, double k, double ampl) - { - for(int i = 0; i < noutput_items; i++) { - output[i] = cos() * ampl; - adjust_phase(input[i] * k); +} + +template <class o_type, class i_type> +void vco<o_type, i_type>::cos( + float* output, const float* input, int noutput_items, double k, double ampl) +{ + for (int i = 0; i < noutput_items; i++) { + output[i] = cos() * ampl; + adjust_phase(input[i] * k); } - } +} } /* namespace gr */ diff --git a/gnuradio-runtime/lib/message.cc b/gnuradio-runtime/lib/message.cc index ac066d668e..9872caf61d 100644 --- a/gnuradio-runtime/lib/message.cc +++ b/gnuradio-runtime/lib/message.cc @@ -30,53 +30,47 @@ namespace gr { - static long s_ncurrently_allocated = 0; +static long s_ncurrently_allocated = 0; - message::sptr - message::make(long type, double arg1, double arg2, size_t length) - { +message::sptr message::make(long type, double arg1, double arg2, size_t length) +{ return message::sptr(new message(type, arg1, arg2, length)); - } +} - message::sptr - message::make_from_string(const std::string s, long type, double arg1, double arg2) - { +message::sptr +message::make_from_string(const std::string s, long type, double arg1, double arg2) +{ message::sptr m = message::make(type, arg1, arg2, s.size()); memcpy(m->msg(), s.data(), s.size()); return m; - } +} - message::message(long type, double arg1, double arg2, size_t length) +message::message(long type, double arg1, double arg2, size_t length) : d_type(type), d_arg1(arg1), d_arg2(arg2) - { - if(length == 0) - d_buf_start = d_msg_start = d_msg_end = d_buf_end = 0; +{ + if (length == 0) + d_buf_start = d_msg_start = d_msg_end = d_buf_end = 0; else { - d_buf_start = new unsigned char[length]; - d_msg_start = d_buf_start; - d_msg_end = d_buf_end = d_buf_start + length; + d_buf_start = new unsigned char[length]; + d_msg_start = d_buf_start; + d_msg_end = d_buf_end = d_buf_start + length; } s_ncurrently_allocated++; - } +} - message::~message() - { - assert (d_next == 0); - delete [] d_buf_start; +message::~message() +{ + assert(d_next == 0); + delete[] d_buf_start; d_msg_start = d_msg_end = d_buf_end = 0; s_ncurrently_allocated--; - } +} - std::string - message::to_string() const - { - return std::string((char *)d_msg_start, length()); - } +std::string message::to_string() const +{ + return std::string((char*)d_msg_start, length()); +} - long - message_ncurrently_allocated() - { - return s_ncurrently_allocated; - } +long message_ncurrently_allocated() { return s_ncurrently_allocated; } } /* namespace gr */ diff --git a/gnuradio-runtime/lib/messages/msg_accepter.cc b/gnuradio-runtime/lib/messages/msg_accepter.cc index cc86a6ff8a..f6a0d957aa 100644 --- a/gnuradio-runtime/lib/messages/msg_accepter.cc +++ b/gnuradio-runtime/lib/messages/msg_accepter.cc @@ -27,12 +27,12 @@ #include <gnuradio/messages/msg_accepter.h> namespace gr { - namespace messages { +namespace messages { - msg_accepter::~msg_accepter() - { - // NOP, required as virtual destructor - } +msg_accepter::~msg_accepter() +{ + // NOP, required as virtual destructor +} - } /* namespace messages */ +} /* namespace messages */ } /* namespace gr */ diff --git a/gnuradio-runtime/lib/messages/msg_accepter_msgq.cc b/gnuradio-runtime/lib/messages/msg_accepter_msgq.cc index 7ee6ea02c1..b2db5105d5 100644 --- a/gnuradio-runtime/lib/messages/msg_accepter_msgq.cc +++ b/gnuradio-runtime/lib/messages/msg_accepter_msgq.cc @@ -26,23 +26,16 @@ #include <gnuradio/messages/msg_accepter_msgq.h> namespace gr { - namespace messages { +namespace messages { - msg_accepter_msgq::msg_accepter_msgq(msg_queue_sptr msgq) - : d_msg_queue(msgq) - { - } +msg_accepter_msgq::msg_accepter_msgq(msg_queue_sptr msgq) : d_msg_queue(msgq) {} - msg_accepter_msgq::~msg_accepter_msgq() - { - // NOP, required as virtual destructor - } +msg_accepter_msgq::~msg_accepter_msgq() +{ + // NOP, required as virtual destructor +} - void - msg_accepter_msgq::post(pmt::pmt_t msg) - { - d_msg_queue->insert_tail(msg); - } +void msg_accepter_msgq::post(pmt::pmt_t msg) { d_msg_queue->insert_tail(msg); } - } /* namespace messages */ +} /* namespace messages */ } /* namespace gr */ diff --git a/gnuradio-runtime/lib/messages/msg_producer.cc b/gnuradio-runtime/lib/messages/msg_producer.cc index 3f56bc6637..19ced499b0 100644 --- a/gnuradio-runtime/lib/messages/msg_producer.cc +++ b/gnuradio-runtime/lib/messages/msg_producer.cc @@ -27,12 +27,12 @@ #include <gnuradio/messages/msg_producer.h> namespace gr { - namespace messages { +namespace messages { - msg_producer::~msg_producer() - { - // NOP, required as virtual destructor - } +msg_producer::~msg_producer() +{ + // NOP, required as virtual destructor +} - } /* namespace messages */ +} /* namespace messages */ } /* namespace gr */ diff --git a/gnuradio-runtime/lib/messages/msg_queue.cc b/gnuradio-runtime/lib/messages/msg_queue.cc index 321b229358..6476ddc4ee 100644 --- a/gnuradio-runtime/lib/messages/msg_queue.cc +++ b/gnuradio-runtime/lib/messages/msg_queue.cc @@ -28,76 +28,65 @@ #include <stdexcept> namespace gr { - namespace messages { - - msg_queue_sptr - make_msg_queue(unsigned int limit) - { - return msg_queue_sptr(new msg_queue(limit)); - } - - msg_queue::msg_queue(unsigned int limit) - : d_limit(limit) - { - } - - msg_queue::~msg_queue() - { - flush(); - } - - void - msg_queue::insert_tail(pmt::pmt_t msg) - { - gr::thread::scoped_lock guard(d_mutex); - - while(full_p()) +namespace messages { + +msg_queue_sptr make_msg_queue(unsigned int limit) +{ + return msg_queue_sptr(new msg_queue(limit)); +} + +msg_queue::msg_queue(unsigned int limit) : d_limit(limit) {} + +msg_queue::~msg_queue() { flush(); } + +void msg_queue::insert_tail(pmt::pmt_t msg) +{ + gr::thread::scoped_lock guard(d_mutex); + + while (full_p()) d_not_full.wait(guard); - d_msgs.push_back(msg); - d_not_empty.notify_one(); - } + d_msgs.push_back(msg); + d_not_empty.notify_one(); +} - pmt::pmt_t - msg_queue::delete_head() - { - gr::thread::scoped_lock guard(d_mutex); +pmt::pmt_t msg_queue::delete_head() +{ + gr::thread::scoped_lock guard(d_mutex); - while(empty_p()) + while (empty_p()) d_not_empty.wait(guard); - pmt::pmt_t m(d_msgs.front()); - d_msgs.pop_front(); + pmt::pmt_t m(d_msgs.front()); + d_msgs.pop_front(); - if(d_limit > 0) // Unlimited length queues never block on write + if (d_limit > 0) // Unlimited length queues never block on write d_not_full.notify_one(); - return m; - } + return m; +} - pmt::pmt_t - msg_queue::delete_head_nowait() - { - gr::thread::scoped_lock guard(d_mutex); +pmt::pmt_t msg_queue::delete_head_nowait() +{ + gr::thread::scoped_lock guard(d_mutex); - if(empty_p()) + if (empty_p()) return pmt::pmt_t(); - pmt::pmt_t m(d_msgs.front()); - d_msgs.pop_front(); + pmt::pmt_t m(d_msgs.front()); + d_msgs.pop_front(); - if(d_limit > 0) // Unlimited length queues never block on write + if (d_limit > 0) // Unlimited length queues never block on write d_not_full.notify_one(); - return m; - } + return m; +} - void - msg_queue::flush() - { - while(delete_head_nowait() != pmt::pmt_t()) +void msg_queue::flush() +{ + while (delete_head_nowait() != pmt::pmt_t()) ; - } +} - } /* namespace messages */ +} /* namespace messages */ } /* namespace gr */ diff --git a/gnuradio-runtime/lib/misc.cc b/gnuradio-runtime/lib/misc.cc index f9ad6ca89c..22c9fbed99 100644 --- a/gnuradio-runtime/lib/misc.cc +++ b/gnuradio-runtime/lib/misc.cc @@ -28,43 +28,38 @@ namespace gr { - unsigned int - rounduppow2(unsigned int n) - { +unsigned int rounduppow2(unsigned int n) +{ int i; - for(i=0;((n-1)>>i) != 0;i++) - ; - return 1<<i; - } + for (i = 0; ((n - 1) >> i) != 0; i++) + ; + return 1 << i; +} - // ---------------------------------------------------------------- +// ---------------------------------------------------------------- - void - zero_vector(std::vector<float> &v) - { - for(unsigned int i=0; i < v.size(); i++) - v[i] = 0; - } +void zero_vector(std::vector<float>& v) +{ + for (unsigned int i = 0; i < v.size(); i++) + v[i] = 0; +} - void - zero_vector(std::vector<double> &v) - { - for(unsigned int i=0; i < v.size(); i++) - v[i] = 0; - } +void zero_vector(std::vector<double>& v) +{ + for (unsigned int i = 0; i < v.size(); i++) + v[i] = 0; +} - void - zero_vector(std::vector<int> &v) - { - for(unsigned int i=0; i < v.size(); i++) - v[i] = 0; - } +void zero_vector(std::vector<int>& v) +{ + for (unsigned int i = 0; i < v.size(); i++) + v[i] = 0; +} - void - zero_vector(std::vector<gr_complex> &v) - { - for(unsigned int i=0; i < v.size(); i++) - v[i] = 0; - } +void zero_vector(std::vector<gr_complex>& v) +{ + for (unsigned int i = 0; i < v.size(); i++) + v[i] = 0; +} } /* namespace gr */ diff --git a/gnuradio-runtime/lib/misc.h b/gnuradio-runtime/lib/misc.h index 833b6470a5..0d2df38138 100644 --- a/gnuradio-runtime/lib/misc.h +++ b/gnuradio-runtime/lib/misc.h @@ -28,14 +28,13 @@ namespace gr { - GR_RUNTIME_API unsigned int - rounduppow2(unsigned int n); +GR_RUNTIME_API unsigned int rounduppow2(unsigned int n); - // FIXME should be template - GR_RUNTIME_API void zero_vector(std::vector<float> &v); - GR_RUNTIME_API void zero_vector(std::vector<double> &v); - GR_RUNTIME_API void zero_vector(std::vector<int> &v); - GR_RUNTIME_API void zero_vector(std::vector<gr_complex> &v); +// FIXME should be template +GR_RUNTIME_API void zero_vector(std::vector<float>& v); +GR_RUNTIME_API void zero_vector(std::vector<double>& v); +GR_RUNTIME_API void zero_vector(std::vector<int>& v); +GR_RUNTIME_API void zero_vector(std::vector<gr_complex>& v); } /* namespace gr */ diff --git a/gnuradio-runtime/lib/msg_accepter.cc b/gnuradio-runtime/lib/msg_accepter.cc index 354fce0c3d..77870ad498 100644 --- a/gnuradio-runtime/lib/msg_accepter.cc +++ b/gnuradio-runtime/lib/msg_accepter.cc @@ -31,32 +31,29 @@ namespace gr { - msg_accepter::msg_accepter() - { - } +msg_accepter::msg_accepter() {} - msg_accepter::~msg_accepter() - { +msg_accepter::~msg_accepter() +{ // NOP, required as virtual destructor - } +} - void - msg_accepter::post(pmt::pmt_t which_port, pmt::pmt_t msg) - { +void msg_accepter::post(pmt::pmt_t which_port, pmt::pmt_t msg) +{ // Notify derived class, handled case by case - block *p = dynamic_cast<block *>(this); - if(p) { - p->_post(which_port, msg); - return; + block* p = dynamic_cast<block*>(this); + if (p) { + p->_post(which_port, msg); + return; } - hier_block2 *p2 = dynamic_cast<hier_block2 *>(this); - if(p2) { - // FIXME do the right thing - return; + hier_block2* p2 = dynamic_cast<hier_block2*>(this); + if (p2) { + // FIXME do the right thing + return; } throw std::runtime_error("unknown derived class"); - } +} } /* namespace gr */ diff --git a/gnuradio-runtime/lib/msg_handler.cc b/gnuradio-runtime/lib/msg_handler.cc index f23b424e1a..9f6e382609 100644 --- a/gnuradio-runtime/lib/msg_handler.cc +++ b/gnuradio-runtime/lib/msg_handler.cc @@ -28,8 +28,6 @@ namespace gr { - msg_handler::~msg_handler() - { - } +msg_handler::~msg_handler() {} } /* namespace gr */ diff --git a/gnuradio-runtime/lib/msg_queue.cc b/gnuradio-runtime/lib/msg_queue.cc index 9961f76296..8ae4601309 100644 --- a/gnuradio-runtime/lib/msg_queue.cc +++ b/gnuradio-runtime/lib/msg_queue.cc @@ -29,62 +29,57 @@ namespace gr { - msg_queue::sptr - msg_queue::make(unsigned int limit) - { +msg_queue::sptr msg_queue::make(unsigned int limit) +{ return msg_queue::sptr(new msg_queue(limit)); - } +} - msg_queue::msg_queue(unsigned int limit) - : d_not_empty(), d_not_full(), - /*d_head(0), d_tail(0),*/ d_count(0), d_limit(limit) - { - } +msg_queue::msg_queue(unsigned int limit) + : d_not_empty(), + d_not_full(), + /*d_head(0), d_tail(0),*/ d_count(0), + d_limit(limit) +{ +} - msg_queue::~msg_queue() - { - flush (); - } +msg_queue::~msg_queue() { flush(); } - void - msg_queue::insert_tail(message::sptr msg) - { - if(msg->d_next) - throw std::invalid_argument("gr::msg_queue::insert_tail: msg already in queue"); +void msg_queue::insert_tail(message::sptr msg) +{ + if (msg->d_next) + throw std::invalid_argument("gr::msg_queue::insert_tail: msg already in queue"); gr::thread::scoped_lock guard(d_mutex); - while(full_p()) - d_not_full.wait(guard); - - if(d_tail == 0) { - d_tail = d_head = msg; - //msg->d_next = 0; - msg->d_next.reset(); - } - else { - d_tail->d_next = msg; - d_tail = msg; - //msg->d_next = 0; - msg->d_next.reset(); + while (full_p()) + d_not_full.wait(guard); + + if (d_tail == 0) { + d_tail = d_head = msg; + // msg->d_next = 0; + msg->d_next.reset(); + } else { + d_tail->d_next = msg; + d_tail = msg; + // msg->d_next = 0; + msg->d_next.reset(); } d_count++; d_not_empty.notify_one(); - } +} - message::sptr - msg_queue::delete_head() - { +message::sptr msg_queue::delete_head() +{ gr::thread::scoped_lock guard(d_mutex); message::sptr m; - while((m = d_head) == 0) - d_not_empty.wait(guard); + while ((m = d_head) == 0) + d_not_empty.wait(guard); d_head = m->d_next; - if(d_head == 0){ - //d_tail = 0; - d_tail.reset(); + if (d_head == 0) { + // d_tail = 0; + d_tail.reset(); } d_count--; @@ -92,39 +87,37 @@ namespace gr { m->d_next.reset(); d_not_full.notify_one(); return m; - } +} - message::sptr - msg_queue::delete_head_nowait() - { +message::sptr msg_queue::delete_head_nowait() +{ gr::thread::scoped_lock guard(d_mutex); message::sptr m; - if((m = d_head) == 0) { - //return 0; - return message::sptr(); + if ((m = d_head) == 0) { + // return 0; + return message::sptr(); } d_head = m->d_next; - if(d_head == 0) { - //d_tail = 0; - d_tail.reset(); + if (d_head == 0) { + // d_tail = 0; + d_tail.reset(); } d_count--; - //m->d_next = 0; + // m->d_next = 0; m->d_next.reset(); d_not_full.notify_one(); return m; - } +} - void - msg_queue::flush() - { +void msg_queue::flush() +{ message::sptr m; - while((m = delete_head_nowait ()) != 0) - ; - } + while ((m = delete_head_nowait()) != 0) + ; +} } /* namespace gr */ diff --git a/gnuradio-runtime/lib/pagesize.cc b/gnuradio-runtime/lib/pagesize.cc index 373c0b6654..3a58c3d8d7 100644 --- a/gnuradio-runtime/lib/pagesize.cc +++ b/gnuradio-runtime/lib/pagesize.cc @@ -31,29 +31,28 @@ namespace gr { #if defined(_WIN32) && defined(HAVE_GETPAGESIZE) - extern "C" size_t getpagesize(void); +extern "C" size_t getpagesize(void); #endif - int - pagesize() - { +int pagesize() +{ static int s_pagesize = -1; - if(s_pagesize == -1) { + if (s_pagesize == -1) { #if defined(HAVE_GETPAGESIZE) - s_pagesize = getpagesize(); -#elif defined (HAVE_SYSCONF) - s_pagesize = sysconf(_SC_PAGESIZE); - if(s_pagesize == -1) { - perror("_SC_PAGESIZE"); - s_pagesize = 4096; - } + s_pagesize = getpagesize(); +#elif defined(HAVE_SYSCONF) + s_pagesize = sysconf(_SC_PAGESIZE); + if (s_pagesize == -1) { + perror("_SC_PAGESIZE"); + s_pagesize = 4096; + } #else - fprintf(stderr, "gr::pagesize: no info; setting pagesize = 4096\n"); - s_pagesize = 4096; + fprintf(stderr, "gr::pagesize: no info; setting pagesize = 4096\n"); + s_pagesize = 4096; #endif } return s_pagesize; - } +} } /* namespace gr */ diff --git a/gnuradio-runtime/lib/pagesize.h b/gnuradio-runtime/lib/pagesize.h index 6a16882002..f7dffe2790 100644 --- a/gnuradio-runtime/lib/pagesize.h +++ b/gnuradio-runtime/lib/pagesize.h @@ -27,10 +27,10 @@ namespace gr { - /*! - * \brief return the page size in bytes - */ - GR_RUNTIME_API int pagesize(); +/*! + * \brief return the page size in bytes + */ +GR_RUNTIME_API int pagesize(); } /* namespace gr */ diff --git a/gnuradio-runtime/lib/pmt/pmt.cc b/gnuradio-runtime/lib/pmt/pmt.cc index e0f50b5b0b..4adb763e5f 100644 --- a/gnuradio-runtime/lib/pmt/pmt.cc +++ b/gnuradio-runtime/lib/pmt/pmt.cc @@ -36,30 +36,30 @@ namespace pmt { pmt_base::~pmt_base() { - // nop -- out of line virtual destructor + // nop -- out of line virtual destructor } //////////////////////////////////////////////////////////////////////////// // Exceptions //////////////////////////////////////////////////////////////////////////// -exception::exception(const std::string &msg, pmt_t obj) - : logic_error(msg + ": " + write_string(obj)) +exception::exception(const std::string& msg, pmt_t obj) + : logic_error(msg + ": " + write_string(obj)) { } -wrong_type::wrong_type(const std::string &msg, pmt_t obj) - : exception(msg + ": wrong_type ", obj) +wrong_type::wrong_type(const std::string& msg, pmt_t obj) + : exception(msg + ": wrong_type ", obj) { } -out_of_range::out_of_range(const std::string &msg, pmt_t obj) - : exception(msg + ": out of range ", obj) +out_of_range::out_of_range(const std::string& msg, pmt_t obj) + : exception(msg + ": out of range ", obj) { } -notimplemented::notimplemented(const std::string &msg, pmt_t obj) - : exception(msg + ": notimplemented ", obj) +notimplemented::notimplemented(const std::string& msg, pmt_t obj) + : exception(msg + ": notimplemented ", obj) { } @@ -67,65 +67,28 @@ notimplemented::notimplemented(const std::string &msg, pmt_t obj) // Dynamic Casts //////////////////////////////////////////////////////////////////////////// -static pmt_symbol * -_symbol(pmt_t x) -{ - return dynamic_cast<pmt_symbol*>(x.get()); -} +static pmt_symbol* _symbol(pmt_t x) { return dynamic_cast<pmt_symbol*>(x.get()); } -static pmt_integer * -_integer(pmt_t x) -{ - return dynamic_cast<pmt_integer*>(x.get()); -} +static pmt_integer* _integer(pmt_t x) { return dynamic_cast<pmt_integer*>(x.get()); } -static pmt_uint64 * -_uint64(pmt_t x) -{ - return dynamic_cast<pmt_uint64*>(x.get()); -} +static pmt_uint64* _uint64(pmt_t x) { return dynamic_cast<pmt_uint64*>(x.get()); } -static pmt_real * -_real(pmt_t x) -{ - return dynamic_cast<pmt_real*>(x.get()); -} +static pmt_real* _real(pmt_t x) { return dynamic_cast<pmt_real*>(x.get()); } -static pmt_complex * -_complex(pmt_t x) -{ - return dynamic_cast<pmt_complex*>(x.get()); -} +static pmt_complex* _complex(pmt_t x) { return dynamic_cast<pmt_complex*>(x.get()); } -static pmt_pair * -_pair(pmt_t x) -{ - return dynamic_cast<pmt_pair*>(x.get()); -} +static pmt_pair* _pair(pmt_t x) { return dynamic_cast<pmt_pair*>(x.get()); } -static pmt_vector * -_vector(pmt_t x) -{ - return dynamic_cast<pmt_vector*>(x.get()); -} +static pmt_vector* _vector(pmt_t x) { return dynamic_cast<pmt_vector*>(x.get()); } -static pmt_tuple * -_tuple(pmt_t x) -{ - return dynamic_cast<pmt_tuple*>(x.get()); -} +static pmt_tuple* _tuple(pmt_t x) { return dynamic_cast<pmt_tuple*>(x.get()); } -static pmt_uniform_vector * -_uniform_vector(pmt_t x) +static pmt_uniform_vector* _uniform_vector(pmt_t x) { - return dynamic_cast<pmt_uniform_vector*>(x.get()); + return dynamic_cast<pmt_uniform_vector*>(x.get()); } -static pmt_any * -_any(pmt_t x) -{ - return dynamic_cast<pmt_any*>(x.get()); -} +static pmt_any* _any(pmt_t x) { return dynamic_cast<pmt_any*>(x.get()); } //////////////////////////////////////////////////////////////////////////// // Globals @@ -133,167 +96,132 @@ _any(pmt_t x) pmt_t get_PMT_NIL() { - static pmt_t _NIL = pmt_t(new pmt_null()); - return _NIL; + static pmt_t _NIL = pmt_t(new pmt_null()); + return _NIL; } pmt_t get_PMT_T() { - static const pmt_t _T = pmt_t(new pmt_bool()); - return _T; + static const pmt_t _T = pmt_t(new pmt_bool()); + return _T; } pmt_t get_PMT_F() { - static const pmt_t _F = pmt_t(new pmt_bool()); - return _F; + static const pmt_t _F = pmt_t(new pmt_bool()); + return _F; } pmt_t get_PMT_EOF() { - static const pmt_t _EOF = cons(get_PMT_NIL(), get_PMT_NIL()); - return _EOF; + static const pmt_t _EOF = cons(get_PMT_NIL(), get_PMT_NIL()); + return _EOF; } //////////////////////////////////////////////////////////////////////////// // Booleans //////////////////////////////////////////////////////////////////////////// -pmt_bool::pmt_bool(){} +pmt_bool::pmt_bool() {} -bool -is_true(pmt_t obj) -{ - return obj != PMT_F; -} +bool is_true(pmt_t obj) { return obj != PMT_F; } -bool -is_false(pmt_t obj) -{ - return obj == PMT_F; -} +bool is_false(pmt_t obj) { return obj == PMT_F; } -bool -is_bool(pmt_t obj) -{ - return obj->is_bool(); -} +bool is_bool(pmt_t obj) { return obj->is_bool(); } -pmt_t -from_bool(bool val) -{ - return val ? PMT_T : PMT_F; -} +pmt_t from_bool(bool val) { return val ? PMT_T : PMT_F; } -bool -to_bool(pmt_t val) +bool to_bool(pmt_t val) { - if (val == PMT_T) - return true; - if (val == PMT_F) - return false; - throw wrong_type("pmt_to_bool", val); + if (val == PMT_T) + return true; + if (val == PMT_F) + return false; + throw wrong_type("pmt_to_bool", val); } //////////////////////////////////////////////////////////////////////////// // Symbols //////////////////////////////////////////////////////////////////////////// -static const unsigned int -get_symbol_hash_table_size() +static const unsigned int get_symbol_hash_table_size() { - static const unsigned int SYMBOL_HASH_TABLE_SIZE = 701; - return SYMBOL_HASH_TABLE_SIZE; + static const unsigned int SYMBOL_HASH_TABLE_SIZE = 701; + return SYMBOL_HASH_TABLE_SIZE; } -static std::vector<pmt_t>* -get_symbol_hash_table() +static std::vector<pmt_t>* get_symbol_hash_table() { - static std::vector<pmt_t> s_symbol_hash_table(get_symbol_hash_table_size()); - return &s_symbol_hash_table; + static std::vector<pmt_t> s_symbol_hash_table(get_symbol_hash_table_size()); + return &s_symbol_hash_table; } -pmt_symbol::pmt_symbol(const std::string &name) : d_name(name){} +pmt_symbol::pmt_symbol(const std::string& name) : d_name(name) {} -static unsigned int -hash_string(const std::string &s) +static unsigned int hash_string(const std::string& s) { - unsigned int h = 0; - unsigned int g = 0; + unsigned int h = 0; + unsigned int g = 0; - for (std::string::const_iterator p = s.begin(); p != s.end(); ++p){ - h = (h << 4) + (*p & 0xff); - g = h & 0xf0000000; - if (g){ - h = h ^ (g >> 24); - h = h ^ g; + for (std::string::const_iterator p = s.begin(); p != s.end(); ++p) { + h = (h << 4) + (*p & 0xff); + g = h & 0xf0000000; + if (g) { + h = h ^ (g >> 24); + h = h ^ g; + } } - } - return h; + return h; } -bool -is_symbol(const pmt_t& obj) -{ - return obj->is_symbol(); -} +bool is_symbol(const pmt_t& obj) { return obj->is_symbol(); } -pmt_t -string_to_symbol(const std::string &name) +pmt_t string_to_symbol(const std::string& name) { - unsigned hash = hash_string(name) % get_symbol_hash_table_size(); + unsigned hash = hash_string(name) % get_symbol_hash_table_size(); - // Does a symbol with this name already exist? - for (pmt_t sym = (*get_symbol_hash_table())[hash]; sym; sym = _symbol(sym)->next()){ - if (name == _symbol(sym)->name()) - return sym; // Yes. Return it - } + // Does a symbol with this name already exist? + for (pmt_t sym = (*get_symbol_hash_table())[hash]; sym; sym = _symbol(sym)->next()) { + if (name == _symbol(sym)->name()) + return sym; // Yes. Return it + } - // Lock the table on insert for thread safety: - static boost::mutex thread_safety; - boost::mutex::scoped_lock lock(thread_safety); - // Re-do the search in case another thread inserted this symbol into the table - // before we got the lock - for (pmt_t sym = (*get_symbol_hash_table())[hash]; sym; sym = _symbol(sym)->next()){ - if (name == _symbol(sym)->name()) - return sym; // Yes. Return it - } + // Lock the table on insert for thread safety: + static boost::mutex thread_safety; + boost::mutex::scoped_lock lock(thread_safety); + // Re-do the search in case another thread inserted this symbol into the table + // before we got the lock + for (pmt_t sym = (*get_symbol_hash_table())[hash]; sym; sym = _symbol(sym)->next()) { + if (name == _symbol(sym)->name()) + return sym; // Yes. Return it + } - // Nope. Make a new one. - pmt_t sym = pmt_t(new pmt_symbol(name)); - _symbol(sym)->set_next((*get_symbol_hash_table())[hash]); - (*get_symbol_hash_table())[hash] = sym; - return sym; + // Nope. Make a new one. + pmt_t sym = pmt_t(new pmt_symbol(name)); + _symbol(sym)->set_next((*get_symbol_hash_table())[hash]); + (*get_symbol_hash_table())[hash] = sym; + return sym; } // alias... -pmt_t -intern(const std::string &name) -{ - return string_to_symbol(name); -} +pmt_t intern(const std::string& name) { return string_to_symbol(name); } -const std::string -symbol_to_string(const pmt_t& sym) +const std::string symbol_to_string(const pmt_t& sym) { - if (!sym->is_symbol()) - throw wrong_type("pmt_symbol_to_string", sym); + if (!sym->is_symbol()) + throw wrong_type("pmt_symbol_to_string", sym); - return _symbol(sym)->name(); + return _symbol(sym)->name(); } - //////////////////////////////////////////////////////////////////////////// // Number //////////////////////////////////////////////////////////////////////////// -bool -is_number(pmt_t x) -{ - return x->is_number(); -} +bool is_number(pmt_t x) { return x->is_number(); } //////////////////////////////////////////////////////////////////////////// // Integer @@ -301,27 +229,18 @@ is_number(pmt_t x) pmt_integer::pmt_integer(long value) : d_value(value) {} -bool -is_integer(pmt_t x) -{ - return x->is_integer(); -} +bool is_integer(pmt_t x) { return x->is_integer(); } -pmt_t -from_long(long x) -{ - return pmt_t(new pmt_integer(x)); -} +pmt_t from_long(long x) { return pmt_t(new pmt_integer(x)); } -long -to_long(pmt_t x) +long to_long(pmt_t x) { - pmt_integer* i = dynamic_cast<pmt_integer*>(x.get()); - if ( i ) - return i->value(); + pmt_integer* i = dynamic_cast<pmt_integer*>(x.get()); + if (i) + return i->value(); - throw wrong_type("pmt_to_long", x); + throw wrong_type("pmt_to_long", x); } //////////////////////////////////////////////////////////////////////////// @@ -330,32 +249,22 @@ to_long(pmt_t x) pmt_uint64::pmt_uint64(uint64_t value) : d_value(value) {} -bool -is_uint64(pmt_t x) -{ - return x->is_uint64(); -} +bool is_uint64(pmt_t x) { return x->is_uint64(); } -pmt_t -from_uint64(uint64_t x) -{ - return pmt_t(new pmt_uint64(x)); -} +pmt_t from_uint64(uint64_t x) { return pmt_t(new pmt_uint64(x)); } -uint64_t -to_uint64(pmt_t x) +uint64_t to_uint64(pmt_t x) { - if(x->is_uint64()) - return _uint64(x)->value(); - if(x->is_integer()) - { - long tmp = _integer(x)->value(); - if(tmp >= 0) - return (uint64_t) tmp; + if (x->is_uint64()) + return _uint64(x)->value(); + if (x->is_integer()) { + long tmp = _integer(x)->value(); + if (tmp >= 0) + return (uint64_t)tmp; } - throw wrong_type("pmt_to_uint64", x); + throw wrong_type("pmt_to_uint64", x); } //////////////////////////////////////////////////////////////////////////// @@ -364,40 +273,23 @@ to_uint64(pmt_t x) pmt_real::pmt_real(double value) : d_value(value) {} -bool -is_real(pmt_t x) -{ - return x->is_real(); -} +bool is_real(pmt_t x) { return x->is_real(); } -pmt_t -from_double(double x) -{ - return pmt_t(new pmt_real(x)); -} +pmt_t from_double(double x) { return pmt_t(new pmt_real(x)); } -pmt_t -from_float(float x) -{ - return pmt_t(new pmt_real(x)); -} +pmt_t from_float(float x) { return pmt_t(new pmt_real(x)); } -double -to_double(pmt_t x) +double to_double(pmt_t x) { - if (x->is_real()) - return _real(x)->value(); - if (x->is_integer()) - return _integer(x)->value(); + if (x->is_real()) + return _real(x)->value(); + if (x->is_integer()) + return _integer(x)->value(); - throw wrong_type("pmt_to_double", x); + throw wrong_type("pmt_to_double", x); } -float -to_float(pmt_t x) -{ - return float(to_double(x)); -} +float to_float(pmt_t x) { return float(to_double(x)); } //////////////////////////////////////////////////////////////////////////// // Complex @@ -405,46 +297,29 @@ to_float(pmt_t x) pmt_complex::pmt_complex(std::complex<double> value) : d_value(value) {} -bool -is_complex(pmt_t x) -{ - return x->is_complex(); -} +bool is_complex(pmt_t x) { return x->is_complex(); } -pmt_t -make_rectangular(double re, double im) -{ - return from_complex(re, im); -} +pmt_t make_rectangular(double re, double im) { return from_complex(re, im); } -pmt_t -from_complex(double re, double im) -{ - return pmt_from_complex(re, im); -} +pmt_t from_complex(double re, double im) { return pmt_from_complex(re, im); } pmt_t pmt_from_complex(double re, double im) { - return pmt_t(new pmt_complex(std::complex<double>(re, im))); + return pmt_t(new pmt_complex(std::complex<double>(re, im))); } -pmt_t -from_complex(const std::complex<double> &z) -{ - return pmt_t(new pmt_complex(z)); -} +pmt_t from_complex(const std::complex<double>& z) { return pmt_t(new pmt_complex(z)); } -std::complex<double> -to_complex(pmt_t x) +std::complex<double> to_complex(pmt_t x) { - if (x->is_complex()) - return _complex(x)->value(); - if (x->is_real()) - return _real(x)->value(); - if (x->is_integer()) - return _integer(x)->value(); + if (x->is_complex()) + return _complex(x)->value(); + if (x->is_real()) + return _real(x)->value(); + if (x->is_integer()) + return _integer(x)->value(); - throw wrong_type("pmt_to_complex", x); + throw wrong_type("pmt_to_complex", x); } //////////////////////////////////////////////////////////////////////////// @@ -454,363 +329,335 @@ to_complex(pmt_t x) pmt_null::pmt_null() {} pmt_pair::pmt_pair(const pmt_t& car, const pmt_t& cdr) : d_car(car), d_cdr(cdr) {} -bool -is_null(const pmt_t& x) -{ - return x == PMT_NIL; -} +bool is_null(const pmt_t& x) { return x == PMT_NIL; } -bool -is_pair(const pmt_t& obj) -{ - return obj->is_pair(); -} +bool is_pair(const pmt_t& obj) { return obj->is_pair(); } -pmt_t -cons(const pmt_t& x, const pmt_t& y) -{ - return pmt_t(new pmt_pair(x, y)); -} +pmt_t cons(const pmt_t& x, const pmt_t& y) { return pmt_t(new pmt_pair(x, y)); } -pmt_t -car(const pmt_t& pair) +pmt_t car(const pmt_t& pair) { - pmt_pair* p = dynamic_cast<pmt_pair*>(pair.get()); - if ( p ) - return p->car(); + pmt_pair* p = dynamic_cast<pmt_pair*>(pair.get()); + if (p) + return p->car(); - throw wrong_type("pmt_car", pair); + throw wrong_type("pmt_car", pair); } -pmt_t -cdr(const pmt_t& pair) +pmt_t cdr(const pmt_t& pair) { - pmt_pair* p = dynamic_cast<pmt_pair*>(pair.get()); - if ( p ) - return p->cdr(); + pmt_pair* p = dynamic_cast<pmt_pair*>(pair.get()); + if (p) + return p->cdr(); - throw wrong_type("pmt_cdr", pair); + throw wrong_type("pmt_cdr", pair); } -void -set_car(pmt_t pair, pmt_t obj) +void set_car(pmt_t pair, pmt_t obj) { - if (pair->is_pair()) - _pair(pair)->set_car(obj); - else - throw wrong_type("pmt_set_car", pair); + if (pair->is_pair()) + _pair(pair)->set_car(obj); + else + throw wrong_type("pmt_set_car", pair); } -void -set_cdr(pmt_t pair, pmt_t obj) +void set_cdr(pmt_t pair, pmt_t obj) { - if (pair->is_pair()) - _pair(pair)->set_cdr(obj); - else - throw wrong_type("pmt_set_cdr", pair); + if (pair->is_pair()) + _pair(pair)->set_cdr(obj); + else + throw wrong_type("pmt_set_cdr", pair); } //////////////////////////////////////////////////////////////////////////// // Vectors //////////////////////////////////////////////////////////////////////////// -pmt_vector::pmt_vector(size_t len, pmt_t fill) - : d_v(len) +pmt_vector::pmt_vector(size_t len, pmt_t fill) : d_v(len) { - for (size_t i = 0; i < len; i++) - d_v[i] = fill; + for (size_t i = 0; i < len; i++) + d_v[i] = fill; } -pmt_t -pmt_vector::ref(size_t k) const +pmt_t pmt_vector::ref(size_t k) const { - if (k >= length()) - throw out_of_range("pmt_vector_ref", from_long(k)); - return d_v[k]; + if (k >= length()) + throw out_of_range("pmt_vector_ref", from_long(k)); + return d_v[k]; } -void -pmt_vector::set(size_t k, pmt_t obj) +void pmt_vector::set(size_t k, pmt_t obj) { - if (k >= length()) - throw out_of_range("pmt_vector_set", from_long(k)); - d_v[k] = obj; + if (k >= length()) + throw out_of_range("pmt_vector_set", from_long(k)); + d_v[k] = obj; } -void -pmt_vector::fill(pmt_t obj) +void pmt_vector::fill(pmt_t obj) { - for (size_t i = 0; i < length(); i++) - d_v[i] = obj; + for (size_t i = 0; i < length(); i++) + d_v[i] = obj; } -bool -is_vector(pmt_t obj) -{ - return obj->is_vector(); -} +bool is_vector(pmt_t obj) { return obj->is_vector(); } -pmt_t -make_vector(size_t k, pmt_t fill) -{ - return pmt_t(new pmt_vector(k, fill)); -} +pmt_t make_vector(size_t k, pmt_t fill) { return pmt_t(new pmt_vector(k, fill)); } -pmt_t -vector_ref(pmt_t vector, size_t k) +pmt_t vector_ref(pmt_t vector, size_t k) { - if (!vector->is_vector()) - throw wrong_type("pmt_vector_ref", vector); - return _vector(vector)->ref(k); + if (!vector->is_vector()) + throw wrong_type("pmt_vector_ref", vector); + return _vector(vector)->ref(k); } -void -vector_set(pmt_t vector, size_t k, pmt_t obj) +void vector_set(pmt_t vector, size_t k, pmt_t obj) { - if (!vector->is_vector()) - throw wrong_type("pmt_vector_set", vector); - _vector(vector)->set(k, obj); + if (!vector->is_vector()) + throw wrong_type("pmt_vector_set", vector); + _vector(vector)->set(k, obj); } -void -vector_fill(pmt_t vector, pmt_t obj) +void vector_fill(pmt_t vector, pmt_t obj) { - if (!vector->is_vector()) - throw wrong_type("pmt_vector_set", vector); - _vector(vector)->fill(obj); + if (!vector->is_vector()) + throw wrong_type("pmt_vector_set", vector); + _vector(vector)->fill(obj); } //////////////////////////////////////////////////////////////////////////// // Tuples //////////////////////////////////////////////////////////////////////////// -pmt_tuple::pmt_tuple(size_t len) - : d_v(len) -{ -} +pmt_tuple::pmt_tuple(size_t len) : d_v(len) {} -pmt_t -pmt_tuple::ref(size_t k) const +pmt_t pmt_tuple::ref(size_t k) const { - if (k >= length()) - throw out_of_range("pmt_tuple_ref", from_long(k)); - return d_v[k]; + if (k >= length()) + throw out_of_range("pmt_tuple_ref", from_long(k)); + return d_v[k]; } -bool -is_tuple(pmt_t obj) -{ - return obj->is_tuple(); -} +bool is_tuple(pmt_t obj) { return obj->is_tuple(); } -pmt_t -tuple_ref(const pmt_t &tuple, size_t k) +pmt_t tuple_ref(const pmt_t& tuple, size_t k) { - if (!tuple->is_tuple()) - throw wrong_type("pmt_tuple_ref", tuple); - return _tuple(tuple)->ref(k); + if (!tuple->is_tuple()) + throw wrong_type("pmt_tuple_ref", tuple); + return _tuple(tuple)->ref(k); } // for (i=0; i < 10; i++) // make_constructor() -pmt_t -make_tuple() -{ - return pmt_t(new pmt_tuple(0)); -} - -pmt_t -make_tuple(const pmt_t &e0) -{ - pmt_tuple *t = new pmt_tuple(1); - t->_set(0, e0); - return pmt_t(t); -} - -pmt_t -make_tuple(const pmt_t &e0, const pmt_t &e1) -{ - pmt_tuple *t = new pmt_tuple(2); - t->_set(0, e0); - t->_set(1, e1); - return pmt_t(t); -} - -pmt_t -make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2) -{ - pmt_tuple *t = new pmt_tuple(3); - t->_set(0, e0); - t->_set(1, e1); - t->_set(2, e2); - return pmt_t(t); -} - -pmt_t -make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3) -{ - pmt_tuple *t = new pmt_tuple(4); - t->_set(0, e0); - t->_set(1, e1); - t->_set(2, e2); - t->_set(3, e3); - return pmt_t(t); -} - -pmt_t -make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4) -{ - pmt_tuple *t = new pmt_tuple(5); - t->_set(0, e0); - t->_set(1, e1); - t->_set(2, e2); - t->_set(3, e3); - t->_set(4, e4); - return pmt_t(t); -} - -pmt_t -make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4, const pmt_t &e5) -{ - pmt_tuple *t = new pmt_tuple(6); - t->_set(0, e0); - t->_set(1, e1); - t->_set(2, e2); - t->_set(3, e3); - t->_set(4, e4); - t->_set(5, e5); - return pmt_t(t); -} - -pmt_t -make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4, const pmt_t &e5, const pmt_t &e6) -{ - pmt_tuple *t = new pmt_tuple(7); - t->_set(0, e0); - t->_set(1, e1); - t->_set(2, e2); - t->_set(3, e3); - t->_set(4, e4); - t->_set(5, e5); - t->_set(6, e6); - return pmt_t(t); -} - -pmt_t -make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4, const pmt_t &e5, const pmt_t &e6, const pmt_t &e7) -{ - pmt_tuple *t = new pmt_tuple(8); - t->_set(0, e0); - t->_set(1, e1); - t->_set(2, e2); - t->_set(3, e3); - t->_set(4, e4); - t->_set(5, e5); - t->_set(6, e6); - t->_set(7, e7); - return pmt_t(t); -} +pmt_t make_tuple() { return pmt_t(new pmt_tuple(0)); } + +pmt_t make_tuple(const pmt_t& e0) +{ + pmt_tuple* t = new pmt_tuple(1); + t->_set(0, e0); + return pmt_t(t); +} + +pmt_t make_tuple(const pmt_t& e0, const pmt_t& e1) +{ + pmt_tuple* t = new pmt_tuple(2); + t->_set(0, e0); + t->_set(1, e1); + return pmt_t(t); +} + +pmt_t make_tuple(const pmt_t& e0, const pmt_t& e1, const pmt_t& e2) +{ + pmt_tuple* t = new pmt_tuple(3); + t->_set(0, e0); + t->_set(1, e1); + t->_set(2, e2); + return pmt_t(t); +} + +pmt_t make_tuple(const pmt_t& e0, const pmt_t& e1, const pmt_t& e2, const pmt_t& e3) +{ + pmt_tuple* t = new pmt_tuple(4); + t->_set(0, e0); + t->_set(1, e1); + t->_set(2, e2); + t->_set(3, e3); + return pmt_t(t); +} + +pmt_t make_tuple( + const pmt_t& e0, const pmt_t& e1, const pmt_t& e2, const pmt_t& e3, const pmt_t& e4) +{ + pmt_tuple* t = new pmt_tuple(5); + t->_set(0, e0); + t->_set(1, e1); + t->_set(2, e2); + t->_set(3, e3); + t->_set(4, e4); + return pmt_t(t); +} + +pmt_t make_tuple(const pmt_t& e0, + const pmt_t& e1, + const pmt_t& e2, + const pmt_t& e3, + const pmt_t& e4, + const pmt_t& e5) +{ + pmt_tuple* t = new pmt_tuple(6); + t->_set(0, e0); + t->_set(1, e1); + t->_set(2, e2); + t->_set(3, e3); + t->_set(4, e4); + t->_set(5, e5); + return pmt_t(t); +} + +pmt_t make_tuple(const pmt_t& e0, + const pmt_t& e1, + const pmt_t& e2, + const pmt_t& e3, + const pmt_t& e4, + const pmt_t& e5, + const pmt_t& e6) +{ + pmt_tuple* t = new pmt_tuple(7); + t->_set(0, e0); + t->_set(1, e1); + t->_set(2, e2); + t->_set(3, e3); + t->_set(4, e4); + t->_set(5, e5); + t->_set(6, e6); + return pmt_t(t); +} + +pmt_t make_tuple(const pmt_t& e0, + const pmt_t& e1, + const pmt_t& e2, + const pmt_t& e3, + const pmt_t& e4, + const pmt_t& e5, + const pmt_t& e6, + const pmt_t& e7) +{ + pmt_tuple* t = new pmt_tuple(8); + t->_set(0, e0); + t->_set(1, e1); + t->_set(2, e2); + t->_set(3, e3); + t->_set(4, e4); + t->_set(5, e5); + t->_set(6, e6); + t->_set(7, e7); + return pmt_t(t); +} + +pmt_t make_tuple(const pmt_t& e0, + const pmt_t& e1, + const pmt_t& e2, + const pmt_t& e3, + const pmt_t& e4, + const pmt_t& e5, + const pmt_t& e6, + const pmt_t& e7, + const pmt_t& e8) +{ + pmt_tuple* t = new pmt_tuple(9); + t->_set(0, e0); + t->_set(1, e1); + t->_set(2, e2); + t->_set(3, e3); + t->_set(4, e4); + t->_set(5, e5); + t->_set(6, e6); + t->_set(7, e7); + t->_set(8, e8); + return pmt_t(t); +} + +pmt_t make_tuple(const pmt_t& e0, + const pmt_t& e1, + const pmt_t& e2, + const pmt_t& e3, + const pmt_t& e4, + const pmt_t& e5, + const pmt_t& e6, + const pmt_t& e7, + const pmt_t& e8, + const pmt_t& e9) +{ + pmt_tuple* t = new pmt_tuple(10); + t->_set(0, e0); + t->_set(1, e1); + t->_set(2, e2); + t->_set(3, e3); + t->_set(4, e4); + t->_set(5, e5); + t->_set(6, e6); + t->_set(7, e7); + t->_set(8, e8); + t->_set(9, e9); + return pmt_t(t); +} + +pmt_t to_tuple(const pmt_t& x) +{ + if (x->is_tuple()) // already one + return x; + + size_t len = length(x); + pmt_tuple* t = new pmt_tuple(len); + pmt_t r = pmt_t(t); + + if (x->is_vector()) { + for (size_t i = 0; i < len; i++) + t->_set(i, _vector(x)->ref(i)); + return r; + } -pmt_t -make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4, const pmt_t &e5, const pmt_t &e6, const pmt_t &e7, const pmt_t &e8) -{ - pmt_tuple *t = new pmt_tuple(9); - t->_set(0, e0); - t->_set(1, e1); - t->_set(2, e2); - t->_set(3, e3); - t->_set(4, e4); - t->_set(5, e5); - t->_set(6, e6); - t->_set(7, e7); - t->_set(8, e8); - return pmt_t(t); -} - -pmt_t -make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4, const pmt_t &e5, const pmt_t &e6, const pmt_t &e7, const pmt_t &e8, const pmt_t &e9) -{ - pmt_tuple *t = new pmt_tuple(10); - t->_set(0, e0); - t->_set(1, e1); - t->_set(2, e2); - t->_set(3, e3); - t->_set(4, e4); - t->_set(5, e5); - t->_set(6, e6); - t->_set(7, e7); - t->_set(8, e8); - t->_set(9, e9); - return pmt_t(t); -} - -pmt_t -to_tuple(const pmt_t &x) -{ - if (x->is_tuple()) // already one - return x; - - size_t len = length(x); - pmt_tuple *t = new pmt_tuple(len); - pmt_t r = pmt_t(t); - - if (x->is_vector()){ - for (size_t i = 0; i < len; i++) - t->_set(i, _vector(x)->ref(i)); - return r; - } - - if (x->is_pair()){ - pmt_t y = x; - for (size_t i = 0; i < len; i++){ - t->_set(i, car(y)); - y = cdr(y); + if (x->is_pair()) { + pmt_t y = x; + for (size_t i = 0; i < len; i++) { + t->_set(i, car(y)); + y = cdr(y); + } + return r; } - return r; - } - throw wrong_type("pmt_to_tuple", x); + throw wrong_type("pmt_to_tuple", x); } - //////////////////////////////////////////////////////////////////////////// // Uniform Numeric Vectors //////////////////////////////////////////////////////////////////////////// -bool -is_uniform_vector(pmt_t x) -{ - return x->is_uniform_vector(); -} +bool is_uniform_vector(pmt_t x) { return x->is_uniform_vector(); } -size_t -uniform_vector_itemsize(pmt_t vector) +size_t uniform_vector_itemsize(pmt_t vector) { - if (!vector->is_uniform_vector()) - throw wrong_type("pmt_uniform_vector_itemsize", vector); - return _uniform_vector(vector)->itemsize(); + if (!vector->is_uniform_vector()) + throw wrong_type("pmt_uniform_vector_itemsize", vector); + return _uniform_vector(vector)->itemsize(); } -const void * -uniform_vector_elements(pmt_t vector, size_t &len) +const void* uniform_vector_elements(pmt_t vector, size_t& len) { - if (!vector->is_uniform_vector()) - throw wrong_type("pmt_uniform_vector_elements", vector); - return _uniform_vector(vector)->uniform_elements(len); + if (!vector->is_uniform_vector()) + throw wrong_type("pmt_uniform_vector_elements", vector); + return _uniform_vector(vector)->uniform_elements(len); } -void * -uniform_vector_writable_elements(pmt_t vector, size_t &len) +void* uniform_vector_writable_elements(pmt_t vector, size_t& len) { - if (!vector->is_uniform_vector()) - throw wrong_type("pmt_uniform_vector_writable_elements", vector); - return _uniform_vector(vector)->uniform_writable_elements(len); + if (!vector->is_uniform_vector()) + throw wrong_type("pmt_uniform_vector_writable_elements", vector); + return _uniform_vector(vector)->uniform_writable_elements(len); } - //////////////////////////////////////////////////////////////////////////// // Dictionaries //////////////////////////////////////////////////////////////////////////// @@ -823,163 +670,130 @@ uniform_vector_writable_elements(pmt_t vector, size_t &len) * Chris Okasaki, 1998, section 3.3. */ -bool -is_dict(const pmt_t &obj) -{ - return is_null(obj) || is_pair(obj); -} +bool is_dict(const pmt_t& obj) { return is_null(obj) || is_pair(obj); } -pmt_t -make_dict() -{ - return PMT_NIL; -} +pmt_t make_dict() { return PMT_NIL; } -pmt_t -dict_add(const pmt_t &dict, const pmt_t &key, const pmt_t &value) +pmt_t dict_add(const pmt_t& dict, const pmt_t& key, const pmt_t& value) { - if (is_null(dict)) - return acons(key, value, PMT_NIL); + if (is_null(dict)) + return acons(key, value, PMT_NIL); - if (dict_has_key(dict, key)) - return acons(key, value, dict_delete(dict, key)); + if (dict_has_key(dict, key)) + return acons(key, value, dict_delete(dict, key)); - return acons(key, value, dict); + return acons(key, value, dict); } -pmt_t -dict_update(const pmt_t &dict1, const pmt_t &dict2) +pmt_t dict_update(const pmt_t& dict1, const pmt_t& dict2) { - pmt_t d(dict1); - pmt_t k(dict_keys(dict2)); - while(is_pair(k)){ - d = dict_add(d, car(k), dict_ref(dict2, car(k), PMT_NIL)); - k = cdr(k); + pmt_t d(dict1); + pmt_t k(dict_keys(dict2)); + while (is_pair(k)) { + d = dict_add(d, car(k), dict_ref(dict2, car(k), PMT_NIL)); + k = cdr(k); } - return d; + return d; } -pmt_t -dict_delete(const pmt_t &dict, const pmt_t &key) +pmt_t dict_delete(const pmt_t& dict, const pmt_t& key) { - if (is_null(dict)) - return dict; + if (is_null(dict)) + return dict; - if (eqv(caar(dict), key)) - return cdr(dict); + if (eqv(caar(dict), key)) + return cdr(dict); - return cons(car(dict), dict_delete(cdr(dict), key)); + return cons(car(dict), dict_delete(cdr(dict), key)); } -pmt_t -dict_ref(const pmt_t &dict, const pmt_t &key, const pmt_t ¬_found) +pmt_t dict_ref(const pmt_t& dict, const pmt_t& key, const pmt_t& not_found) { - pmt_t p = assv(key, dict); // look for (key . value) pair - if (is_pair(p)) - return cdr(p); - else - return not_found; + pmt_t p = assv(key, dict); // look for (key . value) pair + if (is_pair(p)) + return cdr(p); + else + return not_found; } -bool -dict_has_key(const pmt_t &dict, const pmt_t &key) +bool dict_has_key(const pmt_t& dict, const pmt_t& key) { - return is_pair(assv(key, dict)); + return is_pair(assv(key, dict)); } -pmt_t -dict_items(pmt_t dict) +pmt_t dict_items(pmt_t dict) { - if (!is_dict(dict)) - throw wrong_type("pmt_dict_values", dict); + if (!is_dict(dict)) + throw wrong_type("pmt_dict_values", dict); - return dict; // equivalent to dict in the a-list case + return dict; // equivalent to dict in the a-list case } -pmt_t -dict_keys(pmt_t dict) +pmt_t dict_keys(pmt_t dict) { - if (!is_dict(dict)) - throw wrong_type("pmt_dict_keys", dict); + if (!is_dict(dict)) + throw wrong_type("pmt_dict_keys", dict); - return map(car, dict); + return map(car, dict); } -pmt_t -dict_values(pmt_t dict) +pmt_t dict_values(pmt_t dict) { - if (!is_dict(dict)) - throw wrong_type("pmt_dict_keys", dict); + if (!is_dict(dict)) + throw wrong_type("pmt_dict_keys", dict); - return map(cdr, dict); + return map(cdr, dict); } //////////////////////////////////////////////////////////////////////////// // Any //////////////////////////////////////////////////////////////////////////// -pmt_any::pmt_any(const boost::any &any) : d_any(any) {} +pmt_any::pmt_any(const boost::any& any) : d_any(any) {} -bool -is_any(pmt_t obj) -{ - return obj->is_any(); -} +bool is_any(pmt_t obj) { return obj->is_any(); } -pmt_t -make_any(const boost::any &any) -{ - return pmt_t(new pmt_any(any)); -} +pmt_t make_any(const boost::any& any) { return pmt_t(new pmt_any(any)); } -boost::any -any_ref(pmt_t obj) +boost::any any_ref(pmt_t obj) { - if (!obj->is_any()) - throw wrong_type("pmt_any_ref", obj); - return _any(obj)->ref(); + if (!obj->is_any()) + throw wrong_type("pmt_any_ref", obj); + return _any(obj)->ref(); } -void -any_set(pmt_t obj, const boost::any &any) +void any_set(pmt_t obj, const boost::any& any) { - if (!obj->is_any()) - throw wrong_type("pmt_any_set", obj); - _any(obj)->set(any); + if (!obj->is_any()) + throw wrong_type("pmt_any_set", obj); + _any(obj)->set(any); } //////////////////////////////////////////////////////////////////////////// // msg_accepter -- built from "any" //////////////////////////////////////////////////////////////////////////// -bool -is_msg_accepter(const pmt_t &obj) +bool is_msg_accepter(const pmt_t& obj) { - if (!is_any(obj)) - return false; + if (!is_any(obj)) + return false; - boost::any r = any_ref(obj); - return boost::any_cast<gr::messages::msg_accepter_sptr>(&r) != 0; + boost::any r = any_ref(obj); + return boost::any_cast<gr::messages::msg_accepter_sptr>(&r) != 0; } //! make a msg_accepter -pmt_t -make_msg_accepter(gr::messages::msg_accepter_sptr ma) -{ - return make_any(ma); -} +pmt_t make_msg_accepter(gr::messages::msg_accepter_sptr ma) { return make_any(ma); } //! Return underlying msg_accepter -gr::messages::msg_accepter_sptr -msg_accepter_ref(const pmt_t &obj) +gr::messages::msg_accepter_sptr msg_accepter_ref(const pmt_t& obj) { - try { - return boost::any_cast<gr::messages::msg_accepter_sptr>(any_ref(obj)); - } - catch (boost::bad_any_cast &e){ - throw wrong_type("pmt_msg_accepter_ref", obj); - } + try { + return boost::any_cast<gr::messages::msg_accepter_sptr>(any_ref(obj)); + } catch (boost::bad_any_cast& e) { + throw wrong_type("pmt_msg_accepter_ref", obj); + } } @@ -987,31 +801,24 @@ msg_accepter_ref(const pmt_t &obj) // Binary Large Object -- currently a u8vector //////////////////////////////////////////////////////////////////////////// -bool -is_blob(pmt_t x) -{ - return is_u8vector(x); -} +bool is_blob(pmt_t x) { return is_u8vector(x); } -pmt_t -make_blob(const void *buf, size_t len_in_bytes) +pmt_t make_blob(const void* buf, size_t len_in_bytes) { - return init_u8vector(len_in_bytes, (const uint8_t *) buf); + return init_u8vector(len_in_bytes, (const uint8_t*)buf); } -const void * -blob_data(pmt_t blob) +const void* blob_data(pmt_t blob) { - size_t len; - return uniform_vector_elements(blob, len); + size_t len; + return uniform_vector_elements(blob, len); } -size_t -blob_length(pmt_t blob) +size_t blob_length(pmt_t blob) { - size_t len; - uniform_vector_elements(blob, len); - return len; + size_t len; + uniform_vector_elements(blob, len); + return len; } @@ -1019,413 +826,356 @@ blob_length(pmt_t blob) // General Functions //////////////////////////////////////////////////////////////////////////// -bool -eq(const pmt_t& x, const pmt_t& y) -{ - return x == y; -} +bool eq(const pmt_t& x, const pmt_t& y) { return x == y; } -bool -eqv(const pmt_t& x, const pmt_t& y) +bool eqv(const pmt_t& x, const pmt_t& y) { - if (x == y) - return true; + if (x == y) + return true; - if (x->is_integer() && y->is_integer()) - return _integer(x)->value() == _integer(y)->value(); + if (x->is_integer() && y->is_integer()) + return _integer(x)->value() == _integer(y)->value(); - if (x->is_uint64() && y->is_uint64()) - return _uint64(x)->value() == _uint64(y)->value(); + if (x->is_uint64() && y->is_uint64()) + return _uint64(x)->value() == _uint64(y)->value(); - if (x->is_real() && y->is_real()) - return _real(x)->value() == _real(y)->value(); + if (x->is_real() && y->is_real()) + return _real(x)->value() == _real(y)->value(); - if (x->is_complex() && y->is_complex()) - return _complex(x)->value() == _complex(y)->value(); + if (x->is_complex() && y->is_complex()) + return _complex(x)->value() == _complex(y)->value(); - return false; + return false; } -bool -equal(const pmt_t& x, const pmt_t& y) +bool equal(const pmt_t& x, const pmt_t& y) { - if (eqv(x, y)) - return true; + if (eqv(x, y)) + return true; - if (x->is_pair() && y->is_pair()) - return equal(car(x), car(y)) && equal(cdr(x), cdr(y)); + if (x->is_pair() && y->is_pair()) + return equal(car(x), car(y)) && equal(cdr(x), cdr(y)); - if (x->is_vector() && y->is_vector()){ - pmt_vector *xv = _vector(x); - pmt_vector *yv = _vector(y); - if (xv->length() != yv->length()) - return false; + if (x->is_vector() && y->is_vector()) { + pmt_vector* xv = _vector(x); + pmt_vector* yv = _vector(y); + if (xv->length() != yv->length()) + return false; - for (unsigned i = 0; i < xv->length(); i++) - if (!equal(xv->_ref(i), yv->_ref(i))) - return false; + for (unsigned i = 0; i < xv->length(); i++) + if (!equal(xv->_ref(i), yv->_ref(i))) + return false; - return true; - } + return true; + } - if (x->is_tuple() && y->is_tuple()){ - pmt_tuple *xv = _tuple(x); - pmt_tuple *yv = _tuple(y); - if (xv->length() != yv->length()) - return false; + if (x->is_tuple() && y->is_tuple()) { + pmt_tuple* xv = _tuple(x); + pmt_tuple* yv = _tuple(y); + if (xv->length() != yv->length()) + return false; - for (unsigned i = 0; i < xv->length(); i++) - if (!equal(xv->_ref(i), yv->_ref(i))) - return false; + for (unsigned i = 0; i < xv->length(); i++) + if (!equal(xv->_ref(i), yv->_ref(i))) + return false; - return true; - } + return true; + } - if (x->is_uniform_vector() && y->is_uniform_vector()){ - pmt_uniform_vector *xv = _uniform_vector(x); - pmt_uniform_vector *yv = _uniform_vector(y); - if (xv->length() != yv->length()) - return false; + if (x->is_uniform_vector() && y->is_uniform_vector()) { + pmt_uniform_vector* xv = _uniform_vector(x); + pmt_uniform_vector* yv = _uniform_vector(y); + if (xv->length() != yv->length()) + return false; - size_t len_x, len_y; - const void *x_m = xv->uniform_elements(len_x); - const void *y_m = yv->uniform_elements(len_y); - if (memcmp(x_m, y_m, len_x) == 0) - return true; + size_t len_x, len_y; + const void* x_m = xv->uniform_elements(len_x); + const void* y_m = yv->uniform_elements(len_y); + if (memcmp(x_m, y_m, len_x) == 0) + return true; - return false; - } + return false; + } - // FIXME add other cases here... + // FIXME add other cases here... - return false; + return false; } -size_t -length(const pmt_t& x) +size_t length(const pmt_t& x) { - if (x->is_vector()) - return _vector(x)->length(); + if (x->is_vector()) + return _vector(x)->length(); - if (x->is_uniform_vector()) - return _uniform_vector(x)->length(); + if (x->is_uniform_vector()) + return _uniform_vector(x)->length(); - if (x->is_tuple()) - return _tuple(x)->length(); + if (x->is_tuple()) + return _tuple(x)->length(); - if (x->is_null()) - return 0; + if (x->is_null()) + return 0; - if (x->is_pair()) { - size_t length=1; - pmt_t it = cdr(x); - while (is_pair(it)){ - length++; - it = cdr(it); - } - if (is_null(it)) - return length; + if (x->is_pair()) { + size_t length = 1; + pmt_t it = cdr(x); + while (is_pair(it)) { + length++; + it = cdr(it); + } + if (is_null(it)) + return length; - // not a proper list - throw wrong_type("pmt_length", x); - } + // not a proper list + throw wrong_type("pmt_length", x); + } - // FIXME dictionary length (number of entries) + // FIXME dictionary length (number of entries) - throw wrong_type("pmt_length", x); + throw wrong_type("pmt_length", x); } -pmt_t -assq(pmt_t obj, pmt_t alist) +pmt_t assq(pmt_t obj, pmt_t alist) { - while (is_pair(alist)){ - pmt_t p = car(alist); - if (!is_pair(p)) // malformed alist - return PMT_F; + while (is_pair(alist)) { + pmt_t p = car(alist); + if (!is_pair(p)) // malformed alist + return PMT_F; - if (eq(obj, car(p))) - return p; + if (eq(obj, car(p))) + return p; - alist = cdr(alist); - } - return PMT_F; + alist = cdr(alist); + } + return PMT_F; } -pmt_t -assv(pmt_t obj, pmt_t alist) +pmt_t assv(pmt_t obj, pmt_t alist) { - while (is_pair(alist)){ - pmt_t p = car(alist); - if (!is_pair(p)) // malformed alist - return PMT_F; + while (is_pair(alist)) { + pmt_t p = car(alist); + if (!is_pair(p)) // malformed alist + return PMT_F; - if (eqv(obj, car(p))) - return p; + if (eqv(obj, car(p))) + return p; - alist = cdr(alist); - } - return PMT_F; + alist = cdr(alist); + } + return PMT_F; } -pmt_t -assoc(pmt_t obj, pmt_t alist) +pmt_t assoc(pmt_t obj, pmt_t alist) { - while (is_pair(alist)){ - pmt_t p = car(alist); - if (!is_pair(p)) // malformed alist - return PMT_F; + while (is_pair(alist)) { + pmt_t p = car(alist); + if (!is_pair(p)) // malformed alist + return PMT_F; - if (equal(obj, car(p))) - return p; + if (equal(obj, car(p))) + return p; - alist = cdr(alist); - } - return PMT_F; + alist = cdr(alist); + } + return PMT_F; } -pmt_t -map(pmt_t proc(const pmt_t&), pmt_t list) +pmt_t map(pmt_t proc(const pmt_t&), pmt_t list) { - pmt_t r = PMT_NIL; + pmt_t r = PMT_NIL; - while(is_pair(list)){ - r = cons(proc(car(list)), r); - list = cdr(list); - } + while (is_pair(list)) { + r = cons(proc(car(list)), r); + list = cdr(list); + } - return reverse_x(r); + return reverse_x(r); } -pmt_t -reverse(pmt_t listx) +pmt_t reverse(pmt_t listx) { - pmt_t list = listx; - pmt_t r = PMT_NIL; + pmt_t list = listx; + pmt_t r = PMT_NIL; - while(is_pair(list)){ - r = cons(car(list), r); - list = cdr(list); - } - if (is_null(list)) - return r; - else - throw wrong_type("pmt_reverse", listx); + while (is_pair(list)) { + r = cons(car(list), r); + list = cdr(list); + } + if (is_null(list)) + return r; + else + throw wrong_type("pmt_reverse", listx); } -pmt_t -reverse_x(pmt_t list) +pmt_t reverse_x(pmt_t list) { - // FIXME do it destructively - return reverse(list); + // FIXME do it destructively + return reverse(list); } -pmt_t -nth(size_t n, pmt_t list) +pmt_t nth(size_t n, pmt_t list) { - pmt_t t = nthcdr(n, list); - if (is_pair(t)) - return car(t); - else - return PMT_NIL; + pmt_t t = nthcdr(n, list); + if (is_pair(t)) + return car(t); + else + return PMT_NIL; } -pmt_t -nthcdr(size_t n, pmt_t list) +pmt_t nthcdr(size_t n, pmt_t list) { - if (!(is_pair(list) || is_null(list))) - throw wrong_type("pmt_nthcdr", list); + if (!(is_pair(list) || is_null(list))) + throw wrong_type("pmt_nthcdr", list); - while (n > 0){ - if (is_pair(list)){ - list = cdr(list); - n--; - continue; + while (n > 0) { + if (is_pair(list)) { + list = cdr(list); + n--; + continue; + } + if (is_null(list)) + return PMT_NIL; + else + throw wrong_type("pmt_nthcdr: not a LIST", list); } - if (is_null(list)) - return PMT_NIL; - else - throw wrong_type("pmt_nthcdr: not a LIST", list); - } - return list; + return list; } -pmt_t -memq(pmt_t obj, pmt_t list) +pmt_t memq(pmt_t obj, pmt_t list) { - while (is_pair(list)){ - if (eq(obj, car(list))) - return list; - list = cdr(list); - } - return PMT_F; + while (is_pair(list)) { + if (eq(obj, car(list))) + return list; + list = cdr(list); + } + return PMT_F; } -pmt_t -memv(pmt_t obj, pmt_t list) +pmt_t memv(pmt_t obj, pmt_t list) { - while (is_pair(list)){ - if (eqv(obj, car(list))) - return list; - list = cdr(list); - } - return PMT_F; + while (is_pair(list)) { + if (eqv(obj, car(list))) + return list; + list = cdr(list); + } + return PMT_F; } -pmt_t -member(pmt_t obj, pmt_t list) +pmt_t member(pmt_t obj, pmt_t list) { - while (is_pair(list)){ - if (equal(obj, car(list))) - return list; - list = cdr(list); - } - return PMT_F; + while (is_pair(list)) { + if (equal(obj, car(list))) + return list; + list = cdr(list); + } + return PMT_F; } -bool -subsetp(pmt_t list1, pmt_t list2) +bool subsetp(pmt_t list1, pmt_t list2) { - while (is_pair(list1)){ - pmt_t p = car(list1); - if (is_false(memv(p, list2))) - return false; - list1 = cdr(list1); - } - return true; + while (is_pair(list1)) { + pmt_t p = car(list1); + if (is_false(memv(p, list2))) + return false; + list1 = cdr(list1); + } + return true; } -pmt_t -list1(const pmt_t& x1) -{ - return cons(x1, PMT_NIL); -} +pmt_t list1(const pmt_t& x1) { return cons(x1, PMT_NIL); } -pmt_t -list2(const pmt_t& x1, const pmt_t& x2) -{ - return cons(x1, cons(x2, PMT_NIL)); -} +pmt_t list2(const pmt_t& x1, const pmt_t& x2) { return cons(x1, cons(x2, PMT_NIL)); } -pmt_t -list3(const pmt_t& x1, const pmt_t& x2, const pmt_t& x3) +pmt_t list3(const pmt_t& x1, const pmt_t& x2, const pmt_t& x3) { - return cons(x1, cons(x2, cons(x3, PMT_NIL))); + return cons(x1, cons(x2, cons(x3, PMT_NIL))); } -pmt_t -list4(const pmt_t& x1, const pmt_t& x2, const pmt_t& x3, const pmt_t& x4) +pmt_t list4(const pmt_t& x1, const pmt_t& x2, const pmt_t& x3, const pmt_t& x4) { - return cons(x1, cons(x2, cons(x3, cons(x4, PMT_NIL)))); + return cons(x1, cons(x2, cons(x3, cons(x4, PMT_NIL)))); } -pmt_t -list5(const pmt_t& x1, const pmt_t& x2, const pmt_t& x3, const pmt_t& x4, const pmt_t& x5) +pmt_t list5( + const pmt_t& x1, const pmt_t& x2, const pmt_t& x3, const pmt_t& x4, const pmt_t& x5) { - return cons(x1, cons(x2, cons(x3, cons(x4, cons(x5, PMT_NIL))))); + return cons(x1, cons(x2, cons(x3, cons(x4, cons(x5, PMT_NIL))))); } -pmt_t -list6(const pmt_t& x1, const pmt_t& x2, const pmt_t& x3, const pmt_t& x4, const pmt_t& x5, const pmt_t& x6) +pmt_t list6(const pmt_t& x1, + const pmt_t& x2, + const pmt_t& x3, + const pmt_t& x4, + const pmt_t& x5, + const pmt_t& x6) { - return cons(x1, cons(x2, cons(x3, cons(x4, cons(x5, cons(x6, PMT_NIL)))))); + return cons(x1, cons(x2, cons(x3, cons(x4, cons(x5, cons(x6, PMT_NIL)))))); } -pmt_t -list_add(pmt_t list, const pmt_t& item) +pmt_t list_add(pmt_t list, const pmt_t& item) { - return reverse(cons(item, reverse(list))); + return reverse(cons(item, reverse(list))); } -pmt_t -list_rm(pmt_t list, const pmt_t& item) +pmt_t list_rm(pmt_t list, const pmt_t& item) { - if(is_pair(list)){ - pmt_t left = car(list); - pmt_t right = cdr(list); - if(!equal(left, item)){ - return cons(left, list_rm(right, item)); + if (is_pair(list)) { + pmt_t left = car(list); + pmt_t right = cdr(list); + if (!equal(left, item)) { + return cons(left, list_rm(right, item)); } else { - return list_rm(right, item); + return list_rm(right, item); } } else { - return list; + return list; } } -bool -list_has(pmt_t list, const pmt_t& item) +bool list_has(pmt_t list, const pmt_t& item) { - if(is_pair(list)){ - pmt_t left = car(list); - pmt_t right = cdr(list); - if(equal(left,item)) - return true; - return list_has(right, item); - } else { - if(is_null(list)) - return false; - throw std::runtime_error("list contains invalid format!"); - } + if (is_pair(list)) { + pmt_t left = car(list); + pmt_t right = cdr(list); + if (equal(left, item)) + return true; + return list_has(right, item); + } else { + if (is_null(list)) + return false; + throw std::runtime_error("list contains invalid format!"); + } } -pmt_t -caar(pmt_t pair) -{ - return (car(car(pair))); -} +pmt_t caar(pmt_t pair) { return (car(car(pair))); } -pmt_t -cadr(pmt_t pair) -{ - return car(cdr(pair)); -} +pmt_t cadr(pmt_t pair) { return car(cdr(pair)); } -pmt_t -cdar(pmt_t pair) -{ - return cdr(car(pair)); -} +pmt_t cdar(pmt_t pair) { return cdr(car(pair)); } -pmt_t -cddr(pmt_t pair) -{ - return cdr(cdr(pair)); -} +pmt_t cddr(pmt_t pair) { return cdr(cdr(pair)); } -pmt_t -caddr(pmt_t pair) -{ - return car(cdr(cdr(pair))); -} +pmt_t caddr(pmt_t pair) { return car(cdr(cdr(pair))); } -pmt_t -cadddr(pmt_t pair) -{ - return car(cdr(cdr(cdr(pair)))); -} +pmt_t cadddr(pmt_t pair) { return car(cdr(cdr(cdr(pair)))); } -bool -is_eof_object(pmt_t obj) -{ - return eq(obj, PMT_EOF); -} +bool is_eof_object(pmt_t obj) { return eq(obj, PMT_EOF); } -void -dump_sizeof() +void dump_sizeof() { - printf("sizeof(pmt_t) = %3zd\n", sizeof(pmt_t)); - printf("sizeof(pmt_base) = %3zd\n", sizeof(pmt_base)); - printf("sizeof(pmt_bool) = %3zd\n", sizeof(pmt_bool)); - printf("sizeof(pmt_symbol) = %3zd\n", sizeof(pmt_symbol)); - printf("sizeof(pmt_integer) = %3zd\n", sizeof(pmt_integer)); - printf("sizeof(pmt_uint64) = %3zd\n", sizeof(pmt_uint64)); - printf("sizeof(pmt_real) = %3zd\n", sizeof(pmt_real)); - printf("sizeof(pmt_complex) = %3zd\n", sizeof(pmt_complex)); - printf("sizeof(pmt_null) = %3zd\n", sizeof(pmt_null)); - printf("sizeof(pmt_pair) = %3zd\n", sizeof(pmt_pair)); - printf("sizeof(pmt_vector) = %3zd\n", sizeof(pmt_vector)); - printf("sizeof(pmt_uniform_vector) = %3zd\n", sizeof(pmt_uniform_vector)); + printf("sizeof(pmt_t) = %3zd\n", sizeof(pmt_t)); + printf("sizeof(pmt_base) = %3zd\n", sizeof(pmt_base)); + printf("sizeof(pmt_bool) = %3zd\n", sizeof(pmt_bool)); + printf("sizeof(pmt_symbol) = %3zd\n", sizeof(pmt_symbol)); + printf("sizeof(pmt_integer) = %3zd\n", sizeof(pmt_integer)); + printf("sizeof(pmt_uint64) = %3zd\n", sizeof(pmt_uint64)); + printf("sizeof(pmt_real) = %3zd\n", sizeof(pmt_real)); + printf("sizeof(pmt_complex) = %3zd\n", sizeof(pmt_complex)); + printf("sizeof(pmt_null) = %3zd\n", sizeof(pmt_null)); + printf("sizeof(pmt_pair) = %3zd\n", sizeof(pmt_pair)); + printf("sizeof(pmt_vector) = %3zd\n", sizeof(pmt_vector)); + printf("sizeof(pmt_uniform_vector) = %3zd\n", sizeof(pmt_uniform_vector)); } } /* namespace pmt */ diff --git a/gnuradio-runtime/lib/pmt/pmt_int.h b/gnuradio-runtime/lib/pmt/pmt_int.h index 5f02518a62..ea3dd5e2c9 100644 --- a/gnuradio-runtime/lib/pmt/pmt_int.h +++ b/gnuradio-runtime/lib/pmt/pmt_int.h @@ -39,163 +39,166 @@ namespace pmt { class pmt_bool : public pmt_base { public: - pmt_bool(); - //~pmt_bool(){} + pmt_bool(); + //~pmt_bool(){} - bool is_bool() const { return true; } + bool is_bool() const { return true; } }; class pmt_symbol : public pmt_base { - std::string d_name; - pmt_t d_next; + std::string d_name; + pmt_t d_next; public: - pmt_symbol(const std::string &name); - //~pmt_symbol(){} + pmt_symbol(const std::string& name); + //~pmt_symbol(){} - bool is_symbol() const { return true; } - const std::string name() { return d_name; } + bool is_symbol() const { return true; } + const std::string name() { return d_name; } - pmt_t next() { return d_next; } // symbol table link - void set_next(pmt_t next) { d_next = next; } + pmt_t next() { return d_next; } // symbol table link + void set_next(pmt_t next) { d_next = next; } }; class pmt_integer : public pmt_base { public: - long d_value; + long d_value; - pmt_integer(long value); - //~pmt_integer(){} + pmt_integer(long value); + //~pmt_integer(){} - bool is_number() const { return true; } - bool is_integer() const { return true; } - long value() const { return d_value; } + bool is_number() const { return true; } + bool is_integer() const { return true; } + long value() const { return d_value; } }; class pmt_uint64 : public pmt_base { public: - uint64_t d_value; + uint64_t d_value; - pmt_uint64(uint64_t value); - //~pmt_uint64(){} + pmt_uint64(uint64_t value); + //~pmt_uint64(){} - bool is_number() const { return true; } - bool is_uint64() const { return true; } - uint64_t value() const { return d_value; } + bool is_number() const { return true; } + bool is_uint64() const { return true; } + uint64_t value() const { return d_value; } }; class pmt_real : public pmt_base { public: - double d_value; + double d_value; - pmt_real(double value); - //~pmt_real(){} + pmt_real(double value); + //~pmt_real(){} - bool is_number() const { return true; } - bool is_real() const { return true; } - double value() const { return d_value; } + bool is_number() const { return true; } + bool is_real() const { return true; } + double value() const { return d_value; } }; class pmt_complex : public pmt_base { public: - std::complex<double> d_value; + std::complex<double> d_value; - pmt_complex(std::complex<double> value); - //~pmt_complex(){} + pmt_complex(std::complex<double> value); + //~pmt_complex(){} - bool is_number() const { return true; } - bool is_complex() const { return true; } - std::complex<double> value() const { return d_value; } + bool is_number() const { return true; } + bool is_complex() const { return true; } + std::complex<double> value() const { return d_value; } }; -class pmt_null : public pmt_base +class pmt_null : public pmt_base { public: - pmt_null(); - //~pmt_null(){} + pmt_null(); + //~pmt_null(){} - bool is_null() const { return true; } + bool is_null() const { return true; } }; class pmt_pair : public pmt_base { public: - pmt_t d_car; - pmt_t d_cdr; + pmt_t d_car; + pmt_t d_cdr; - pmt_pair(const pmt_t& car, const pmt_t& cdr); - //~pmt_pair(){}; + pmt_pair(const pmt_t& car, const pmt_t& cdr); + //~pmt_pair(){}; - bool is_pair() const { return true; } - pmt_t car() const { return d_car; } - pmt_t cdr() const { return d_cdr; } + bool is_pair() const { return true; } + pmt_t car() const { return d_car; } + pmt_t cdr() const { return d_cdr; } - void set_car(pmt_t car) { d_car = car; } - void set_cdr(pmt_t cdr) { d_cdr = cdr; } + void set_car(pmt_t car) { d_car = car; } + void set_cdr(pmt_t cdr) { d_cdr = cdr; } }; class pmt_vector : public pmt_base { - std::vector<pmt_t> d_v; + std::vector<pmt_t> d_v; public: - pmt_vector(size_t len, pmt_t fill); - //~pmt_vector(); + pmt_vector(size_t len, pmt_t fill); + //~pmt_vector(); - bool is_vector() const { return true; } - pmt_t ref(size_t k) const; - void set(size_t k, pmt_t obj); - void fill(pmt_t fill); - size_t length() const { return d_v.size(); } + bool is_vector() const { return true; } + pmt_t ref(size_t k) const; + void set(size_t k, pmt_t obj); + void fill(pmt_t fill); + size_t length() const { return d_v.size(); } - pmt_t _ref(size_t k) const { return d_v[k]; } + pmt_t _ref(size_t k) const { return d_v[k]; } }; class pmt_tuple : public pmt_base { - std::vector<pmt_t> d_v; + std::vector<pmt_t> d_v; public: - pmt_tuple(size_t len); - //~pmt_tuple(); + pmt_tuple(size_t len); + //~pmt_tuple(); - bool is_tuple() const { return true; } - pmt_t ref(size_t k) const; - size_t length() const { return d_v.size(); } + bool is_tuple() const { return true; } + pmt_t ref(size_t k) const; + size_t length() const { return d_v.size(); } - pmt_t _ref(size_t k) const { return d_v[k]; } - void _set(size_t k, pmt_t v) { d_v[k] = v; } + pmt_t _ref(size_t k) const { return d_v[k]; } + void _set(size_t k, pmt_t v) { d_v[k] = v; } }; class pmt_any : public pmt_base { - boost::any d_any; + boost::any d_any; public: - pmt_any(const boost::any &any); - //~pmt_any(); + pmt_any(const boost::any& any); + //~pmt_any(); - bool is_any() const { return true; } - const boost::any &ref() const { return d_any; } - void set(const boost::any &any) { d_any = any; } + bool is_any() const { return true; } + const boost::any& ref() const { return d_any; } + void set(const boost::any& any) { d_any = any; } }; class pmt_uniform_vector : public pmt_base { public: - bool is_uniform_vector() const { return true; } - virtual const void *uniform_elements(size_t &len) = 0; - virtual void *uniform_writable_elements(size_t &len) = 0; - virtual size_t length() const = 0; - virtual size_t itemsize() const = 0; - virtual const std::string string_ref(size_t k) const { return std::string("not implemented"); } + bool is_uniform_vector() const { return true; } + virtual const void* uniform_elements(size_t& len) = 0; + virtual void* uniform_writable_elements(size_t& len) = 0; + virtual size_t length() const = 0; + virtual size_t itemsize() const = 0; + virtual const std::string string_ref(size_t k) const + { + return std::string("not implemented"); + } }; } /* namespace pmt */ diff --git a/gnuradio-runtime/lib/pmt/pmt_io.cc b/gnuradio-runtime/lib/pmt/pmt_io.cc index e63bae4994..2c39a0872f 100644 --- a/gnuradio-runtime/lib/pmt/pmt_io.cc +++ b/gnuradio-runtime/lib/pmt/pmt_io.cc @@ -31,146 +31,122 @@ namespace pmt { -static void -write_list_tail(pmt_t obj, std::ostream &port) +static void write_list_tail(pmt_t obj, std::ostream& port) { - write(car(obj), port); // write the car - obj = cdr(obj); // step to cdr - - if (is_null(obj)) // () - port << ")"; - - else if (is_pair(obj)){ // normal list - port << " "; - write_list_tail(obj, port); - } - else { // dotted pair - port << " . "; - write(obj, port); - port << ")"; - } + write(car(obj), port); // write the car + obj = cdr(obj); // step to cdr + + if (is_null(obj)) // () + port << ")"; + + else if (is_pair(obj)) { // normal list + port << " "; + write_list_tail(obj, port); + } else { // dotted pair + port << " . "; + write(obj, port); + port << ")"; + } } -void -write(pmt_t obj, std::ostream &port) +void write(pmt_t obj, std::ostream& port) { - if (is_bool(obj)){ - if (is_true(obj)) - port << "#t"; - else - port << "#f"; - } - else if (is_symbol(obj)){ - port << symbol_to_string(obj); - } - else if (is_number(obj)){ - if (is_integer(obj)) - port << to_long(obj); - else if (is_uint64(obj)) - port << to_uint64(obj); - else if (is_real(obj)) - port << to_double(obj); - else if (is_complex(obj)){ - std::complex<double> c = to_complex(obj); - port << c.real() << '+' << c.imag() << 'i'; - } - else - goto error; - } - else if (is_null(obj)){ - port << "()"; - } - else if (is_pair(obj)){ - port << "("; - write_list_tail(obj, port); - } - else if (is_tuple(obj)){ - port << "{"; - size_t len = length(obj); - if (len > 0){ - port << tuple_ref(obj, 0); - for (size_t i = 1; i < len; i++) - port << " " << tuple_ref(obj, i); - } - port << "}"; - } - else if (is_vector(obj)){ - port << "#("; - size_t len = length(obj); - if (len > 0){ - port << vector_ref(obj, 0); - for (size_t i = 1; i < len; i++) - port << " " << vector_ref(obj, i); + if (is_bool(obj)) { + if (is_true(obj)) + port << "#t"; + else + port << "#f"; + } else if (is_symbol(obj)) { + port << symbol_to_string(obj); + } else if (is_number(obj)) { + if (is_integer(obj)) + port << to_long(obj); + else if (is_uint64(obj)) + port << to_uint64(obj); + else if (is_real(obj)) + port << to_double(obj); + else if (is_complex(obj)) { + std::complex<double> c = to_complex(obj); + port << c.real() << '+' << c.imag() << 'i'; + } else + goto error; + } else if (is_null(obj)) { + port << "()"; + } else if (is_pair(obj)) { + port << "("; + write_list_tail(obj, port); + } else if (is_tuple(obj)) { + port << "{"; + size_t len = length(obj); + if (len > 0) { + port << tuple_ref(obj, 0); + for (size_t i = 1; i < len; i++) + port << " " << tuple_ref(obj, i); + } + port << "}"; + } else if (is_vector(obj)) { + port << "#("; + size_t len = length(obj); + if (len > 0) { + port << vector_ref(obj, 0); + for (size_t i = 1; i < len; i++) + port << " " << vector_ref(obj, i); + } + port << ")"; + } else if (is_dict(obj)) { + // FIXME + // port << "#<dict " << obj << ">"; + port << "#<dict>"; + } else if (is_uniform_vector(obj)) { + port << "#["; + size_t len = length(obj); + if (len) { + pmt_uniform_vector* uv = static_cast<pmt_uniform_vector*>(obj.get()); + port << uv->string_ref(0); + for (size_t i = 1; i < len; i++) + port << " " << uv->string_ref(i); + } + port << "]"; + } else { + error: + // FIXME + // port << "#<" << obj << ">"; + port << "#<unknown>"; } - port << ")"; - } - else if (is_dict(obj)){ - // FIXME - // port << "#<dict " << obj << ">"; - port << "#<dict>"; - } - else if (is_uniform_vector(obj)){ - port << "#["; - size_t len = length(obj); - if (len) - { - pmt_uniform_vector *uv = static_cast<pmt_uniform_vector*>(obj.get()); - port << uv->string_ref(0); - for (size_t i = 1; i < len; i++) - port << " " << uv->string_ref(i); - } - port << "]"; - } - else { - error: - // FIXME - // port << "#<" << obj << ">"; - port << "#<unknown>"; - } } -std::ostream& operator<<(std::ostream &os, pmt_t obj) +std::ostream& operator<<(std::ostream& os, pmt_t obj) { - write(obj, os); - return os; + write(obj, os); + return os; } -std::string -write_string(pmt_t obj) +std::string write_string(pmt_t obj) { - std::ostringstream s; - s << obj; - return s.str(); + std::ostringstream s; + s << obj; + return s.str(); } -pmt_t -read(std::istream &port) +pmt_t read(std::istream& port) { - throw notimplemented("notimplemented: pmt::read", PMT_NIL); + throw notimplemented("notimplemented: pmt::read", PMT_NIL); } -void -serialize(pmt_t obj, std::ostream &sink) +void serialize(pmt_t obj, std::ostream& sink) { - throw notimplemented("notimplemented: pmt::serialize", obj); + throw notimplemented("notimplemented: pmt::serialize", obj); } /*! * \brief Create obj from portable byte-serial representation */ -pmt_t -deserialize(std::istream &source) +pmt_t deserialize(std::istream& source) { - throw notimplemented("notimplemented: pmt::deserialize", PMT_NIL); + throw notimplemented("notimplemented: pmt::deserialize", PMT_NIL); } } /* namespace pmt */ -void -pmt::print(pmt_t v) -{ - std::cout << write_string(v) << std::endl; -} - - +void pmt::print(pmt_t v) { std::cout << write_string(v) << std::endl; } diff --git a/gnuradio-runtime/lib/pmt/pmt_pool.cc b/gnuradio-runtime/lib/pmt/pmt_pool.cc index 8864f79dc2..066d31296f 100644 --- a/gnuradio-runtime/lib/pmt/pmt_pool.cc +++ b/gnuradio-runtime/lib/pmt/pmt_pool.cc @@ -29,85 +29,85 @@ namespace pmt { -static inline size_t -ROUNDUP(size_t x, size_t stride) +static inline size_t ROUNDUP(size_t x, size_t stride) { - return ((((x) + (stride) - 1)/(stride)) * (stride)); + return ((((x) + (stride)-1) / (stride)) * (stride)); } -pmt_pool::pmt_pool(size_t itemsize, size_t alignment, - size_t allocation_size, size_t max_items) - : d_itemsize(ROUNDUP(itemsize, alignment)), - d_alignment(alignment), - d_allocation_size(std::max(allocation_size, 16 * itemsize)), - d_max_items(max_items), d_n_items(0), - d_freelist(0) +pmt_pool::pmt_pool(size_t itemsize, + size_t alignment, + size_t allocation_size, + size_t max_items) + : d_itemsize(ROUNDUP(itemsize, alignment)), + d_alignment(alignment), + d_allocation_size(std::max(allocation_size, 16 * itemsize)), + d_max_items(max_items), + d_n_items(0), + d_freelist(0) { } pmt_pool::~pmt_pool() { - for (unsigned int i = 0; i < d_allocations.size(); i++){ - delete [] d_allocations[i]; - } + for (unsigned int i = 0; i < d_allocations.size(); i++) { + delete[] d_allocations[i]; + } } -void * -pmt_pool::malloc() +void* pmt_pool::malloc() { - scoped_lock guard(d_mutex); - item *p; - - if (d_max_items != 0){ - while (d_n_items >= d_max_items) - d_cond.wait(guard); - } - - if (d_freelist){ // got something? + scoped_lock guard(d_mutex); + item* p; + + if (d_max_items != 0) { + while (d_n_items >= d_max_items) + d_cond.wait(guard); + } + + if (d_freelist) { // got something? + p = d_freelist; + d_freelist = p->d_next; + d_n_items++; + return p; + } + + // allocate a new chunk + char* alloc = new char[d_allocation_size + d_alignment - 1]; + d_allocations.push_back(alloc); + + // get the alignment we require + char* start = (char*)(((uintptr_t)alloc + d_alignment - 1) & -d_alignment); + char* end = alloc + d_allocation_size + d_alignment - 1; + size_t n = (end - start) / d_itemsize; + + // link the new items onto the free list. + p = (item*)start; + for (size_t i = 0; i < n; i++) { + p->d_next = d_freelist; + d_freelist = p; + p = (item*)((char*)p + d_itemsize); + } + + // now return the first one p = d_freelist; d_freelist = p->d_next; d_n_items++; return p; - } - - // allocate a new chunk - char *alloc = new char[d_allocation_size + d_alignment - 1]; - d_allocations.push_back(alloc); - - // get the alignment we require - char *start = (char *)(((uintptr_t)alloc + d_alignment-1) & -d_alignment); - char *end = alloc + d_allocation_size + d_alignment - 1; - size_t n = (end - start) / d_itemsize; - - // link the new items onto the free list. - p = (item *) start; - for (size_t i = 0; i < n; i++){ - p->d_next = d_freelist; - d_freelist = p; - p = (item *)((char *) p + d_itemsize); - } - - // now return the first one - p = d_freelist; - d_freelist = p->d_next; - d_n_items++; - return p; } -void -pmt_pool::free(void *foo) +void pmt_pool::free(void* foo) { - if (!foo) - return; + if (!foo) + return; - scoped_lock guard(d_mutex); + scoped_lock guard(d_mutex); - item *p = (item *) foo; - p->d_next = d_freelist; - d_freelist = p; - d_n_items--; - if (d_max_items != 0) - d_cond.notify_one(); + item* p = (item*)foo; + p->d_next = d_freelist; + d_freelist = p; + d_n_items--; + if (d_max_items != 0) + d_cond.notify_one(); } } /* namespace pmt */ diff --git a/gnuradio-runtime/lib/pmt/pmt_serialize.cc b/gnuradio-runtime/lib/pmt/pmt_serialize.cc index e7d61030af..4f77c0378a 100644 --- a/gnuradio-runtime/lib/pmt/pmt_serialize.cc +++ b/gnuradio-runtime/lib/pmt/pmt_serialize.cc @@ -31,68 +31,63 @@ namespace pmt { -static pmt_t parse_pair(std::streambuf &sb); +static pmt_t parse_pair(std::streambuf& sb); // ---------------------------------------------------------------- // output primitives // ---------------------------------------------------------------- -static bool -serialize_untagged_u8(unsigned int i, std::streambuf &sb) +static bool serialize_untagged_u8(unsigned int i, std::streambuf& sb) { - return sb.sputc((i >> 0) & 0xff) != std::streambuf::traits_type::eof(); + return sb.sputc((i >> 0) & 0xff) != std::streambuf::traits_type::eof(); } // always writes big-endian -static bool -serialize_untagged_u16(unsigned int i, std::streambuf &sb) +static bool serialize_untagged_u16(unsigned int i, std::streambuf& sb) { - sb.sputc((i >> 8) & 0xff); - return sb.sputc((i >> 0) & 0xff) != std::streambuf::traits_type::eof(); + sb.sputc((i >> 8) & 0xff); + return sb.sputc((i >> 0) & 0xff) != std::streambuf::traits_type::eof(); } // always writes big-endian -static bool -serialize_untagged_u32(unsigned int i, std::streambuf &sb) +static bool serialize_untagged_u32(unsigned int i, std::streambuf& sb) { - sb.sputc((i >> 24) & 0xff); - sb.sputc((i >> 16) & 0xff); - sb.sputc((i >> 8) & 0xff); - return sb.sputc((i >> 0) & 0xff) != std::streambuf::traits_type::eof(); + sb.sputc((i >> 24) & 0xff); + sb.sputc((i >> 16) & 0xff); + sb.sputc((i >> 8) & 0xff); + return sb.sputc((i >> 0) & 0xff) != std::streambuf::traits_type::eof(); } -static bool -serialize_untagged_f64(double i, std::streambuf &sb) +static bool serialize_untagged_f64(double i, std::streambuf& sb) { - typedef union { - double id; - uint64_t ii; - } iu_t; - iu_t iu; - iu.id = i; - sb.sputc((iu.ii >> 56) & 0xff); - sb.sputc((iu.ii >> 48) & 0xff); - sb.sputc((iu.ii >> 40) & 0xff); - sb.sputc((iu.ii >> 32) & 0xff); - sb.sputc((iu.ii >> 24) & 0xff); - sb.sputc((iu.ii >> 16) & 0xff); - sb.sputc((iu.ii >> 8) & 0xff); - return sb.sputc((iu.ii >> 0) & 0xff) != std::streambuf::traits_type::eof(); + typedef union { + double id; + uint64_t ii; + } iu_t; + iu_t iu; + iu.id = i; + sb.sputc((iu.ii >> 56) & 0xff); + sb.sputc((iu.ii >> 48) & 0xff); + sb.sputc((iu.ii >> 40) & 0xff); + sb.sputc((iu.ii >> 32) & 0xff); + sb.sputc((iu.ii >> 24) & 0xff); + sb.sputc((iu.ii >> 16) & 0xff); + sb.sputc((iu.ii >> 8) & 0xff); + return sb.sputc((iu.ii >> 0) & 0xff) != std::streambuf::traits_type::eof(); } // always writes big-endian -static bool -serialize_untagged_u64(uint64_t i, std::streambuf &sb) +static bool serialize_untagged_u64(uint64_t i, std::streambuf& sb) { - sb.sputc((i >> 56) & 0xff); - sb.sputc((i >> 48) & 0xff); - sb.sputc((i >> 40) & 0xff); - sb.sputc((i >> 32) & 0xff); - sb.sputc((i >> 24) & 0xff); - sb.sputc((i >> 16) & 0xff); - sb.sputc((i >> 8) & 0xff); - return sb.sputc((i >> 0) & 0xff) != std::streambuf::traits_type::eof(); + sb.sputc((i >> 56) & 0xff); + sb.sputc((i >> 48) & 0xff); + sb.sputc((i >> 40) & 0xff); + sb.sputc((i >> 32) & 0xff); + sb.sputc((i >> 24) & 0xff); + sb.sputc((i >> 16) & 0xff); + sb.sputc((i >> 8) & 0xff); + return sb.sputc((i >> 0) & 0xff) != std::streambuf::traits_type::eof(); } // ---------------------------------------------------------------- @@ -101,134 +96,127 @@ serialize_untagged_u64(uint64_t i, std::streambuf &sb) // always reads big-endian -static bool -deserialize_untagged_u8(uint8_t *ip, std::streambuf &sb) +static bool deserialize_untagged_u8(uint8_t* ip, std::streambuf& sb) { - std::streambuf::traits_type::int_type t; - int i; + std::streambuf::traits_type::int_type t; + int i; - t = sb.sbumpc(); - i = t & 0xff; + t = sb.sbumpc(); + i = t & 0xff; - *ip = i; - return t != std::streambuf::traits_type::eof(); + *ip = i; + return t != std::streambuf::traits_type::eof(); } // always reads big-endian -static bool -deserialize_untagged_u16(uint16_t *ip, std::streambuf &sb) +static bool deserialize_untagged_u16(uint16_t* ip, std::streambuf& sb) { - std::streambuf::traits_type::int_type t; - int i; + std::streambuf::traits_type::int_type t; + int i; - t = sb.sbumpc(); - i = t & 0xff; + t = sb.sbumpc(); + i = t & 0xff; - t = sb.sbumpc(); - i = (i << 8) | (t & 0xff); + t = sb.sbumpc(); + i = (i << 8) | (t & 0xff); - *ip = i; - return t != std::streambuf::traits_type::eof(); + *ip = i; + return t != std::streambuf::traits_type::eof(); } // always reads big-endian -static bool -deserialize_untagged_u32(uint32_t *ip, std::streambuf &sb) +static bool deserialize_untagged_u32(uint32_t* ip, std::streambuf& sb) { - std::streambuf::traits_type::int_type t; - int i; + std::streambuf::traits_type::int_type t; + int i; - t = sb.sbumpc(); - i = t & 0xff; + t = sb.sbumpc(); + i = t & 0xff; - t = sb.sbumpc(); - i = (i << 8) | (t & 0xff); - t = sb.sbumpc(); - i = (i << 8) | (t & 0xff); - t = sb.sbumpc(); - i = (i << 8) | (t & 0xff); + t = sb.sbumpc(); + i = (i << 8) | (t & 0xff); + t = sb.sbumpc(); + i = (i << 8) | (t & 0xff); + t = sb.sbumpc(); + i = (i << 8) | (t & 0xff); - *ip = i; - return t != std::streambuf::traits_type::eof(); + *ip = i; + return t != std::streambuf::traits_type::eof(); } // always reads big-endian -static bool -deserialize_untagged_u64(uint64_t *ip, std::streambuf &sb) +static bool deserialize_untagged_u64(uint64_t* ip, std::streambuf& sb) { - std::streambuf::traits_type::int_type t; - uint64_t i; - - t = sb.sbumpc(); - i = t & 0xff; - - t = sb.sbumpc(); - i = (i << 8) | (t & 0xff); - t = sb.sbumpc(); - i = (i << 8) | (t & 0xff); - t = sb.sbumpc(); - i = (i << 8) | (t & 0xff); - t = sb.sbumpc(); - i = (i << 8) | (t & 0xff); - t = sb.sbumpc(); - i = (i << 8) | (t & 0xff); - t = sb.sbumpc(); - i = (i << 8) | (t & 0xff); - t = sb.sbumpc(); - i = (i << 8) | (t & 0xff); - - *ip = i; - return t != std::streambuf::traits_type::eof(); + std::streambuf::traits_type::int_type t; + uint64_t i; + + t = sb.sbumpc(); + i = t & 0xff; + + t = sb.sbumpc(); + i = (i << 8) | (t & 0xff); + t = sb.sbumpc(); + i = (i << 8) | (t & 0xff); + t = sb.sbumpc(); + i = (i << 8) | (t & 0xff); + t = sb.sbumpc(); + i = (i << 8) | (t & 0xff); + t = sb.sbumpc(); + i = (i << 8) | (t & 0xff); + t = sb.sbumpc(); + i = (i << 8) | (t & 0xff); + t = sb.sbumpc(); + i = (i << 8) | (t & 0xff); + + *ip = i; + return t != std::streambuf::traits_type::eof(); } -static bool -deserialize_untagged_f64(double *ip, std::streambuf &sb) +static bool deserialize_untagged_f64(double* ip, std::streambuf& sb) { - std::streambuf::traits_type::int_type t; - - typedef union { - double id; - uint64_t ii; - } iu_t; - - iu_t iu; - - t = sb.sbumpc(); - iu.ii = t & 0xff; - - t = sb.sbumpc(); - iu.ii = (iu.ii<<8) | (t & 0xff); - t = sb.sbumpc(); - iu.ii = (iu.ii<<8) | (t & 0xff); - t = sb.sbumpc(); - iu.ii = (iu.ii<<8) | (t & 0xff); - t = sb.sbumpc(); - iu.ii = (iu.ii<<8) | (t & 0xff); - t = sb.sbumpc(); - iu.ii = (iu.ii<<8) | (t & 0xff); - t = sb.sbumpc(); - iu.ii = (iu.ii<<8) | (t & 0xff); - t = sb.sbumpc(); - iu.ii = (iu.ii<<8) | (t & 0xff); - - *ip = iu.id; - return t != std::streambuf::traits_type::eof(); + std::streambuf::traits_type::int_type t; + + typedef union { + double id; + uint64_t ii; + } iu_t; + + iu_t iu; + + t = sb.sbumpc(); + iu.ii = t & 0xff; + + t = sb.sbumpc(); + iu.ii = (iu.ii << 8) | (t & 0xff); + t = sb.sbumpc(); + iu.ii = (iu.ii << 8) | (t & 0xff); + t = sb.sbumpc(); + iu.ii = (iu.ii << 8) | (t & 0xff); + t = sb.sbumpc(); + iu.ii = (iu.ii << 8) | (t & 0xff); + t = sb.sbumpc(); + iu.ii = (iu.ii << 8) | (t & 0xff); + t = sb.sbumpc(); + iu.ii = (iu.ii << 8) | (t & 0xff); + t = sb.sbumpc(); + iu.ii = (iu.ii << 8) | (t & 0xff); + + *ip = iu.id; + return t != std::streambuf::traits_type::eof(); } -static bool -deserialize_tuple(pmt_t *tuple, std::streambuf &sb) +static bool deserialize_tuple(pmt_t* tuple, std::streambuf& sb) { uint32_t nitems; bool ok = deserialize_untagged_u32(&nitems, sb); pmt_t list(PMT_NIL); - for(uint32_t i=0; i<nitems; i++) { - pmt_t item = deserialize(sb); - if(eq(list, PMT_NIL)) { - list = list1(item); - } - else { - list = list_add(list, item); - } + for (uint32_t i = 0; i < nitems; i++) { + pmt_t item = deserialize(sb); + if (eq(list, PMT_NIL)) { + list = list1(item); + } else { + list = list_add(list, item); + } } (*tuple) = to_tuple(list); return ok; @@ -240,283 +228,284 @@ deserialize_tuple(pmt_t *tuple, std::streambuf &sb) * * N.B., Circular structures cause infinite recursion. */ -bool -serialize(pmt_t obj, std::streambuf &sb) +bool serialize(pmt_t obj, std::streambuf& sb) { - bool ok = true; - - tail_recursion: - - if(is_bool(obj)) { - if(eq(obj, PMT_T)) - return serialize_untagged_u8(PST_TRUE, sb); - else - return serialize_untagged_u8(PST_FALSE, sb); - } - - if(is_null(obj)) - return serialize_untagged_u8(PST_NULL, sb); - - if(is_symbol(obj)) { - const std::string s = symbol_to_string(obj); - size_t len = s.size(); - ok = serialize_untagged_u8(PST_SYMBOL, sb); - ok &= serialize_untagged_u16(len, sb); - for(size_t i = 0; i < len; i++) - ok &= serialize_untagged_u8(s[i], sb); - return ok; - } - - if(is_pair(obj)) { - ok = serialize_untagged_u8(PST_PAIR, sb); - ok &= serialize(car(obj), sb); - if(!ok) - return false; - obj = cdr(obj); - goto tail_recursion; - } - - if(is_number(obj)) { - - if(is_uint64(obj)) { - uint64_t i = to_uint64(obj); - ok = serialize_untagged_u8(PST_UINT64, sb); - ok &= serialize_untagged_u64(i, sb); - return ok; + bool ok = true; + +tail_recursion: + + if (is_bool(obj)) { + if (eq(obj, PMT_T)) + return serialize_untagged_u8(PST_TRUE, sb); + else + return serialize_untagged_u8(PST_FALSE, sb); } - else { - if(is_integer(obj)) { - long i = to_long(obj); - if((sizeof(long) > 4) && ((i < std::numeric_limits<std::int32_t>::min() || i > std::numeric_limits<std::int32_t>::max()))) { - // Serializing as 4 bytes won't work for this value, serialize as 8 bytes - ok = serialize_untagged_u8(PST_INT64, sb); - ok &= serialize_untagged_u64(i, sb); - } else { - ok = serialize_untagged_u8(PST_INT32, sb); - ok &= serialize_untagged_u32(i, sb); - } + + if (is_null(obj)) + return serialize_untagged_u8(PST_NULL, sb); + + if (is_symbol(obj)) { + const std::string s = symbol_to_string(obj); + size_t len = s.size(); + ok = serialize_untagged_u8(PST_SYMBOL, sb); + ok &= serialize_untagged_u16(len, sb); + for (size_t i = 0; i < len; i++) + ok &= serialize_untagged_u8(s[i], sb); return ok; - } } - if(is_real(obj)) { - double i = to_double(obj); - ok = serialize_untagged_u8(PST_DOUBLE, sb); - ok &= serialize_untagged_f64(i, sb); - return ok; + if (is_pair(obj)) { + ok = serialize_untagged_u8(PST_PAIR, sb); + ok &= serialize(car(obj), sb); + if (!ok) + return false; + obj = cdr(obj); + goto tail_recursion; } - if(is_complex(obj)) { - std::complex<double> i = to_complex(obj); - ok = serialize_untagged_u8(PST_COMPLEX, sb); - ok &= serialize_untagged_f64(i.real(), sb); - ok &= serialize_untagged_f64(i.imag(), sb); - return ok; - } - } - - if(is_vector(obj)) { - size_t vec_len = pmt::length(obj); - ok = serialize_untagged_u8(PST_VECTOR, sb); - ok &= serialize_untagged_u32(vec_len, sb); - for(size_t i=0; i<vec_len; i++) { - ok &= serialize(vector_ref(obj, i), sb); - } - return ok; - } - - if(is_uniform_vector(obj)) { - size_t npad = 1; - size_t vec_len = pmt::length(obj); - - if(is_u8vector(obj)) { - ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); - ok &= serialize_untagged_u8(UVI_U8, sb); - ok &= serialize_untagged_u32(vec_len, sb); - ok &= serialize_untagged_u8(npad, sb); - for(size_t i=0; i<npad; i++) { - ok &= serialize_untagged_u8(0, sb); - } - for(size_t i=0; i<vec_len; i++) { - ok &= serialize_untagged_u8(u8vector_ref(obj, i), sb); - } - return ok; - } + if (is_number(obj)) { - if(is_s8vector(obj)) { - ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); - ok &= serialize_untagged_u8(UVI_S8, sb); - ok &= serialize_untagged_u32(vec_len, sb); - ok &= serialize_untagged_u8(npad, sb); - for(size_t i=0; i<npad; i++) { - ok &= serialize_untagged_u8(0, sb); - } - for(size_t i=0; i<vec_len; i++) { - ok &= serialize_untagged_u8(s8vector_ref(obj, i), sb); - } - return ok; - } + if (is_uint64(obj)) { + uint64_t i = to_uint64(obj); + ok = serialize_untagged_u8(PST_UINT64, sb); + ok &= serialize_untagged_u64(i, sb); + return ok; + } else { + if (is_integer(obj)) { + long i = to_long(obj); + if ((sizeof(long) > 4) && + ((i < std::numeric_limits<std::int32_t>::min() || + i > std::numeric_limits<std::int32_t>::max()))) { + // Serializing as 4 bytes won't work for this value, serialize as 8 + // bytes + ok = serialize_untagged_u8(PST_INT64, sb); + ok &= serialize_untagged_u64(i, sb); + } else { + ok = serialize_untagged_u8(PST_INT32, sb); + ok &= serialize_untagged_u32(i, sb); + } + return ok; + } + } - if(is_u16vector(obj)) { - ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); - ok &= serialize_untagged_u8(UVI_U16, sb); - ok &= serialize_untagged_u32(vec_len, sb); - ok &= serialize_untagged_u8(npad, sb); - for(size_t i=0; i<npad; i++) { - ok &= serialize_untagged_u8(0, sb); - } - for(size_t i=0; i<vec_len; i++) { - ok &= serialize_untagged_u16(u16vector_ref(obj, i), sb); - } - return ok; - } + if (is_real(obj)) { + double i = to_double(obj); + ok = serialize_untagged_u8(PST_DOUBLE, sb); + ok &= serialize_untagged_f64(i, sb); + return ok; + } - if(is_s16vector(obj)) { - ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); - ok &= serialize_untagged_u8(UVI_S16, sb); - ok &= serialize_untagged_u32(vec_len, sb); - ok &= serialize_untagged_u8(npad, sb); - for(size_t i=0; i<npad; i++) { - ok &= serialize_untagged_u8(0, sb); - } - for(size_t i=0; i<vec_len; i++) { - ok &= serialize_untagged_u16(s16vector_ref(obj, i), sb); - } - return ok; + if (is_complex(obj)) { + std::complex<double> i = to_complex(obj); + ok = serialize_untagged_u8(PST_COMPLEX, sb); + ok &= serialize_untagged_f64(i.real(), sb); + ok &= serialize_untagged_f64(i.imag(), sb); + return ok; + } } - if(is_u32vector(obj)) { - ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); - ok &= serialize_untagged_u8(UVI_U32, sb); - ok &= serialize_untagged_u32(vec_len, sb); - ok &= serialize_untagged_u8(npad, sb); - for(size_t i=0; i<npad; i++) { - ok &= serialize_untagged_u8(0, sb); - } - for(size_t i=0; i<vec_len; i++) { - ok &= serialize_untagged_u32(u32vector_ref(obj, i), sb); - } - return ok; + if (is_vector(obj)) { + size_t vec_len = pmt::length(obj); + ok = serialize_untagged_u8(PST_VECTOR, sb); + ok &= serialize_untagged_u32(vec_len, sb); + for (size_t i = 0; i < vec_len; i++) { + ok &= serialize(vector_ref(obj, i), sb); + } + return ok; } - if(is_s32vector(obj)) { - ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); - ok &= serialize_untagged_u8(UVI_S32, sb); - ok &= serialize_untagged_u32(vec_len, sb); - ok &= serialize_untagged_u8(npad, sb); - for(size_t i=0; i<npad; i++) { - ok &= serialize_untagged_u8(0, sb); - } - for(size_t i=0; i<vec_len; i++) { - ok &= serialize_untagged_u32(s32vector_ref(obj, i), sb); - } - return ok; - } + if (is_uniform_vector(obj)) { + size_t npad = 1; + size_t vec_len = pmt::length(obj); + + if (is_u8vector(obj)) { + ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); + ok &= serialize_untagged_u8(UVI_U8, sb); + ok &= serialize_untagged_u32(vec_len, sb); + ok &= serialize_untagged_u8(npad, sb); + for (size_t i = 0; i < npad; i++) { + ok &= serialize_untagged_u8(0, sb); + } + for (size_t i = 0; i < vec_len; i++) { + ok &= serialize_untagged_u8(u8vector_ref(obj, i), sb); + } + return ok; + } - if(is_u64vector(obj)) { - ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); - ok &= serialize_untagged_u8(UVI_U64, sb); - ok &= serialize_untagged_u32(vec_len, sb); - ok &= serialize_untagged_u8(npad, sb); - for(size_t i=0; i<npad; i++) { - ok &= serialize_untagged_u8(0, sb); - } - for(size_t i=0; i<vec_len; i++) { - ok &= serialize_untagged_u64(u64vector_ref(obj, i), sb); - } - return ok; - } + if (is_s8vector(obj)) { + ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); + ok &= serialize_untagged_u8(UVI_S8, sb); + ok &= serialize_untagged_u32(vec_len, sb); + ok &= serialize_untagged_u8(npad, sb); + for (size_t i = 0; i < npad; i++) { + ok &= serialize_untagged_u8(0, sb); + } + for (size_t i = 0; i < vec_len; i++) { + ok &= serialize_untagged_u8(s8vector_ref(obj, i), sb); + } + return ok; + } - if(is_s64vector(obj)) { - ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); - ok &= serialize_untagged_u8(UVI_S64, sb); - ok &= serialize_untagged_u32(vec_len, sb); - ok &= serialize_untagged_u8(npad, sb); - for(size_t i=0; i<npad; i++) { - ok &= serialize_untagged_u8(0, sb); - } - for(size_t i=0; i<vec_len; i++) { - ok &= serialize_untagged_u64(s64vector_ref(obj, i), sb); - } - return ok; - } + if (is_u16vector(obj)) { + ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); + ok &= serialize_untagged_u8(UVI_U16, sb); + ok &= serialize_untagged_u32(vec_len, sb); + ok &= serialize_untagged_u8(npad, sb); + for (size_t i = 0; i < npad; i++) { + ok &= serialize_untagged_u8(0, sb); + } + for (size_t i = 0; i < vec_len; i++) { + ok &= serialize_untagged_u16(u16vector_ref(obj, i), sb); + } + return ok; + } - if(is_f32vector(obj)) { - ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); - ok &= serialize_untagged_u8(UVI_F32, sb); - ok &= serialize_untagged_u32(vec_len, sb); - ok &= serialize_untagged_u8(npad, sb); - for(size_t i=0; i<npad; i++) { - ok &= serialize_untagged_u8(0, sb); - } - for(size_t i=0; i<vec_len; i++) { - ok &= serialize_untagged_f64(f32vector_ref(obj, i), sb); - } - return ok; - } + if (is_s16vector(obj)) { + ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); + ok &= serialize_untagged_u8(UVI_S16, sb); + ok &= serialize_untagged_u32(vec_len, sb); + ok &= serialize_untagged_u8(npad, sb); + for (size_t i = 0; i < npad; i++) { + ok &= serialize_untagged_u8(0, sb); + } + for (size_t i = 0; i < vec_len; i++) { + ok &= serialize_untagged_u16(s16vector_ref(obj, i), sb); + } + return ok; + } - if(is_f64vector(obj)) { - ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); - ok &= serialize_untagged_u8(UVI_F64, sb); - ok &= serialize_untagged_u32(vec_len, sb); - ok &= serialize_untagged_u8(npad, sb); - for(size_t i=0; i<npad; i++) { - ok &= serialize_untagged_u8(0, sb); - } - for(size_t i=0; i<vec_len; i++) { - ok &= serialize_untagged_f64(f64vector_ref(obj, i), sb); - } - return ok; - } + if (is_u32vector(obj)) { + ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); + ok &= serialize_untagged_u8(UVI_U32, sb); + ok &= serialize_untagged_u32(vec_len, sb); + ok &= serialize_untagged_u8(npad, sb); + for (size_t i = 0; i < npad; i++) { + ok &= serialize_untagged_u8(0, sb); + } + for (size_t i = 0; i < vec_len; i++) { + ok &= serialize_untagged_u32(u32vector_ref(obj, i), sb); + } + return ok; + } - if(is_c32vector(obj)) { - ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); - ok &= serialize_untagged_u8(UVI_C32, sb); - ok &= serialize_untagged_u32(vec_len, sb); - ok &= serialize_untagged_u8(npad, sb); - for(size_t i=0; i<npad; i++) { - ok &= serialize_untagged_u8(0, sb); - } - for(size_t i=0; i<vec_len; i++) { - std::complex<float> c = c32vector_ref(obj, i); - ok &= serialize_untagged_f64(c.real(), sb); - ok &= serialize_untagged_f64(c.imag(), sb); - } - return ok; - } + if (is_s32vector(obj)) { + ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); + ok &= serialize_untagged_u8(UVI_S32, sb); + ok &= serialize_untagged_u32(vec_len, sb); + ok &= serialize_untagged_u8(npad, sb); + for (size_t i = 0; i < npad; i++) { + ok &= serialize_untagged_u8(0, sb); + } + for (size_t i = 0; i < vec_len; i++) { + ok &= serialize_untagged_u32(s32vector_ref(obj, i), sb); + } + return ok; + } + + if (is_u64vector(obj)) { + ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); + ok &= serialize_untagged_u8(UVI_U64, sb); + ok &= serialize_untagged_u32(vec_len, sb); + ok &= serialize_untagged_u8(npad, sb); + for (size_t i = 0; i < npad; i++) { + ok &= serialize_untagged_u8(0, sb); + } + for (size_t i = 0; i < vec_len; i++) { + ok &= serialize_untagged_u64(u64vector_ref(obj, i), sb); + } + return ok; + } + + if (is_s64vector(obj)) { + ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); + ok &= serialize_untagged_u8(UVI_S64, sb); + ok &= serialize_untagged_u32(vec_len, sb); + ok &= serialize_untagged_u8(npad, sb); + for (size_t i = 0; i < npad; i++) { + ok &= serialize_untagged_u8(0, sb); + } + for (size_t i = 0; i < vec_len; i++) { + ok &= serialize_untagged_u64(s64vector_ref(obj, i), sb); + } + return ok; + } + + if (is_f32vector(obj)) { + ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); + ok &= serialize_untagged_u8(UVI_F32, sb); + ok &= serialize_untagged_u32(vec_len, sb); + ok &= serialize_untagged_u8(npad, sb); + for (size_t i = 0; i < npad; i++) { + ok &= serialize_untagged_u8(0, sb); + } + for (size_t i = 0; i < vec_len; i++) { + ok &= serialize_untagged_f64(f32vector_ref(obj, i), sb); + } + return ok; + } - if(is_c64vector(obj)) { - ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); - ok &= serialize_untagged_u8(UVI_C64, sb); - ok &= serialize_untagged_u32(vec_len, sb); - ok &= serialize_untagged_u8(npad, sb); - for(size_t i=0; i<npad; i++) { - ok &= serialize_untagged_u8(0, sb); - } - for(size_t i=0; i<vec_len; i++) { - std::complex<double> c = c64vector_ref(obj, i); - ok &= serialize_untagged_f64(c.real(), sb); - ok &= serialize_untagged_f64(c.imag(), sb); - } - return ok; + if (is_f64vector(obj)) { + ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); + ok &= serialize_untagged_u8(UVI_F64, sb); + ok &= serialize_untagged_u32(vec_len, sb); + ok &= serialize_untagged_u8(npad, sb); + for (size_t i = 0; i < npad; i++) { + ok &= serialize_untagged_u8(0, sb); + } + for (size_t i = 0; i < vec_len; i++) { + ok &= serialize_untagged_f64(f64vector_ref(obj, i), sb); + } + return ok; + } + + if (is_c32vector(obj)) { + ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); + ok &= serialize_untagged_u8(UVI_C32, sb); + ok &= serialize_untagged_u32(vec_len, sb); + ok &= serialize_untagged_u8(npad, sb); + for (size_t i = 0; i < npad; i++) { + ok &= serialize_untagged_u8(0, sb); + } + for (size_t i = 0; i < vec_len; i++) { + std::complex<float> c = c32vector_ref(obj, i); + ok &= serialize_untagged_f64(c.real(), sb); + ok &= serialize_untagged_f64(c.imag(), sb); + } + return ok; + } + + if (is_c64vector(obj)) { + ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); + ok &= serialize_untagged_u8(UVI_C64, sb); + ok &= serialize_untagged_u32(vec_len, sb); + ok &= serialize_untagged_u8(npad, sb); + for (size_t i = 0; i < npad; i++) { + ok &= serialize_untagged_u8(0, sb); + } + for (size_t i = 0; i < vec_len; i++) { + std::complex<double> c = c64vector_ref(obj, i); + ok &= serialize_untagged_f64(c.real(), sb); + ok &= serialize_untagged_f64(c.imag(), sb); + } + return ok; + } } - } - if (is_dict(obj)) - throw notimplemented("pmt::serialize (dict)", obj); + if (is_dict(obj)) + throw notimplemented("pmt::serialize (dict)", obj); - if (is_tuple(obj)){ - size_t tuple_len = pmt::length(obj); - ok = serialize_untagged_u8(PST_TUPLE, sb); - ok &= serialize_untagged_u32(tuple_len, sb); - for(size_t i=0; i<tuple_len; i++){ - ok &= serialize(tuple_ref(obj, i), sb); + if (is_tuple(obj)) { + size_t tuple_len = pmt::length(obj); + ok = serialize_untagged_u8(PST_TUPLE, sb); + ok &= serialize_untagged_u32(tuple_len, sb); + for (size_t i = 0; i < tuple_len; i++) { + ok &= serialize(tuple_ref(obj, i), sb); + } + return ok; } - return ok; - } - //throw pmt_notimplemented("pmt::serialize (tuple)", obj); + // throw pmt_notimplemented("pmt::serialize (tuple)", obj); - throw notimplemented("pmt::serialize (?)", obj); + throw notimplemented("pmt::serialize (?)", obj); } /* @@ -525,266 +514,247 @@ serialize(pmt_t obj, std::streambuf &sb) * Returns next obj from streambuf, or PMT_EOF at end of file. * Throws exception on malformed input. */ -pmt_t -deserialize(std::streambuf &sb) +pmt_t deserialize(std::streambuf& sb) { - uint8_t tag; - uint8_t u8; - uint16_t u16; - uint32_t u32; - uint64_t u64; - double f64; - char tmpbuf[1024]; - - if (!deserialize_untagged_u8(&tag, sb)) - return PMT_EOF; - - switch (tag){ - case PST_TRUE: - return PMT_T; - - case PST_FALSE: - return PMT_F; - - case PST_NULL: - return PMT_NIL; - - case PST_SYMBOL: - if (!deserialize_untagged_u16(&u16, sb)) - goto error; - if (u16 > sizeof(tmpbuf)) - throw notimplemented("pmt::deserialize: very long symbol", - PMT_F); - if (sb.sgetn(tmpbuf, u16) != u16) - goto error; - return intern(std::string(tmpbuf, u16)); - - case PST_INT32: - if (!deserialize_untagged_u32(&u32, sb)) - goto error; - return from_long((int32_t) u32); - - case PST_UINT64: - if(!deserialize_untagged_u64(&u64, sb)) - goto error; - return from_uint64(u64); - - case PST_INT64: - if(!deserialize_untagged_u64(&u64, sb)) - goto error; - return from_long(u64); - - case PST_PAIR: - return parse_pair(sb); - - case PST_DOUBLE: - if(!deserialize_untagged_f64(&f64, sb)) - goto error; - return from_double( f64 ); - - case PST_COMPLEX: - { - double r,i; - if(!deserialize_untagged_f64(&r, sb) || !deserialize_untagged_f64(&i, sb)) - goto error; - return make_rectangular( r,i ); + uint8_t tag; + uint8_t u8; + uint16_t u16; + uint32_t u32; + uint64_t u64; + double f64; + char tmpbuf[1024]; + + if (!deserialize_untagged_u8(&tag, sb)) + return PMT_EOF; + + switch (tag) { + case PST_TRUE: + return PMT_T; + + case PST_FALSE: + return PMT_F; + + case PST_NULL: + return PMT_NIL; + + case PST_SYMBOL: + if (!deserialize_untagged_u16(&u16, sb)) + goto error; + if (u16 > sizeof(tmpbuf)) + throw notimplemented("pmt::deserialize: very long symbol", PMT_F); + if (sb.sgetn(tmpbuf, u16) != u16) + goto error; + return intern(std::string(tmpbuf, u16)); + + case PST_INT32: + if (!deserialize_untagged_u32(&u32, sb)) + goto error; + return from_long((int32_t)u32); + + case PST_UINT64: + if (!deserialize_untagged_u64(&u64, sb)) + goto error; + return from_uint64(u64); + + case PST_INT64: + if (!deserialize_untagged_u64(&u64, sb)) + goto error; + return from_long(u64); + + case PST_PAIR: + return parse_pair(sb); + + case PST_DOUBLE: + if (!deserialize_untagged_f64(&f64, sb)) + goto error; + return from_double(f64); + + case PST_COMPLEX: { + double r, i; + if (!deserialize_untagged_f64(&r, sb) || !deserialize_untagged_f64(&i, sb)) + goto error; + return make_rectangular(r, i); } - case PST_TUPLE: - { - pmt_t tuple; - if(!deserialize_tuple(&tuple, sb)){ - goto error; - } - return tuple; + case PST_TUPLE: { + pmt_t tuple; + if (!deserialize_tuple(&tuple, sb)) { + goto error; + } + return tuple; } - case PST_VECTOR: - { - uint32_t nitems; - if(!deserialize_untagged_u32(&nitems, sb)) - goto error; - pmt_t vec = make_vector(nitems, PMT_NIL); - for(uint32_t i=0; i<nitems; i++) { - pmt_t item = deserialize(sb); - vector_set(vec, i, item); - } - return vec; + case PST_VECTOR: { + uint32_t nitems; + if (!deserialize_untagged_u32(&nitems, sb)) + goto error; + pmt_t vec = make_vector(nitems, PMT_NIL); + for (uint32_t i = 0; i < nitems; i++) { + pmt_t item = deserialize(sb); + vector_set(vec, i, item); + } + return vec; } - case PST_UNIFORM_VECTOR: - { - uint8_t utag, npad; - uint32_t nitems; - - if(!deserialize_untagged_u8(&utag, sb)) - return PMT_EOF; - - if(!deserialize_untagged_u32(&nitems, sb)) - goto error; - - deserialize_untagged_u8(&npad, sb); - for(size_t i = 0; i < npad; i++) - deserialize_untagged_u8(&u8, sb); - - switch(utag) { - case(UVI_U8): - { - pmt_t vec = make_u8vector(nitems, 0); - for(uint32_t i=0; i<nitems; i++) { - deserialize_untagged_u8(&u8, sb); - u8vector_set(vec, i, u8); - } - return vec; - } - case(UVI_S8): - { - pmt_t vec = make_s8vector(nitems, 0); - for(uint32_t i=0; i<nitems; i++) { - deserialize_untagged_u8(&u8, sb); - s8vector_set(vec, i, u8); - } - return vec; - } - case(UVI_U16): - { - pmt_t vec = make_u16vector(nitems, 0); - for(uint32_t i=0; i<nitems; i++) { - deserialize_untagged_u16(&u16, sb); - u16vector_set(vec, i, u16); - } - return vec; - } - case(UVI_S16): - { - pmt_t vec = make_s16vector(nitems, 0); - for(uint32_t i=0; i<nitems; i++) { - deserialize_untagged_u16(&u16, sb); - s16vector_set(vec, i, u16); - } - return vec; - } - case(UVI_U32): - { - pmt_t vec = make_u32vector(nitems, 0); - for(uint32_t i=0; i<nitems; i++) { - deserialize_untagged_u32(&u32, sb); - u32vector_set(vec, i, u32); - } - return vec; - } - case(UVI_S32): - { - pmt_t vec = make_s32vector(nitems, 0); - for(uint32_t i=0; i<nitems; i++) { - deserialize_untagged_u32(&u32, sb); - s32vector_set(vec, i, u32); - } - return vec; - } - case(UVI_U64): - { - pmt_t vec = make_u64vector(nitems, 0); - for(uint32_t i=0; i<nitems; i++) { - deserialize_untagged_u64(&u64, sb); - u64vector_set(vec, i, u64); - } - return vec; - } - case(UVI_S64): - { - pmt_t vec = make_s64vector(nitems, 0); - for(uint32_t i=0; i<nitems; i++) { - deserialize_untagged_u64(&u64, sb); - s64vector_set(vec, i, u64); - } - return vec; - } - case(UVI_F32): - { - pmt_t vec = make_f32vector(nitems, 0); - for(uint32_t i=0; i<nitems; i++) { - deserialize_untagged_f64(&f64, sb); - f32vector_set(vec, i, static_cast<float>(f64)); - } - return vec; - } - case(UVI_F64): - { - pmt_t vec = make_f64vector(nitems, 0); - for(uint32_t i=0; i<nitems; i++) { - deserialize_untagged_f64(&f64, sb); - f64vector_set(vec, i, f64); - } - return vec; - } - case(UVI_C32): - { - pmt_t vec = make_c32vector(nitems, 0); - for(uint32_t i=0; i<nitems; i++) { - float re, im; - deserialize_untagged_f64(&f64, sb); - re = static_cast<float>(f64); - deserialize_untagged_f64(&f64, sb); - im = static_cast<float>(f64); - c32vector_set(vec, i, std::complex<float>(re, im)); - } - return vec; - } - - case(UVI_C64): - { - pmt_t vec = make_c64vector(nitems, 0); - for(uint32_t i=0; i<nitems; i++) { - double re, im; - deserialize_untagged_f64(&f64, sb); - re = f64; - deserialize_untagged_f64(&f64, sb); - im = f64; - c64vector_set(vec, i, std::complex<double>(re, im)); - } - return vec; - } - - default: - throw exception("pmt::deserialize: malformed input stream, tag value = ", - from_long(tag)); - } + case PST_UNIFORM_VECTOR: { + uint8_t utag, npad; + uint32_t nitems; + + if (!deserialize_untagged_u8(&utag, sb)) + return PMT_EOF; + + if (!deserialize_untagged_u32(&nitems, sb)) + goto error; + + deserialize_untagged_u8(&npad, sb); + for (size_t i = 0; i < npad; i++) + deserialize_untagged_u8(&u8, sb); + + switch (utag) { + case (UVI_U8): { + pmt_t vec = make_u8vector(nitems, 0); + for (uint32_t i = 0; i < nitems; i++) { + deserialize_untagged_u8(&u8, sb); + u8vector_set(vec, i, u8); + } + return vec; + } + case (UVI_S8): { + pmt_t vec = make_s8vector(nitems, 0); + for (uint32_t i = 0; i < nitems; i++) { + deserialize_untagged_u8(&u8, sb); + s8vector_set(vec, i, u8); + } + return vec; + } + case (UVI_U16): { + pmt_t vec = make_u16vector(nitems, 0); + for (uint32_t i = 0; i < nitems; i++) { + deserialize_untagged_u16(&u16, sb); + u16vector_set(vec, i, u16); + } + return vec; + } + case (UVI_S16): { + pmt_t vec = make_s16vector(nitems, 0); + for (uint32_t i = 0; i < nitems; i++) { + deserialize_untagged_u16(&u16, sb); + s16vector_set(vec, i, u16); + } + return vec; + } + case (UVI_U32): { + pmt_t vec = make_u32vector(nitems, 0); + for (uint32_t i = 0; i < nitems; i++) { + deserialize_untagged_u32(&u32, sb); + u32vector_set(vec, i, u32); + } + return vec; + } + case (UVI_S32): { + pmt_t vec = make_s32vector(nitems, 0); + for (uint32_t i = 0; i < nitems; i++) { + deserialize_untagged_u32(&u32, sb); + s32vector_set(vec, i, u32); + } + return vec; + } + case (UVI_U64): { + pmt_t vec = make_u64vector(nitems, 0); + for (uint32_t i = 0; i < nitems; i++) { + deserialize_untagged_u64(&u64, sb); + u64vector_set(vec, i, u64); + } + return vec; + } + case (UVI_S64): { + pmt_t vec = make_s64vector(nitems, 0); + for (uint32_t i = 0; i < nitems; i++) { + deserialize_untagged_u64(&u64, sb); + s64vector_set(vec, i, u64); + } + return vec; + } + case (UVI_F32): { + pmt_t vec = make_f32vector(nitems, 0); + for (uint32_t i = 0; i < nitems; i++) { + deserialize_untagged_f64(&f64, sb); + f32vector_set(vec, i, static_cast<float>(f64)); + } + return vec; + } + case (UVI_F64): { + pmt_t vec = make_f64vector(nitems, 0); + for (uint32_t i = 0; i < nitems; i++) { + deserialize_untagged_f64(&f64, sb); + f64vector_set(vec, i, f64); + } + return vec; + } + case (UVI_C32): { + pmt_t vec = make_c32vector(nitems, 0); + for (uint32_t i = 0; i < nitems; i++) { + float re, im; + deserialize_untagged_f64(&f64, sb); + re = static_cast<float>(f64); + deserialize_untagged_f64(&f64, sb); + im = static_cast<float>(f64); + c32vector_set(vec, i, std::complex<float>(re, im)); + } + return vec; + } + + case (UVI_C64): { + pmt_t vec = make_c64vector(nitems, 0); + for (uint32_t i = 0; i < nitems; i++) { + double re, im; + deserialize_untagged_f64(&f64, sb); + re = f64; + deserialize_untagged_f64(&f64, sb); + im = f64; + c64vector_set(vec, i, std::complex<double>(re, im)); + } + return vec; + } + + default: + throw exception("pmt::deserialize: malformed input stream, tag value = ", + from_long(tag)); + } } - case PST_DICT: - case PST_COMMENT: - throw notimplemented("pmt::deserialize: tag value = ", - from_long(tag)); + case PST_DICT: + case PST_COMMENT: + throw notimplemented("pmt::deserialize: tag value = ", from_long(tag)); - default: - throw exception("pmt::deserialize: malformed input stream, tag value = ", - from_long(tag)); - } + default: + throw exception("pmt::deserialize: malformed input stream, tag value = ", + from_long(tag)); + } - error: - throw exception("pmt::deserialize: malformed input stream", PMT_F); +error: + throw exception("pmt::deserialize: malformed input stream", PMT_F); } /* * provide a simple string accessor to the serialized pmt form */ -std::string -serialize_str(pmt_t obj){ - std::stringbuf sb; - serialize(obj, sb); - return sb.str(); +std::string serialize_str(pmt_t obj) +{ + std::stringbuf sb; + serialize(obj, sb); + return sb.str(); } /* * provide a simple string accessor to the deserialized pmt form */ -pmt_t -deserialize_str(std::string s){ - std::stringbuf sb(s); - return deserialize(sb); +pmt_t deserialize_str(std::string s) +{ + std::stringbuf sb(s); + return deserialize(sb); } @@ -794,50 +764,49 @@ deserialize_str(std::string s){ * * On entry we've already eaten the PST_PAIR tag. */ -pmt_t -parse_pair(std::streambuf &sb) +pmt_t parse_pair(std::streambuf& sb) { - uint8_t tag; - pmt_t val, expr, lastnptr, nptr; - - // - // Keep appending nodes until we get a non-PAIR cdr. - // - lastnptr = PMT_NIL; - while (1){ - expr = deserialize(sb); // read the car - - nptr = cons(expr, PMT_NIL); // build new cell - if (is_null(lastnptr)) - val = nptr; - else - set_cdr(lastnptr, nptr); - lastnptr = nptr; - - if (!deserialize_untagged_u8(&tag, sb)) // get tag of cdr - throw exception("pmt::deserialize: malformed input stream", PMT_F); - - if (tag == PST_PAIR) - continue; // keep on looping... - - if (tag == PST_NULL){ - expr = PMT_NIL; - break; + uint8_t tag; + pmt_t val, expr, lastnptr, nptr; + + // + // Keep appending nodes until we get a non-PAIR cdr. + // + lastnptr = PMT_NIL; + while (1) { + expr = deserialize(sb); // read the car + + nptr = cons(expr, PMT_NIL); // build new cell + if (is_null(lastnptr)) + val = nptr; + else + set_cdr(lastnptr, nptr); + lastnptr = nptr; + + if (!deserialize_untagged_u8(&tag, sb)) // get tag of cdr + throw exception("pmt::deserialize: malformed input stream", PMT_F); + + if (tag == PST_PAIR) + continue; // keep on looping... + + if (tag == PST_NULL) { + expr = PMT_NIL; + break; + } + + // + // default: push tag back and use pmt_deserialize to get the cdr + // + sb.sungetc(); + expr = deserialize(sb); + break; } // - // default: push tag back and use pmt_deserialize to get the cdr + // At this point, expr contains the value of the final cdr in the list. // - sb.sungetc(); - expr = deserialize(sb); - break; - } - - // - // At this point, expr contains the value of the final cdr in the list. - // - set_cdr(lastnptr, expr); - return val; + set_cdr(lastnptr, expr); + return val; } } /* namespace pmt */ diff --git a/gnuradio-runtime/lib/pmt/pmt_unv.cc b/gnuradio-runtime/lib/pmt/pmt_unv.cc index 25cd9a3c95..fc295fb6b3 100644 --- a/gnuradio-runtime/lib/pmt/pmt_unv.cc +++ b/gnuradio-runtime/lib/pmt/pmt_unv.cc @@ -37,146 +37,119 @@ namespace pmt { -static pmt_u8vector * -_u8vector(pmt_t x) -{ - return dynamic_cast<pmt_u8vector*>(x.get()); -} +static pmt_u8vector* _u8vector(pmt_t x) { return dynamic_cast<pmt_u8vector*>(x.get()); } -pmt_u8vector::pmt_u8vector(size_t k, uint8_t fill) - : d_v(k) +pmt_u8vector::pmt_u8vector(size_t k, uint8_t fill) : d_v(k) { - for (size_t i = 0; i < k; i++) - d_v[i] = fill; + for (size_t i = 0; i < k; i++) + d_v[i] = fill; } -pmt_u8vector::pmt_u8vector(size_t k, const uint8_t *data) - : d_v(k) +pmt_u8vector::pmt_u8vector(size_t k, const uint8_t* data) : d_v(k) { - if(k) - memcpy( &d_v[0], data, k * sizeof(uint8_t) ); + if (k) + memcpy(&d_v[0], data, k * sizeof(uint8_t)); } -uint8_t -pmt_u8vector::ref(size_t k) const +uint8_t pmt_u8vector::ref(size_t k) const { - if (k >= length()) - throw out_of_range("pmt_u8vector_ref", from_long(k)); - return d_v[k]; + if (k >= length()) + throw out_of_range("pmt_u8vector_ref", from_long(k)); + return d_v[k]; } -void -pmt_u8vector::set(size_t k, uint8_t x) +void pmt_u8vector::set(size_t k, uint8_t x) { - if (k >= length()) - throw out_of_range("pmt_u8vector_set", from_long(k)); - d_v[k] = x; + if (k >= length()) + throw out_of_range("pmt_u8vector_set", from_long(k)); + d_v[k] = x; } -const uint8_t * -pmt_u8vector::elements(size_t &len) +const uint8_t* pmt_u8vector::elements(size_t& len) { - len = length(); - return len ? &d_v[0] : nullptr; + len = length(); + return len ? &d_v[0] : nullptr; } -uint8_t * -pmt_u8vector::writable_elements(size_t &len) +uint8_t* pmt_u8vector::writable_elements(size_t& len) { - len = length(); - return len ? &d_v[0] : nullptr; + len = length(); + return len ? &d_v[0] : nullptr; } -const void* -pmt_u8vector::uniform_elements(size_t &len) +const void* pmt_u8vector::uniform_elements(size_t& len) { - len = length() * sizeof(uint8_t); - return len ? &d_v[0] : nullptr; + len = length() * sizeof(uint8_t); + return len ? &d_v[0] : nullptr; } -void* -pmt_u8vector::uniform_writable_elements(size_t &len) +void* pmt_u8vector::uniform_writable_elements(size_t& len) { - len = length() * sizeof(uint8_t); - return len ? (&d_v[0]) : nullptr; + len = length() * sizeof(uint8_t); + return len ? (&d_v[0]) : nullptr; } -bool -is_u8vector(pmt_t obj) -{ - return obj->is_u8vector(); -} +bool is_u8vector(pmt_t obj) { return obj->is_u8vector(); } -pmt_t -make_u8vector(size_t k, uint8_t fill) -{ - return pmt_t(new pmt_u8vector(k, fill)); -} +pmt_t make_u8vector(size_t k, uint8_t fill) { return pmt_t(new pmt_u8vector(k, fill)); } -pmt_t -init_u8vector(size_t k, const uint8_t *data) +pmt_t init_u8vector(size_t k, const uint8_t* data) { - return pmt_t(new pmt_u8vector(k, data)); + return pmt_t(new pmt_u8vector(k, data)); } -pmt_t -init_u8vector(size_t k, const std::vector< uint8_t > &data) +pmt_t init_u8vector(size_t k, const std::vector<uint8_t>& data) { - if(k) { - return pmt_t(new pmt_u8vector(k, &data[0])); - } - return pmt_t(new pmt_u8vector(k, static_cast< uint8_t >(0))); // fills an empty vector with 0 + if (k) { + return pmt_t(new pmt_u8vector(k, &data[0])); + } + return pmt_t( + new pmt_u8vector(k, static_cast<uint8_t>(0))); // fills an empty vector with 0 } -uint8_t -u8vector_ref(pmt_t vector, size_t k) +uint8_t u8vector_ref(pmt_t vector, size_t k) { - if (!vector->is_u8vector()) - throw wrong_type("pmt_u8vector_ref", vector); - return _u8vector(vector)->ref(k); + if (!vector->is_u8vector()) + throw wrong_type("pmt_u8vector_ref", vector); + return _u8vector(vector)->ref(k); } -void -u8vector_set(pmt_t vector, size_t k, uint8_t obj) +void u8vector_set(pmt_t vector, size_t k, uint8_t obj) { - if (!vector->is_u8vector()) - throw wrong_type("pmt_u8vector_set", vector); - _u8vector(vector)->set(k, obj); + if (!vector->is_u8vector()) + throw wrong_type("pmt_u8vector_set", vector); + _u8vector(vector)->set(k, obj); } -const uint8_t * -u8vector_elements(pmt_t vector, size_t &len) +const uint8_t* u8vector_elements(pmt_t vector, size_t& len) { - if (!vector->is_u8vector()) - throw wrong_type("pmt_u8vector_elements", vector); - return _u8vector(vector)->elements(len); + if (!vector->is_u8vector()) + throw wrong_type("pmt_u8vector_elements", vector); + return _u8vector(vector)->elements(len); } -const std::vector< uint8_t > -u8vector_elements(pmt_t vector) +const std::vector<uint8_t> u8vector_elements(pmt_t vector) { - if (!vector->is_u8vector()) - throw wrong_type("pmt_u8vector_elements", vector); - size_t len; - const uint8_t *array = _u8vector(vector)->elements(len); - const std::vector< uint8_t > vec(array, array+len); - return vec; + if (!vector->is_u8vector()) + throw wrong_type("pmt_u8vector_elements", vector); + size_t len; + const uint8_t* array = _u8vector(vector)->elements(len); + const std::vector<uint8_t> vec(array, array + len); + return vec; } -uint8_t * -u8vector_writable_elements(pmt_t vector, size_t &len) +uint8_t* u8vector_writable_elements(pmt_t vector, size_t& len) { - if (!vector->is_u8vector()) - throw wrong_type("pmt_u8vector_writable_elements", vector); - return _u8vector(vector)->writable_elements(len); + if (!vector->is_u8vector()) + throw wrong_type("pmt_u8vector_writable_elements", vector); + return _u8vector(vector)->writable_elements(len); } -const std::string -pmt_u8vector::string_ref(size_t k) const +const std::string pmt_u8vector::string_ref(size_t k) const { - return boost::lexical_cast< std::string, uint8_t > (ref(k)); + return boost::lexical_cast<std::string, uint8_t>(ref(k)); } } /* namespace pmt */ @@ -186,146 +159,119 @@ pmt_u8vector::string_ref(size_t k) const namespace pmt { -static pmt_s8vector * -_s8vector(pmt_t x) -{ - return dynamic_cast<pmt_s8vector*>(x.get()); -} +static pmt_s8vector* _s8vector(pmt_t x) { return dynamic_cast<pmt_s8vector*>(x.get()); } -pmt_s8vector::pmt_s8vector(size_t k, int8_t fill) - : d_v(k) +pmt_s8vector::pmt_s8vector(size_t k, int8_t fill) : d_v(k) { - for (size_t i = 0; i < k; i++) - d_v[i] = fill; + for (size_t i = 0; i < k; i++) + d_v[i] = fill; } -pmt_s8vector::pmt_s8vector(size_t k, const int8_t *data) - : d_v(k) +pmt_s8vector::pmt_s8vector(size_t k, const int8_t* data) : d_v(k) { - if(k) - memcpy( &d_v[0], data, k * sizeof(int8_t) ); + if (k) + memcpy(&d_v[0], data, k * sizeof(int8_t)); } -int8_t -pmt_s8vector::ref(size_t k) const +int8_t pmt_s8vector::ref(size_t k) const { - if (k >= length()) - throw out_of_range("pmt_s8vector_ref", from_long(k)); - return d_v[k]; + if (k >= length()) + throw out_of_range("pmt_s8vector_ref", from_long(k)); + return d_v[k]; } -void -pmt_s8vector::set(size_t k, int8_t x) +void pmt_s8vector::set(size_t k, int8_t x) { - if (k >= length()) - throw out_of_range("pmt_s8vector_set", from_long(k)); - d_v[k] = x; + if (k >= length()) + throw out_of_range("pmt_s8vector_set", from_long(k)); + d_v[k] = x; } -const int8_t * -pmt_s8vector::elements(size_t &len) +const int8_t* pmt_s8vector::elements(size_t& len) { - len = length(); - return len ? &d_v[0] : nullptr; + len = length(); + return len ? &d_v[0] : nullptr; } -int8_t * -pmt_s8vector::writable_elements(size_t &len) +int8_t* pmt_s8vector::writable_elements(size_t& len) { - len = length(); - return len ? &d_v[0] : nullptr; + len = length(); + return len ? &d_v[0] : nullptr; } -const void* -pmt_s8vector::uniform_elements(size_t &len) +const void* pmt_s8vector::uniform_elements(size_t& len) { - len = length() * sizeof(int8_t); - return len ? &d_v[0] : nullptr; + len = length() * sizeof(int8_t); + return len ? &d_v[0] : nullptr; } -void* -pmt_s8vector::uniform_writable_elements(size_t &len) +void* pmt_s8vector::uniform_writable_elements(size_t& len) { - len = length() * sizeof(int8_t); - return len ? (&d_v[0]) : nullptr; + len = length() * sizeof(int8_t); + return len ? (&d_v[0]) : nullptr; } -bool -is_s8vector(pmt_t obj) -{ - return obj->is_s8vector(); -} +bool is_s8vector(pmt_t obj) { return obj->is_s8vector(); } -pmt_t -make_s8vector(size_t k, int8_t fill) -{ - return pmt_t(new pmt_s8vector(k, fill)); -} +pmt_t make_s8vector(size_t k, int8_t fill) { return pmt_t(new pmt_s8vector(k, fill)); } -pmt_t -init_s8vector(size_t k, const int8_t *data) +pmt_t init_s8vector(size_t k, const int8_t* data) { - return pmt_t(new pmt_s8vector(k, data)); + return pmt_t(new pmt_s8vector(k, data)); } -pmt_t -init_s8vector(size_t k, const std::vector< int8_t > &data) +pmt_t init_s8vector(size_t k, const std::vector<int8_t>& data) { - if(k) { - return pmt_t(new pmt_s8vector(k, &data[0])); - } - return pmt_t(new pmt_s8vector(k, static_cast< int8_t >(0))); // fills an empty vector with 0 + if (k) { + return pmt_t(new pmt_s8vector(k, &data[0])); + } + return pmt_t( + new pmt_s8vector(k, static_cast<int8_t>(0))); // fills an empty vector with 0 } -int8_t -s8vector_ref(pmt_t vector, size_t k) +int8_t s8vector_ref(pmt_t vector, size_t k) { - if (!vector->is_s8vector()) - throw wrong_type("pmt_s8vector_ref", vector); - return _s8vector(vector)->ref(k); + if (!vector->is_s8vector()) + throw wrong_type("pmt_s8vector_ref", vector); + return _s8vector(vector)->ref(k); } -void -s8vector_set(pmt_t vector, size_t k, int8_t obj) +void s8vector_set(pmt_t vector, size_t k, int8_t obj) { - if (!vector->is_s8vector()) - throw wrong_type("pmt_s8vector_set", vector); - _s8vector(vector)->set(k, obj); + if (!vector->is_s8vector()) + throw wrong_type("pmt_s8vector_set", vector); + _s8vector(vector)->set(k, obj); } -const int8_t * -s8vector_elements(pmt_t vector, size_t &len) +const int8_t* s8vector_elements(pmt_t vector, size_t& len) { - if (!vector->is_s8vector()) - throw wrong_type("pmt_s8vector_elements", vector); - return _s8vector(vector)->elements(len); + if (!vector->is_s8vector()) + throw wrong_type("pmt_s8vector_elements", vector); + return _s8vector(vector)->elements(len); } -const std::vector< int8_t > -s8vector_elements(pmt_t vector) +const std::vector<int8_t> s8vector_elements(pmt_t vector) { - if (!vector->is_s8vector()) - throw wrong_type("pmt_s8vector_elements", vector); - size_t len; - const int8_t *array = _s8vector(vector)->elements(len); - const std::vector< int8_t > vec(array, array+len); - return vec; + if (!vector->is_s8vector()) + throw wrong_type("pmt_s8vector_elements", vector); + size_t len; + const int8_t* array = _s8vector(vector)->elements(len); + const std::vector<int8_t> vec(array, array + len); + return vec; } -int8_t * -s8vector_writable_elements(pmt_t vector, size_t &len) +int8_t* s8vector_writable_elements(pmt_t vector, size_t& len) { - if (!vector->is_s8vector()) - throw wrong_type("pmt_s8vector_writable_elements", vector); - return _s8vector(vector)->writable_elements(len); + if (!vector->is_s8vector()) + throw wrong_type("pmt_s8vector_writable_elements", vector); + return _s8vector(vector)->writable_elements(len); } -const std::string -pmt_s8vector::string_ref(size_t k) const +const std::string pmt_s8vector::string_ref(size_t k) const { - return boost::lexical_cast< std::string, int8_t > (ref(k)); + return boost::lexical_cast<std::string, int8_t>(ref(k)); } } /* namespace pmt */ @@ -335,146 +281,125 @@ pmt_s8vector::string_ref(size_t k) const namespace pmt { -static pmt_u16vector * -_u16vector(pmt_t x) +static pmt_u16vector* _u16vector(pmt_t x) { - return dynamic_cast<pmt_u16vector*>(x.get()); + return dynamic_cast<pmt_u16vector*>(x.get()); } -pmt_u16vector::pmt_u16vector(size_t k, uint16_t fill) - : d_v(k) +pmt_u16vector::pmt_u16vector(size_t k, uint16_t fill) : d_v(k) { - for (size_t i = 0; i < k; i++) - d_v[i] = fill; + for (size_t i = 0; i < k; i++) + d_v[i] = fill; } -pmt_u16vector::pmt_u16vector(size_t k, const uint16_t *data) - : d_v(k) +pmt_u16vector::pmt_u16vector(size_t k, const uint16_t* data) : d_v(k) { - if(k) - memcpy( &d_v[0], data, k * sizeof(uint16_t) ); + if (k) + memcpy(&d_v[0], data, k * sizeof(uint16_t)); } -uint16_t -pmt_u16vector::ref(size_t k) const +uint16_t pmt_u16vector::ref(size_t k) const { - if (k >= length()) - throw out_of_range("pmt_u16vector_ref", from_long(k)); - return d_v[k]; + if (k >= length()) + throw out_of_range("pmt_u16vector_ref", from_long(k)); + return d_v[k]; } -void -pmt_u16vector::set(size_t k, uint16_t x) +void pmt_u16vector::set(size_t k, uint16_t x) { - if (k >= length()) - throw out_of_range("pmt_u16vector_set", from_long(k)); - d_v[k] = x; + if (k >= length()) + throw out_of_range("pmt_u16vector_set", from_long(k)); + d_v[k] = x; } -const uint16_t * -pmt_u16vector::elements(size_t &len) +const uint16_t* pmt_u16vector::elements(size_t& len) { - len = length(); - return len ? &d_v[0] : nullptr; + len = length(); + return len ? &d_v[0] : nullptr; } -uint16_t * -pmt_u16vector::writable_elements(size_t &len) +uint16_t* pmt_u16vector::writable_elements(size_t& len) { - len = length(); - return len ? &d_v[0] : nullptr; + len = length(); + return len ? &d_v[0] : nullptr; } -const void* -pmt_u16vector::uniform_elements(size_t &len) +const void* pmt_u16vector::uniform_elements(size_t& len) { - len = length() * sizeof(uint16_t); - return len ? &d_v[0] : nullptr; + len = length() * sizeof(uint16_t); + return len ? &d_v[0] : nullptr; } -void* -pmt_u16vector::uniform_writable_elements(size_t &len) +void* pmt_u16vector::uniform_writable_elements(size_t& len) { - len = length() * sizeof(uint16_t); - return len ? (&d_v[0]) : nullptr; + len = length() * sizeof(uint16_t); + return len ? (&d_v[0]) : nullptr; } -bool -is_u16vector(pmt_t obj) -{ - return obj->is_u16vector(); -} +bool is_u16vector(pmt_t obj) { return obj->is_u16vector(); } -pmt_t -make_u16vector(size_t k, uint16_t fill) +pmt_t make_u16vector(size_t k, uint16_t fill) { - return pmt_t(new pmt_u16vector(k, fill)); + return pmt_t(new pmt_u16vector(k, fill)); } -pmt_t -init_u16vector(size_t k, const uint16_t *data) +pmt_t init_u16vector(size_t k, const uint16_t* data) { - return pmt_t(new pmt_u16vector(k, data)); + return pmt_t(new pmt_u16vector(k, data)); } -pmt_t -init_u16vector(size_t k, const std::vector< uint16_t > &data) +pmt_t init_u16vector(size_t k, const std::vector<uint16_t>& data) { - if(k) { - return pmt_t(new pmt_u16vector(k, &data[0])); - } - return pmt_t(new pmt_u16vector(k, static_cast< uint16_t >(0))); // fills an empty vector with 0 + if (k) { + return pmt_t(new pmt_u16vector(k, &data[0])); + } + return pmt_t( + new pmt_u16vector(k, static_cast<uint16_t>(0))); // fills an empty vector with 0 } -uint16_t -u16vector_ref(pmt_t vector, size_t k) +uint16_t u16vector_ref(pmt_t vector, size_t k) { - if (!vector->is_u16vector()) - throw wrong_type("pmt_u16vector_ref", vector); - return _u16vector(vector)->ref(k); + if (!vector->is_u16vector()) + throw wrong_type("pmt_u16vector_ref", vector); + return _u16vector(vector)->ref(k); } -void -u16vector_set(pmt_t vector, size_t k, uint16_t obj) +void u16vector_set(pmt_t vector, size_t k, uint16_t obj) { - if (!vector->is_u16vector()) - throw wrong_type("pmt_u16vector_set", vector); - _u16vector(vector)->set(k, obj); + if (!vector->is_u16vector()) + throw wrong_type("pmt_u16vector_set", vector); + _u16vector(vector)->set(k, obj); } -const uint16_t * -u16vector_elements(pmt_t vector, size_t &len) +const uint16_t* u16vector_elements(pmt_t vector, size_t& len) { - if (!vector->is_u16vector()) - throw wrong_type("pmt_u16vector_elements", vector); - return _u16vector(vector)->elements(len); + if (!vector->is_u16vector()) + throw wrong_type("pmt_u16vector_elements", vector); + return _u16vector(vector)->elements(len); } -const std::vector< uint16_t > -u16vector_elements(pmt_t vector) +const std::vector<uint16_t> u16vector_elements(pmt_t vector) { - if (!vector->is_u16vector()) - throw wrong_type("pmt_u16vector_elements", vector); - size_t len; - const uint16_t *array = _u16vector(vector)->elements(len); - const std::vector< uint16_t > vec(array, array+len); - return vec; + if (!vector->is_u16vector()) + throw wrong_type("pmt_u16vector_elements", vector); + size_t len; + const uint16_t* array = _u16vector(vector)->elements(len); + const std::vector<uint16_t> vec(array, array + len); + return vec; } -uint16_t * -u16vector_writable_elements(pmt_t vector, size_t &len) +uint16_t* u16vector_writable_elements(pmt_t vector, size_t& len) { - if (!vector->is_u16vector()) - throw wrong_type("pmt_u16vector_writable_elements", vector); - return _u16vector(vector)->writable_elements(len); + if (!vector->is_u16vector()) + throw wrong_type("pmt_u16vector_writable_elements", vector); + return _u16vector(vector)->writable_elements(len); } -const std::string -pmt_u16vector::string_ref(size_t k) const +const std::string pmt_u16vector::string_ref(size_t k) const { - return std::to_string(ref(k)); + return std::to_string(ref(k)); } } /* namespace pmt */ @@ -484,146 +409,122 @@ pmt_u16vector::string_ref(size_t k) const namespace pmt { -static pmt_s16vector * -_s16vector(pmt_t x) +static pmt_s16vector* _s16vector(pmt_t x) { - return dynamic_cast<pmt_s16vector*>(x.get()); + return dynamic_cast<pmt_s16vector*>(x.get()); } -pmt_s16vector::pmt_s16vector(size_t k, int16_t fill) - : d_v(k) +pmt_s16vector::pmt_s16vector(size_t k, int16_t fill) : d_v(k) { - for (size_t i = 0; i < k; i++) - d_v[i] = fill; + for (size_t i = 0; i < k; i++) + d_v[i] = fill; } -pmt_s16vector::pmt_s16vector(size_t k, const int16_t *data) - : d_v(k) +pmt_s16vector::pmt_s16vector(size_t k, const int16_t* data) : d_v(k) { - if(k) - memcpy( &d_v[0], data, k * sizeof(int16_t) ); + if (k) + memcpy(&d_v[0], data, k * sizeof(int16_t)); } -int16_t -pmt_s16vector::ref(size_t k) const +int16_t pmt_s16vector::ref(size_t k) const { - if (k >= length()) - throw out_of_range("pmt_s16vector_ref", from_long(k)); - return d_v[k]; + if (k >= length()) + throw out_of_range("pmt_s16vector_ref", from_long(k)); + return d_v[k]; } -void -pmt_s16vector::set(size_t k, int16_t x) +void pmt_s16vector::set(size_t k, int16_t x) { - if (k >= length()) - throw out_of_range("pmt_s16vector_set", from_long(k)); - d_v[k] = x; + if (k >= length()) + throw out_of_range("pmt_s16vector_set", from_long(k)); + d_v[k] = x; } -const int16_t * -pmt_s16vector::elements(size_t &len) +const int16_t* pmt_s16vector::elements(size_t& len) { - len = length(); - return len ? &d_v[0] : nullptr; + len = length(); + return len ? &d_v[0] : nullptr; } -int16_t * -pmt_s16vector::writable_elements(size_t &len) +int16_t* pmt_s16vector::writable_elements(size_t& len) { - len = length(); - return len ? &d_v[0] : nullptr; + len = length(); + return len ? &d_v[0] : nullptr; } -const void* -pmt_s16vector::uniform_elements(size_t &len) +const void* pmt_s16vector::uniform_elements(size_t& len) { - len = length() * sizeof(int16_t); - return len ? &d_v[0] : nullptr; + len = length() * sizeof(int16_t); + return len ? &d_v[0] : nullptr; } -void* -pmt_s16vector::uniform_writable_elements(size_t &len) +void* pmt_s16vector::uniform_writable_elements(size_t& len) { - len = length() * sizeof(int16_t); - return len ? (&d_v[0]) : nullptr; + len = length() * sizeof(int16_t); + return len ? (&d_v[0]) : nullptr; } -bool -is_s16vector(pmt_t obj) -{ - return obj->is_s16vector(); -} +bool is_s16vector(pmt_t obj) { return obj->is_s16vector(); } -pmt_t -make_s16vector(size_t k, int16_t fill) -{ - return pmt_t(new pmt_s16vector(k, fill)); -} +pmt_t make_s16vector(size_t k, int16_t fill) { return pmt_t(new pmt_s16vector(k, fill)); } -pmt_t -init_s16vector(size_t k, const int16_t *data) +pmt_t init_s16vector(size_t k, const int16_t* data) { - return pmt_t(new pmt_s16vector(k, data)); + return pmt_t(new pmt_s16vector(k, data)); } -pmt_t -init_s16vector(size_t k, const std::vector< int16_t > &data) +pmt_t init_s16vector(size_t k, const std::vector<int16_t>& data) { - if(k) { - return pmt_t(new pmt_s16vector(k, &data[0])); - } - return pmt_t(new pmt_s16vector(k, static_cast< int16_t >(0))); // fills an empty vector with 0 + if (k) { + return pmt_t(new pmt_s16vector(k, &data[0])); + } + return pmt_t( + new pmt_s16vector(k, static_cast<int16_t>(0))); // fills an empty vector with 0 } -int16_t -s16vector_ref(pmt_t vector, size_t k) +int16_t s16vector_ref(pmt_t vector, size_t k) { - if (!vector->is_s16vector()) - throw wrong_type("pmt_s16vector_ref", vector); - return _s16vector(vector)->ref(k); + if (!vector->is_s16vector()) + throw wrong_type("pmt_s16vector_ref", vector); + return _s16vector(vector)->ref(k); } -void -s16vector_set(pmt_t vector, size_t k, int16_t obj) +void s16vector_set(pmt_t vector, size_t k, int16_t obj) { - if (!vector->is_s16vector()) - throw wrong_type("pmt_s16vector_set", vector); - _s16vector(vector)->set(k, obj); + if (!vector->is_s16vector()) + throw wrong_type("pmt_s16vector_set", vector); + _s16vector(vector)->set(k, obj); } -const int16_t * -s16vector_elements(pmt_t vector, size_t &len) +const int16_t* s16vector_elements(pmt_t vector, size_t& len) { - if (!vector->is_s16vector()) - throw wrong_type("pmt_s16vector_elements", vector); - return _s16vector(vector)->elements(len); + if (!vector->is_s16vector()) + throw wrong_type("pmt_s16vector_elements", vector); + return _s16vector(vector)->elements(len); } -const std::vector< int16_t > -s16vector_elements(pmt_t vector) +const std::vector<int16_t> s16vector_elements(pmt_t vector) { - if (!vector->is_s16vector()) - throw wrong_type("pmt_s16vector_elements", vector); - size_t len; - const int16_t *array = _s16vector(vector)->elements(len); - const std::vector< int16_t > vec(array, array+len); - return vec; + if (!vector->is_s16vector()) + throw wrong_type("pmt_s16vector_elements", vector); + size_t len; + const int16_t* array = _s16vector(vector)->elements(len); + const std::vector<int16_t> vec(array, array + len); + return vec; } -int16_t * -s16vector_writable_elements(pmt_t vector, size_t &len) +int16_t* s16vector_writable_elements(pmt_t vector, size_t& len) { - if (!vector->is_s16vector()) - throw wrong_type("pmt_s16vector_writable_elements", vector); - return _s16vector(vector)->writable_elements(len); + if (!vector->is_s16vector()) + throw wrong_type("pmt_s16vector_writable_elements", vector); + return _s16vector(vector)->writable_elements(len); } -const std::string -pmt_s16vector::string_ref(size_t k) const +const std::string pmt_s16vector::string_ref(size_t k) const { - return std::to_string(ref(k)); + return std::to_string(ref(k)); } } /* namespace pmt */ @@ -633,146 +534,125 @@ pmt_s16vector::string_ref(size_t k) const namespace pmt { -static pmt_u32vector * -_u32vector(pmt_t x) +static pmt_u32vector* _u32vector(pmt_t x) { - return dynamic_cast<pmt_u32vector*>(x.get()); + return dynamic_cast<pmt_u32vector*>(x.get()); } -pmt_u32vector::pmt_u32vector(size_t k, uint32_t fill) - : d_v(k) +pmt_u32vector::pmt_u32vector(size_t k, uint32_t fill) : d_v(k) { - for (size_t i = 0; i < k; i++) - d_v[i] = fill; + for (size_t i = 0; i < k; i++) + d_v[i] = fill; } -pmt_u32vector::pmt_u32vector(size_t k, const uint32_t *data) - : d_v(k) +pmt_u32vector::pmt_u32vector(size_t k, const uint32_t* data) : d_v(k) { - if(k) - memcpy( &d_v[0], data, k * sizeof(uint32_t) ); + if (k) + memcpy(&d_v[0], data, k * sizeof(uint32_t)); } -uint32_t -pmt_u32vector::ref(size_t k) const +uint32_t pmt_u32vector::ref(size_t k) const { - if (k >= length()) - throw out_of_range("pmt_u32vector_ref", from_long(k)); - return d_v[k]; + if (k >= length()) + throw out_of_range("pmt_u32vector_ref", from_long(k)); + return d_v[k]; } -void -pmt_u32vector::set(size_t k, uint32_t x) +void pmt_u32vector::set(size_t k, uint32_t x) { - if (k >= length()) - throw out_of_range("pmt_u32vector_set", from_long(k)); - d_v[k] = x; + if (k >= length()) + throw out_of_range("pmt_u32vector_set", from_long(k)); + d_v[k] = x; } -const uint32_t * -pmt_u32vector::elements(size_t &len) +const uint32_t* pmt_u32vector::elements(size_t& len) { - len = length(); - return len ? &d_v[0] : nullptr; + len = length(); + return len ? &d_v[0] : nullptr; } -uint32_t * -pmt_u32vector::writable_elements(size_t &len) +uint32_t* pmt_u32vector::writable_elements(size_t& len) { - len = length(); - return len ? &d_v[0] : nullptr; + len = length(); + return len ? &d_v[0] : nullptr; } -const void* -pmt_u32vector::uniform_elements(size_t &len) +const void* pmt_u32vector::uniform_elements(size_t& len) { - len = length() * sizeof(uint32_t); - return len ? &d_v[0] : nullptr; + len = length() * sizeof(uint32_t); + return len ? &d_v[0] : nullptr; } -void* -pmt_u32vector::uniform_writable_elements(size_t &len) +void* pmt_u32vector::uniform_writable_elements(size_t& len) { - len = length() * sizeof(uint32_t); - return len ? (&d_v[0]) : nullptr; + len = length() * sizeof(uint32_t); + return len ? (&d_v[0]) : nullptr; } -bool -is_u32vector(pmt_t obj) -{ - return obj->is_u32vector(); -} +bool is_u32vector(pmt_t obj) { return obj->is_u32vector(); } -pmt_t -make_u32vector(size_t k, uint32_t fill) +pmt_t make_u32vector(size_t k, uint32_t fill) { - return pmt_t(new pmt_u32vector(k, fill)); + return pmt_t(new pmt_u32vector(k, fill)); } -pmt_t -init_u32vector(size_t k, const uint32_t *data) +pmt_t init_u32vector(size_t k, const uint32_t* data) { - return pmt_t(new pmt_u32vector(k, data)); + return pmt_t(new pmt_u32vector(k, data)); } -pmt_t -init_u32vector(size_t k, const std::vector< uint32_t > &data) +pmt_t init_u32vector(size_t k, const std::vector<uint32_t>& data) { - if(k) { - return pmt_t(new pmt_u32vector(k, &data[0])); - } - return pmt_t(new pmt_u32vector(k, static_cast< uint32_t >(0))); // fills an empty vector with 0 + if (k) { + return pmt_t(new pmt_u32vector(k, &data[0])); + } + return pmt_t( + new pmt_u32vector(k, static_cast<uint32_t>(0))); // fills an empty vector with 0 } -uint32_t -u32vector_ref(pmt_t vector, size_t k) +uint32_t u32vector_ref(pmt_t vector, size_t k) { - if (!vector->is_u32vector()) - throw wrong_type("pmt_u32vector_ref", vector); - return _u32vector(vector)->ref(k); + if (!vector->is_u32vector()) + throw wrong_type("pmt_u32vector_ref", vector); + return _u32vector(vector)->ref(k); } -void -u32vector_set(pmt_t vector, size_t k, uint32_t obj) +void u32vector_set(pmt_t vector, size_t k, uint32_t obj) { - if (!vector->is_u32vector()) - throw wrong_type("pmt_u32vector_set", vector); - _u32vector(vector)->set(k, obj); + if (!vector->is_u32vector()) + throw wrong_type("pmt_u32vector_set", vector); + _u32vector(vector)->set(k, obj); } -const uint32_t * -u32vector_elements(pmt_t vector, size_t &len) +const uint32_t* u32vector_elements(pmt_t vector, size_t& len) { - if (!vector->is_u32vector()) - throw wrong_type("pmt_u32vector_elements", vector); - return _u32vector(vector)->elements(len); + if (!vector->is_u32vector()) + throw wrong_type("pmt_u32vector_elements", vector); + return _u32vector(vector)->elements(len); } -const std::vector< uint32_t > -u32vector_elements(pmt_t vector) +const std::vector<uint32_t> u32vector_elements(pmt_t vector) { - if (!vector->is_u32vector()) - throw wrong_type("pmt_u32vector_elements", vector); - size_t len; - const uint32_t *array = _u32vector(vector)->elements(len); - const std::vector< uint32_t > vec(array, array+len); - return vec; + if (!vector->is_u32vector()) + throw wrong_type("pmt_u32vector_elements", vector); + size_t len; + const uint32_t* array = _u32vector(vector)->elements(len); + const std::vector<uint32_t> vec(array, array + len); + return vec; } -uint32_t * -u32vector_writable_elements(pmt_t vector, size_t &len) +uint32_t* u32vector_writable_elements(pmt_t vector, size_t& len) { - if (!vector->is_u32vector()) - throw wrong_type("pmt_u32vector_writable_elements", vector); - return _u32vector(vector)->writable_elements(len); + if (!vector->is_u32vector()) + throw wrong_type("pmt_u32vector_writable_elements", vector); + return _u32vector(vector)->writable_elements(len); } -const std::string -pmt_u32vector::string_ref(size_t k) const +const std::string pmt_u32vector::string_ref(size_t k) const { - return std::to_string(ref(k)); + return std::to_string(ref(k)); } } /* namespace pmt */ @@ -782,146 +662,122 @@ pmt_u32vector::string_ref(size_t k) const namespace pmt { -static pmt_s32vector * -_s32vector(pmt_t x) +static pmt_s32vector* _s32vector(pmt_t x) { - return dynamic_cast<pmt_s32vector*>(x.get()); + return dynamic_cast<pmt_s32vector*>(x.get()); } -pmt_s32vector::pmt_s32vector(size_t k, int32_t fill) - : d_v(k) +pmt_s32vector::pmt_s32vector(size_t k, int32_t fill) : d_v(k) { - for (size_t i = 0; i < k; i++) - d_v[i] = fill; + for (size_t i = 0; i < k; i++) + d_v[i] = fill; } -pmt_s32vector::pmt_s32vector(size_t k, const int32_t *data) - : d_v(k) +pmt_s32vector::pmt_s32vector(size_t k, const int32_t* data) : d_v(k) { - if(k) - memcpy( &d_v[0], data, k * sizeof(int32_t) ); + if (k) + memcpy(&d_v[0], data, k * sizeof(int32_t)); } -int32_t -pmt_s32vector::ref(size_t k) const +int32_t pmt_s32vector::ref(size_t k) const { - if (k >= length()) - throw out_of_range("pmt_s32vector_ref", from_long(k)); - return d_v[k]; + if (k >= length()) + throw out_of_range("pmt_s32vector_ref", from_long(k)); + return d_v[k]; } -void -pmt_s32vector::set(size_t k, int32_t x) +void pmt_s32vector::set(size_t k, int32_t x) { - if (k >= length()) - throw out_of_range("pmt_s32vector_set", from_long(k)); - d_v[k] = x; + if (k >= length()) + throw out_of_range("pmt_s32vector_set", from_long(k)); + d_v[k] = x; } -const int32_t * -pmt_s32vector::elements(size_t &len) +const int32_t* pmt_s32vector::elements(size_t& len) { - len = length(); - return len ? &d_v[0] : nullptr; + len = length(); + return len ? &d_v[0] : nullptr; } -int32_t * -pmt_s32vector::writable_elements(size_t &len) +int32_t* pmt_s32vector::writable_elements(size_t& len) { - len = length(); - return len ? &d_v[0] : nullptr; + len = length(); + return len ? &d_v[0] : nullptr; } -const void* -pmt_s32vector::uniform_elements(size_t &len) +const void* pmt_s32vector::uniform_elements(size_t& len) { - len = length() * sizeof(int32_t); - return len ? &d_v[0] : nullptr; + len = length() * sizeof(int32_t); + return len ? &d_v[0] : nullptr; } -void* -pmt_s32vector::uniform_writable_elements(size_t &len) +void* pmt_s32vector::uniform_writable_elements(size_t& len) { - len = length() * sizeof(int32_t); - return len ? (&d_v[0]) : nullptr; + len = length() * sizeof(int32_t); + return len ? (&d_v[0]) : nullptr; } -bool -is_s32vector(pmt_t obj) -{ - return obj->is_s32vector(); -} +bool is_s32vector(pmt_t obj) { return obj->is_s32vector(); } -pmt_t -make_s32vector(size_t k, int32_t fill) -{ - return pmt_t(new pmt_s32vector(k, fill)); -} +pmt_t make_s32vector(size_t k, int32_t fill) { return pmt_t(new pmt_s32vector(k, fill)); } -pmt_t -init_s32vector(size_t k, const int32_t *data) +pmt_t init_s32vector(size_t k, const int32_t* data) { - return pmt_t(new pmt_s32vector(k, data)); + return pmt_t(new pmt_s32vector(k, data)); } -pmt_t -init_s32vector(size_t k, const std::vector< int32_t > &data) +pmt_t init_s32vector(size_t k, const std::vector<int32_t>& data) { - if(k) { - return pmt_t(new pmt_s32vector(k, &data[0])); - } - return pmt_t(new pmt_s32vector(k, static_cast< int32_t >(0))); // fills an empty vector with 0 + if (k) { + return pmt_t(new pmt_s32vector(k, &data[0])); + } + return pmt_t( + new pmt_s32vector(k, static_cast<int32_t>(0))); // fills an empty vector with 0 } -int32_t -s32vector_ref(pmt_t vector, size_t k) +int32_t s32vector_ref(pmt_t vector, size_t k) { - if (!vector->is_s32vector()) - throw wrong_type("pmt_s32vector_ref", vector); - return _s32vector(vector)->ref(k); + if (!vector->is_s32vector()) + throw wrong_type("pmt_s32vector_ref", vector); + return _s32vector(vector)->ref(k); } -void -s32vector_set(pmt_t vector, size_t k, int32_t obj) +void s32vector_set(pmt_t vector, size_t k, int32_t obj) { - if (!vector->is_s32vector()) - throw wrong_type("pmt_s32vector_set", vector); - _s32vector(vector)->set(k, obj); + if (!vector->is_s32vector()) + throw wrong_type("pmt_s32vector_set", vector); + _s32vector(vector)->set(k, obj); } -const int32_t * -s32vector_elements(pmt_t vector, size_t &len) +const int32_t* s32vector_elements(pmt_t vector, size_t& len) { - if (!vector->is_s32vector()) - throw wrong_type("pmt_s32vector_elements", vector); - return _s32vector(vector)->elements(len); + if (!vector->is_s32vector()) + throw wrong_type("pmt_s32vector_elements", vector); + return _s32vector(vector)->elements(len); } -const std::vector< int32_t > -s32vector_elements(pmt_t vector) +const std::vector<int32_t> s32vector_elements(pmt_t vector) { - if (!vector->is_s32vector()) - throw wrong_type("pmt_s32vector_elements", vector); - size_t len; - const int32_t *array = _s32vector(vector)->elements(len); - const std::vector< int32_t > vec(array, array+len); - return vec; + if (!vector->is_s32vector()) + throw wrong_type("pmt_s32vector_elements", vector); + size_t len; + const int32_t* array = _s32vector(vector)->elements(len); + const std::vector<int32_t> vec(array, array + len); + return vec; } -int32_t * -s32vector_writable_elements(pmt_t vector, size_t &len) +int32_t* s32vector_writable_elements(pmt_t vector, size_t& len) { - if (!vector->is_s32vector()) - throw wrong_type("pmt_s32vector_writable_elements", vector); - return _s32vector(vector)->writable_elements(len); + if (!vector->is_s32vector()) + throw wrong_type("pmt_s32vector_writable_elements", vector); + return _s32vector(vector)->writable_elements(len); } -const std::string -pmt_s32vector::string_ref(size_t k) const +const std::string pmt_s32vector::string_ref(size_t k) const { - return std::to_string(ref(k)); + return std::to_string(ref(k)); } } /* namespace pmt */ @@ -931,146 +787,125 @@ pmt_s32vector::string_ref(size_t k) const namespace pmt { -static pmt_u64vector * -_u64vector(pmt_t x) +static pmt_u64vector* _u64vector(pmt_t x) { - return dynamic_cast<pmt_u64vector*>(x.get()); + return dynamic_cast<pmt_u64vector*>(x.get()); } -pmt_u64vector::pmt_u64vector(size_t k, uint64_t fill) - : d_v(k) +pmt_u64vector::pmt_u64vector(size_t k, uint64_t fill) : d_v(k) { - for (size_t i = 0; i < k; i++) - d_v[i] = fill; + for (size_t i = 0; i < k; i++) + d_v[i] = fill; } -pmt_u64vector::pmt_u64vector(size_t k, const uint64_t *data) - : d_v(k) +pmt_u64vector::pmt_u64vector(size_t k, const uint64_t* data) : d_v(k) { - if(k) - memcpy( &d_v[0], data, k * sizeof(uint64_t) ); + if (k) + memcpy(&d_v[0], data, k * sizeof(uint64_t)); } -uint64_t -pmt_u64vector::ref(size_t k) const +uint64_t pmt_u64vector::ref(size_t k) const { - if (k >= length()) - throw out_of_range("pmt_u64vector_ref", from_long(k)); - return d_v[k]; + if (k >= length()) + throw out_of_range("pmt_u64vector_ref", from_long(k)); + return d_v[k]; } -void -pmt_u64vector::set(size_t k, uint64_t x) +void pmt_u64vector::set(size_t k, uint64_t x) { - if (k >= length()) - throw out_of_range("pmt_u64vector_set", from_long(k)); - d_v[k] = x; + if (k >= length()) + throw out_of_range("pmt_u64vector_set", from_long(k)); + d_v[k] = x; } -const uint64_t * -pmt_u64vector::elements(size_t &len) +const uint64_t* pmt_u64vector::elements(size_t& len) { - len = length(); - return len ? &d_v[0] : nullptr; + len = length(); + return len ? &d_v[0] : nullptr; } -uint64_t * -pmt_u64vector::writable_elements(size_t &len) +uint64_t* pmt_u64vector::writable_elements(size_t& len) { - len = length(); - return len ? &d_v[0] : nullptr; + len = length(); + return len ? &d_v[0] : nullptr; } -const void* -pmt_u64vector::uniform_elements(size_t &len) +const void* pmt_u64vector::uniform_elements(size_t& len) { - len = length() * sizeof(uint64_t); - return len ? &d_v[0] : nullptr; + len = length() * sizeof(uint64_t); + return len ? &d_v[0] : nullptr; } -void* -pmt_u64vector::uniform_writable_elements(size_t &len) +void* pmt_u64vector::uniform_writable_elements(size_t& len) { - len = length() * sizeof(uint64_t); - return len ? (&d_v[0]) : nullptr; + len = length() * sizeof(uint64_t); + return len ? (&d_v[0]) : nullptr; } -bool -is_u64vector(pmt_t obj) -{ - return obj->is_u64vector(); -} +bool is_u64vector(pmt_t obj) { return obj->is_u64vector(); } -pmt_t -make_u64vector(size_t k, uint64_t fill) +pmt_t make_u64vector(size_t k, uint64_t fill) { - return pmt_t(new pmt_u64vector(k, fill)); + return pmt_t(new pmt_u64vector(k, fill)); } -pmt_t -init_u64vector(size_t k, const uint64_t *data) +pmt_t init_u64vector(size_t k, const uint64_t* data) { - return pmt_t(new pmt_u64vector(k, data)); + return pmt_t(new pmt_u64vector(k, data)); } -pmt_t -init_u64vector(size_t k, const std::vector< uint64_t > &data) +pmt_t init_u64vector(size_t k, const std::vector<uint64_t>& data) { - if(k) { - return pmt_t(new pmt_u64vector(k, &data[0])); - } - return pmt_t(new pmt_u64vector(k, static_cast< uint64_t >(0))); // fills an empty vector with 0 + if (k) { + return pmt_t(new pmt_u64vector(k, &data[0])); + } + return pmt_t( + new pmt_u64vector(k, static_cast<uint64_t>(0))); // fills an empty vector with 0 } -uint64_t -u64vector_ref(pmt_t vector, size_t k) +uint64_t u64vector_ref(pmt_t vector, size_t k) { - if (!vector->is_u64vector()) - throw wrong_type("pmt_u64vector_ref", vector); - return _u64vector(vector)->ref(k); + if (!vector->is_u64vector()) + throw wrong_type("pmt_u64vector_ref", vector); + return _u64vector(vector)->ref(k); } -void -u64vector_set(pmt_t vector, size_t k, uint64_t obj) +void u64vector_set(pmt_t vector, size_t k, uint64_t obj) { - if (!vector->is_u64vector()) - throw wrong_type("pmt_u64vector_set", vector); - _u64vector(vector)->set(k, obj); + if (!vector->is_u64vector()) + throw wrong_type("pmt_u64vector_set", vector); + _u64vector(vector)->set(k, obj); } -const uint64_t * -u64vector_elements(pmt_t vector, size_t &len) +const uint64_t* u64vector_elements(pmt_t vector, size_t& len) { - if (!vector->is_u64vector()) - throw wrong_type("pmt_u64vector_elements", vector); - return _u64vector(vector)->elements(len); + if (!vector->is_u64vector()) + throw wrong_type("pmt_u64vector_elements", vector); + return _u64vector(vector)->elements(len); } -const std::vector< uint64_t > -u64vector_elements(pmt_t vector) +const std::vector<uint64_t> u64vector_elements(pmt_t vector) { - if (!vector->is_u64vector()) - throw wrong_type("pmt_u64vector_elements", vector); - size_t len; - const uint64_t *array = _u64vector(vector)->elements(len); - const std::vector< uint64_t > vec(array, array+len); - return vec; + if (!vector->is_u64vector()) + throw wrong_type("pmt_u64vector_elements", vector); + size_t len; + const uint64_t* array = _u64vector(vector)->elements(len); + const std::vector<uint64_t> vec(array, array + len); + return vec; } -uint64_t * -u64vector_writable_elements(pmt_t vector, size_t &len) +uint64_t* u64vector_writable_elements(pmt_t vector, size_t& len) { - if (!vector->is_u64vector()) - throw wrong_type("pmt_u64vector_writable_elements", vector); - return _u64vector(vector)->writable_elements(len); + if (!vector->is_u64vector()) + throw wrong_type("pmt_u64vector_writable_elements", vector); + return _u64vector(vector)->writable_elements(len); } -const std::string -pmt_u64vector::string_ref(size_t k) const +const std::string pmt_u64vector::string_ref(size_t k) const { - return std::to_string(ref(k)); + return std::to_string(ref(k)); } } /* namespace pmt */ @@ -1080,146 +915,122 @@ pmt_u64vector::string_ref(size_t k) const namespace pmt { -static pmt_s64vector * -_s64vector(pmt_t x) +static pmt_s64vector* _s64vector(pmt_t x) { - return dynamic_cast<pmt_s64vector*>(x.get()); + return dynamic_cast<pmt_s64vector*>(x.get()); } -pmt_s64vector::pmt_s64vector(size_t k, int64_t fill) - : d_v(k) +pmt_s64vector::pmt_s64vector(size_t k, int64_t fill) : d_v(k) { - for (size_t i = 0; i < k; i++) - d_v[i] = fill; + for (size_t i = 0; i < k; i++) + d_v[i] = fill; } -pmt_s64vector::pmt_s64vector(size_t k, const int64_t *data) - : d_v(k) +pmt_s64vector::pmt_s64vector(size_t k, const int64_t* data) : d_v(k) { - if(k) - memcpy( &d_v[0], data, k * sizeof(int64_t) ); + if (k) + memcpy(&d_v[0], data, k * sizeof(int64_t)); } -int64_t -pmt_s64vector::ref(size_t k) const +int64_t pmt_s64vector::ref(size_t k) const { - if (k >= length()) - throw out_of_range("pmt_s64vector_ref", from_long(k)); - return d_v[k]; + if (k >= length()) + throw out_of_range("pmt_s64vector_ref", from_long(k)); + return d_v[k]; } -void -pmt_s64vector::set(size_t k, int64_t x) +void pmt_s64vector::set(size_t k, int64_t x) { - if (k >= length()) - throw out_of_range("pmt_s64vector_set", from_long(k)); - d_v[k] = x; + if (k >= length()) + throw out_of_range("pmt_s64vector_set", from_long(k)); + d_v[k] = x; } -const int64_t * -pmt_s64vector::elements(size_t &len) +const int64_t* pmt_s64vector::elements(size_t& len) { - len = length(); - return len ? &d_v[0] : nullptr; + len = length(); + return len ? &d_v[0] : nullptr; } -int64_t * -pmt_s64vector::writable_elements(size_t &len) +int64_t* pmt_s64vector::writable_elements(size_t& len) { - len = length(); - return len ? &d_v[0] : nullptr; + len = length(); + return len ? &d_v[0] : nullptr; } -const void* -pmt_s64vector::uniform_elements(size_t &len) +const void* pmt_s64vector::uniform_elements(size_t& len) { - len = length() * sizeof(int64_t); - return len ? &d_v[0] : nullptr; + len = length() * sizeof(int64_t); + return len ? &d_v[0] : nullptr; } -void* -pmt_s64vector::uniform_writable_elements(size_t &len) +void* pmt_s64vector::uniform_writable_elements(size_t& len) { - len = length() * sizeof(int64_t); - return len ? (&d_v[0]) : nullptr; + len = length() * sizeof(int64_t); + return len ? (&d_v[0]) : nullptr; } -bool -is_s64vector(pmt_t obj) -{ - return obj->is_s64vector(); -} +bool is_s64vector(pmt_t obj) { return obj->is_s64vector(); } -pmt_t -make_s64vector(size_t k, int64_t fill) -{ - return pmt_t(new pmt_s64vector(k, fill)); -} +pmt_t make_s64vector(size_t k, int64_t fill) { return pmt_t(new pmt_s64vector(k, fill)); } -pmt_t -init_s64vector(size_t k, const int64_t *data) +pmt_t init_s64vector(size_t k, const int64_t* data) { - return pmt_t(new pmt_s64vector(k, data)); + return pmt_t(new pmt_s64vector(k, data)); } -pmt_t -init_s64vector(size_t k, const std::vector< int64_t > &data) +pmt_t init_s64vector(size_t k, const std::vector<int64_t>& data) { - if(k) { - return pmt_t(new pmt_s64vector(k, &data[0])); - } - return pmt_t(new pmt_s64vector(k, static_cast< int64_t >(0))); // fills an empty vector with 0 + if (k) { + return pmt_t(new pmt_s64vector(k, &data[0])); + } + return pmt_t( + new pmt_s64vector(k, static_cast<int64_t>(0))); // fills an empty vector with 0 } -int64_t -s64vector_ref(pmt_t vector, size_t k) +int64_t s64vector_ref(pmt_t vector, size_t k) { - if (!vector->is_s64vector()) - throw wrong_type("pmt_s64vector_ref", vector); - return _s64vector(vector)->ref(k); + if (!vector->is_s64vector()) + throw wrong_type("pmt_s64vector_ref", vector); + return _s64vector(vector)->ref(k); } -void -s64vector_set(pmt_t vector, size_t k, int64_t obj) +void s64vector_set(pmt_t vector, size_t k, int64_t obj) { - if (!vector->is_s64vector()) - throw wrong_type("pmt_s64vector_set", vector); - _s64vector(vector)->set(k, obj); + if (!vector->is_s64vector()) + throw wrong_type("pmt_s64vector_set", vector); + _s64vector(vector)->set(k, obj); } -const int64_t * -s64vector_elements(pmt_t vector, size_t &len) +const int64_t* s64vector_elements(pmt_t vector, size_t& len) { - if (!vector->is_s64vector()) - throw wrong_type("pmt_s64vector_elements", vector); - return _s64vector(vector)->elements(len); + if (!vector->is_s64vector()) + throw wrong_type("pmt_s64vector_elements", vector); + return _s64vector(vector)->elements(len); } -const std::vector< int64_t > -s64vector_elements(pmt_t vector) +const std::vector<int64_t> s64vector_elements(pmt_t vector) { - if (!vector->is_s64vector()) - throw wrong_type("pmt_s64vector_elements", vector); - size_t len; - const int64_t *array = _s64vector(vector)->elements(len); - const std::vector< int64_t > vec(array, array+len); - return vec; + if (!vector->is_s64vector()) + throw wrong_type("pmt_s64vector_elements", vector); + size_t len; + const int64_t* array = _s64vector(vector)->elements(len); + const std::vector<int64_t> vec(array, array + len); + return vec; } -int64_t * -s64vector_writable_elements(pmt_t vector, size_t &len) +int64_t* s64vector_writable_elements(pmt_t vector, size_t& len) { - if (!vector->is_s64vector()) - throw wrong_type("pmt_s64vector_writable_elements", vector); - return _s64vector(vector)->writable_elements(len); + if (!vector->is_s64vector()) + throw wrong_type("pmt_s64vector_writable_elements", vector); + return _s64vector(vector)->writable_elements(len); } -const std::string -pmt_s64vector::string_ref(size_t k) const +const std::string pmt_s64vector::string_ref(size_t k) const { - return std::to_string(ref(k)); + return std::to_string(ref(k)); } } /* namespace pmt */ @@ -1229,146 +1040,122 @@ pmt_s64vector::string_ref(size_t k) const namespace pmt { -static pmt_f32vector * -_f32vector(pmt_t x) +static pmt_f32vector* _f32vector(pmt_t x) { - return dynamic_cast<pmt_f32vector*>(x.get()); + return dynamic_cast<pmt_f32vector*>(x.get()); } -pmt_f32vector::pmt_f32vector(size_t k, float fill) - : d_v(k) +pmt_f32vector::pmt_f32vector(size_t k, float fill) : d_v(k) { - for (size_t i = 0; i < k; i++) - d_v[i] = fill; + for (size_t i = 0; i < k; i++) + d_v[i] = fill; } -pmt_f32vector::pmt_f32vector(size_t k, const float *data) - : d_v(k) +pmt_f32vector::pmt_f32vector(size_t k, const float* data) : d_v(k) { - if(k) - memcpy( &d_v[0], data, k * sizeof(float) ); + if (k) + memcpy(&d_v[0], data, k * sizeof(float)); } -float -pmt_f32vector::ref(size_t k) const +float pmt_f32vector::ref(size_t k) const { - if (k >= length()) - throw out_of_range("pmt_f32vector_ref", from_long(k)); - return d_v[k]; + if (k >= length()) + throw out_of_range("pmt_f32vector_ref", from_long(k)); + return d_v[k]; } -void -pmt_f32vector::set(size_t k, float x) +void pmt_f32vector::set(size_t k, float x) { - if (k >= length()) - throw out_of_range("pmt_f32vector_set", from_long(k)); - d_v[k] = x; + if (k >= length()) + throw out_of_range("pmt_f32vector_set", from_long(k)); + d_v[k] = x; } -const float * -pmt_f32vector::elements(size_t &len) +const float* pmt_f32vector::elements(size_t& len) { - len = length(); - return len ? &d_v[0] : nullptr; + len = length(); + return len ? &d_v[0] : nullptr; } -float * -pmt_f32vector::writable_elements(size_t &len) +float* pmt_f32vector::writable_elements(size_t& len) { - len = length(); - return len ? &d_v[0] : nullptr; + len = length(); + return len ? &d_v[0] : nullptr; } -const void* -pmt_f32vector::uniform_elements(size_t &len) +const void* pmt_f32vector::uniform_elements(size_t& len) { - len = length() * sizeof(float); - return len ? &d_v[0] : nullptr; + len = length() * sizeof(float); + return len ? &d_v[0] : nullptr; } -void* -pmt_f32vector::uniform_writable_elements(size_t &len) +void* pmt_f32vector::uniform_writable_elements(size_t& len) { - len = length() * sizeof(float); - return len ? (&d_v[0]) : nullptr; + len = length() * sizeof(float); + return len ? (&d_v[0]) : nullptr; } -bool -is_f32vector(pmt_t obj) -{ - return obj->is_f32vector(); -} +bool is_f32vector(pmt_t obj) { return obj->is_f32vector(); } -pmt_t -make_f32vector(size_t k, float fill) -{ - return pmt_t(new pmt_f32vector(k, fill)); -} +pmt_t make_f32vector(size_t k, float fill) { return pmt_t(new pmt_f32vector(k, fill)); } -pmt_t -init_f32vector(size_t k, const float *data) +pmt_t init_f32vector(size_t k, const float* data) { - return pmt_t(new pmt_f32vector(k, data)); + return pmt_t(new pmt_f32vector(k, data)); } -pmt_t -init_f32vector(size_t k, const std::vector< float > &data) +pmt_t init_f32vector(size_t k, const std::vector<float>& data) { - if(k) { - return pmt_t(new pmt_f32vector(k, &data[0])); - } - return pmt_t(new pmt_f32vector(k, static_cast< float >(0))); // fills an empty vector with 0 + if (k) { + return pmt_t(new pmt_f32vector(k, &data[0])); + } + return pmt_t( + new pmt_f32vector(k, static_cast<float>(0))); // fills an empty vector with 0 } -float -f32vector_ref(pmt_t vector, size_t k) +float f32vector_ref(pmt_t vector, size_t k) { - if (!vector->is_f32vector()) - throw wrong_type("pmt_f32vector_ref", vector); - return _f32vector(vector)->ref(k); + if (!vector->is_f32vector()) + throw wrong_type("pmt_f32vector_ref", vector); + return _f32vector(vector)->ref(k); } -void -f32vector_set(pmt_t vector, size_t k, float obj) +void f32vector_set(pmt_t vector, size_t k, float obj) { - if (!vector->is_f32vector()) - throw wrong_type("pmt_f32vector_set", vector); - _f32vector(vector)->set(k, obj); + if (!vector->is_f32vector()) + throw wrong_type("pmt_f32vector_set", vector); + _f32vector(vector)->set(k, obj); } -const float * -f32vector_elements(pmt_t vector, size_t &len) +const float* f32vector_elements(pmt_t vector, size_t& len) { - if (!vector->is_f32vector()) - throw wrong_type("pmt_f32vector_elements", vector); - return _f32vector(vector)->elements(len); + if (!vector->is_f32vector()) + throw wrong_type("pmt_f32vector_elements", vector); + return _f32vector(vector)->elements(len); } -const std::vector< float > -f32vector_elements(pmt_t vector) +const std::vector<float> f32vector_elements(pmt_t vector) { - if (!vector->is_f32vector()) - throw wrong_type("pmt_f32vector_elements", vector); - size_t len; - const float *array = _f32vector(vector)->elements(len); - const std::vector< float > vec(array, array+len); - return vec; + if (!vector->is_f32vector()) + throw wrong_type("pmt_f32vector_elements", vector); + size_t len; + const float* array = _f32vector(vector)->elements(len); + const std::vector<float> vec(array, array + len); + return vec; } -float * -f32vector_writable_elements(pmt_t vector, size_t &len) +float* f32vector_writable_elements(pmt_t vector, size_t& len) { - if (!vector->is_f32vector()) - throw wrong_type("pmt_f32vector_writable_elements", vector); - return _f32vector(vector)->writable_elements(len); + if (!vector->is_f32vector()) + throw wrong_type("pmt_f32vector_writable_elements", vector); + return _f32vector(vector)->writable_elements(len); } -const std::string -pmt_f32vector::string_ref(size_t k) const +const std::string pmt_f32vector::string_ref(size_t k) const { - return boost::lexical_cast< std::string, float > (ref(k)); + return boost::lexical_cast<std::string, float>(ref(k)); } } /* namespace pmt */ @@ -1378,146 +1165,122 @@ pmt_f32vector::string_ref(size_t k) const namespace pmt { -static pmt_f64vector * -_f64vector(pmt_t x) +static pmt_f64vector* _f64vector(pmt_t x) { - return dynamic_cast<pmt_f64vector*>(x.get()); + return dynamic_cast<pmt_f64vector*>(x.get()); } -pmt_f64vector::pmt_f64vector(size_t k, double fill) - : d_v(k) +pmt_f64vector::pmt_f64vector(size_t k, double fill) : d_v(k) { - for (size_t i = 0; i < k; i++) - d_v[i] = fill; + for (size_t i = 0; i < k; i++) + d_v[i] = fill; } -pmt_f64vector::pmt_f64vector(size_t k, const double *data) - : d_v(k) +pmt_f64vector::pmt_f64vector(size_t k, const double* data) : d_v(k) { - if(k) - memcpy( &d_v[0], data, k * sizeof(double) ); + if (k) + memcpy(&d_v[0], data, k * sizeof(double)); } -double -pmt_f64vector::ref(size_t k) const +double pmt_f64vector::ref(size_t k) const { - if (k >= length()) - throw out_of_range("pmt_f64vector_ref", from_long(k)); - return d_v[k]; + if (k >= length()) + throw out_of_range("pmt_f64vector_ref", from_long(k)); + return d_v[k]; } -void -pmt_f64vector::set(size_t k, double x) +void pmt_f64vector::set(size_t k, double x) { - if (k >= length()) - throw out_of_range("pmt_f64vector_set", from_long(k)); - d_v[k] = x; + if (k >= length()) + throw out_of_range("pmt_f64vector_set", from_long(k)); + d_v[k] = x; } -const double * -pmt_f64vector::elements(size_t &len) +const double* pmt_f64vector::elements(size_t& len) { - len = length(); - return len ? &d_v[0] : nullptr; + len = length(); + return len ? &d_v[0] : nullptr; } -double * -pmt_f64vector::writable_elements(size_t &len) +double* pmt_f64vector::writable_elements(size_t& len) { - len = length(); - return len ? &d_v[0] : nullptr; + len = length(); + return len ? &d_v[0] : nullptr; } -const void* -pmt_f64vector::uniform_elements(size_t &len) +const void* pmt_f64vector::uniform_elements(size_t& len) { - len = length() * sizeof(double); - return len ? &d_v[0] : nullptr; + len = length() * sizeof(double); + return len ? &d_v[0] : nullptr; } -void* -pmt_f64vector::uniform_writable_elements(size_t &len) +void* pmt_f64vector::uniform_writable_elements(size_t& len) { - len = length() * sizeof(double); - return len ? (&d_v[0]) : nullptr; + len = length() * sizeof(double); + return len ? (&d_v[0]) : nullptr; } -bool -is_f64vector(pmt_t obj) -{ - return obj->is_f64vector(); -} +bool is_f64vector(pmt_t obj) { return obj->is_f64vector(); } -pmt_t -make_f64vector(size_t k, double fill) -{ - return pmt_t(new pmt_f64vector(k, fill)); -} +pmt_t make_f64vector(size_t k, double fill) { return pmt_t(new pmt_f64vector(k, fill)); } -pmt_t -init_f64vector(size_t k, const double *data) +pmt_t init_f64vector(size_t k, const double* data) { - return pmt_t(new pmt_f64vector(k, data)); + return pmt_t(new pmt_f64vector(k, data)); } -pmt_t -init_f64vector(size_t k, const std::vector< double > &data) +pmt_t init_f64vector(size_t k, const std::vector<double>& data) { - if(k) { - return pmt_t(new pmt_f64vector(k, &data[0])); - } - return pmt_t(new pmt_f64vector(k, static_cast< double >(0))); // fills an empty vector with 0 + if (k) { + return pmt_t(new pmt_f64vector(k, &data[0])); + } + return pmt_t( + new pmt_f64vector(k, static_cast<double>(0))); // fills an empty vector with 0 } -double -f64vector_ref(pmt_t vector, size_t k) +double f64vector_ref(pmt_t vector, size_t k) { - if (!vector->is_f64vector()) - throw wrong_type("pmt_f64vector_ref", vector); - return _f64vector(vector)->ref(k); + if (!vector->is_f64vector()) + throw wrong_type("pmt_f64vector_ref", vector); + return _f64vector(vector)->ref(k); } -void -f64vector_set(pmt_t vector, size_t k, double obj) +void f64vector_set(pmt_t vector, size_t k, double obj) { - if (!vector->is_f64vector()) - throw wrong_type("pmt_f64vector_set", vector); - _f64vector(vector)->set(k, obj); + if (!vector->is_f64vector()) + throw wrong_type("pmt_f64vector_set", vector); + _f64vector(vector)->set(k, obj); } -const double * -f64vector_elements(pmt_t vector, size_t &len) +const double* f64vector_elements(pmt_t vector, size_t& len) { - if (!vector->is_f64vector()) - throw wrong_type("pmt_f64vector_elements", vector); - return _f64vector(vector)->elements(len); + if (!vector->is_f64vector()) + throw wrong_type("pmt_f64vector_elements", vector); + return _f64vector(vector)->elements(len); } -const std::vector< double > -f64vector_elements(pmt_t vector) +const std::vector<double> f64vector_elements(pmt_t vector) { - if (!vector->is_f64vector()) - throw wrong_type("pmt_f64vector_elements", vector); - size_t len; - const double *array = _f64vector(vector)->elements(len); - const std::vector< double > vec(array, array+len); - return vec; + if (!vector->is_f64vector()) + throw wrong_type("pmt_f64vector_elements", vector); + size_t len; + const double* array = _f64vector(vector)->elements(len); + const std::vector<double> vec(array, array + len); + return vec; } -double * -f64vector_writable_elements(pmt_t vector, size_t &len) +double* f64vector_writable_elements(pmt_t vector, size_t& len) { - if (!vector->is_f64vector()) - throw wrong_type("pmt_f64vector_writable_elements", vector); - return _f64vector(vector)->writable_elements(len); + if (!vector->is_f64vector()) + throw wrong_type("pmt_f64vector_writable_elements", vector); + return _f64vector(vector)->writable_elements(len); } -const std::string -pmt_f64vector::string_ref(size_t k) const +const std::string pmt_f64vector::string_ref(size_t k) const { - return boost::lexical_cast< std::string, double > (ref(k)); + return boost::lexical_cast<std::string, double>(ref(k)); } } /* namespace pmt */ @@ -1527,146 +1290,125 @@ pmt_f64vector::string_ref(size_t k) const namespace pmt { -static pmt_c32vector * -_c32vector(pmt_t x) +static pmt_c32vector* _c32vector(pmt_t x) { - return dynamic_cast<pmt_c32vector*>(x.get()); + return dynamic_cast<pmt_c32vector*>(x.get()); } -pmt_c32vector::pmt_c32vector(size_t k, std::complex<float> fill) - : d_v(k) +pmt_c32vector::pmt_c32vector(size_t k, std::complex<float> fill) : d_v(k) { - for (size_t i = 0; i < k; i++) - d_v[i] = fill; + for (size_t i = 0; i < k; i++) + d_v[i] = fill; } -pmt_c32vector::pmt_c32vector(size_t k, const std::complex<float> *data) - : d_v(k) +pmt_c32vector::pmt_c32vector(size_t k, const std::complex<float>* data) : d_v(k) { - if(k) - memcpy( &d_v[0], data, k * sizeof(std::complex<float>) ); + if (k) + memcpy(&d_v[0], data, k * sizeof(std::complex<float>)); } -std::complex<float> -pmt_c32vector::ref(size_t k) const +std::complex<float> pmt_c32vector::ref(size_t k) const { - if (k >= length()) - throw out_of_range("pmt_c32vector_ref", from_long(k)); - return d_v[k]; + if (k >= length()) + throw out_of_range("pmt_c32vector_ref", from_long(k)); + return d_v[k]; } -void -pmt_c32vector::set(size_t k, std::complex<float> x) +void pmt_c32vector::set(size_t k, std::complex<float> x) { - if (k >= length()) - throw out_of_range("pmt_c32vector_set", from_long(k)); - d_v[k] = x; + if (k >= length()) + throw out_of_range("pmt_c32vector_set", from_long(k)); + d_v[k] = x; } -const std::complex<float> * -pmt_c32vector::elements(size_t &len) +const std::complex<float>* pmt_c32vector::elements(size_t& len) { - len = length(); - return len ? &d_v[0] : nullptr; + len = length(); + return len ? &d_v[0] : nullptr; } -std::complex<float> * -pmt_c32vector::writable_elements(size_t &len) +std::complex<float>* pmt_c32vector::writable_elements(size_t& len) { - len = length(); - return len ? &d_v[0] : nullptr; + len = length(); + return len ? &d_v[0] : nullptr; } -const void* -pmt_c32vector::uniform_elements(size_t &len) +const void* pmt_c32vector::uniform_elements(size_t& len) { - len = length() * sizeof(std::complex<float>); - return len ? &d_v[0] : nullptr; + len = length() * sizeof(std::complex<float>); + return len ? &d_v[0] : nullptr; } -void* -pmt_c32vector::uniform_writable_elements(size_t &len) +void* pmt_c32vector::uniform_writable_elements(size_t& len) { - len = length() * sizeof(std::complex<float>); - return len ? (&d_v[0]) : nullptr; + len = length() * sizeof(std::complex<float>); + return len ? (&d_v[0]) : nullptr; } -bool -is_c32vector(pmt_t obj) -{ - return obj->is_c32vector(); -} +bool is_c32vector(pmt_t obj) { return obj->is_c32vector(); } -pmt_t -make_c32vector(size_t k, std::complex<float> fill) +pmt_t make_c32vector(size_t k, std::complex<float> fill) { - return pmt_t(new pmt_c32vector(k, fill)); + return pmt_t(new pmt_c32vector(k, fill)); } -pmt_t -init_c32vector(size_t k, const std::complex<float> *data) +pmt_t init_c32vector(size_t k, const std::complex<float>* data) { - return pmt_t(new pmt_c32vector(k, data)); + return pmt_t(new pmt_c32vector(k, data)); } -pmt_t -init_c32vector(size_t k, const std::vector< std::complex<float> > &data) +pmt_t init_c32vector(size_t k, const std::vector<std::complex<float>>& data) { - if(k) { - return pmt_t(new pmt_c32vector(k, &data[0])); - } - return pmt_t(new pmt_c32vector(k, static_cast< std::complex<float> >(0))); // fills an empty vector with 0 + if (k) { + return pmt_t(new pmt_c32vector(k, &data[0])); + } + return pmt_t(new pmt_c32vector( + k, static_cast<std::complex<float>>(0))); // fills an empty vector with 0 } -std::complex<float> -c32vector_ref(pmt_t vector, size_t k) +std::complex<float> c32vector_ref(pmt_t vector, size_t k) { - if (!vector->is_c32vector()) - throw wrong_type("pmt_c32vector_ref", vector); - return _c32vector(vector)->ref(k); + if (!vector->is_c32vector()) + throw wrong_type("pmt_c32vector_ref", vector); + return _c32vector(vector)->ref(k); } -void -c32vector_set(pmt_t vector, size_t k, std::complex<float> obj) +void c32vector_set(pmt_t vector, size_t k, std::complex<float> obj) { - if (!vector->is_c32vector()) - throw wrong_type("pmt_c32vector_set", vector); - _c32vector(vector)->set(k, obj); + if (!vector->is_c32vector()) + throw wrong_type("pmt_c32vector_set", vector); + _c32vector(vector)->set(k, obj); } -const std::complex<float> * -c32vector_elements(pmt_t vector, size_t &len) +const std::complex<float>* c32vector_elements(pmt_t vector, size_t& len) { - if (!vector->is_c32vector()) - throw wrong_type("pmt_c32vector_elements", vector); - return _c32vector(vector)->elements(len); + if (!vector->is_c32vector()) + throw wrong_type("pmt_c32vector_elements", vector); + return _c32vector(vector)->elements(len); } -const std::vector< std::complex<float> > -c32vector_elements(pmt_t vector) +const std::vector<std::complex<float>> c32vector_elements(pmt_t vector) { - if (!vector->is_c32vector()) - throw wrong_type("pmt_c32vector_elements", vector); - size_t len; - const std::complex<float> *array = _c32vector(vector)->elements(len); - const std::vector< std::complex<float> > vec(array, array+len); - return vec; + if (!vector->is_c32vector()) + throw wrong_type("pmt_c32vector_elements", vector); + size_t len; + const std::complex<float>* array = _c32vector(vector)->elements(len); + const std::vector<std::complex<float>> vec(array, array + len); + return vec; } -std::complex<float> * -c32vector_writable_elements(pmt_t vector, size_t &len) +std::complex<float>* c32vector_writable_elements(pmt_t vector, size_t& len) { - if (!vector->is_c32vector()) - throw wrong_type("pmt_c32vector_writable_elements", vector); - return _c32vector(vector)->writable_elements(len); + if (!vector->is_c32vector()) + throw wrong_type("pmt_c32vector_writable_elements", vector); + return _c32vector(vector)->writable_elements(len); } -const std::string -pmt_c32vector::string_ref(size_t k) const +const std::string pmt_c32vector::string_ref(size_t k) const { - return boost::lexical_cast< std::string, std::complex<float> > (ref(k)); + return boost::lexical_cast<std::string, std::complex<float>>(ref(k)); } } /* namespace pmt */ @@ -1676,146 +1418,125 @@ pmt_c32vector::string_ref(size_t k) const namespace pmt { -static pmt_c64vector * -_c64vector(pmt_t x) +static pmt_c64vector* _c64vector(pmt_t x) { - return dynamic_cast<pmt_c64vector*>(x.get()); + return dynamic_cast<pmt_c64vector*>(x.get()); } -pmt_c64vector::pmt_c64vector(size_t k, std::complex<double> fill) - : d_v(k) +pmt_c64vector::pmt_c64vector(size_t k, std::complex<double> fill) : d_v(k) { - for (size_t i = 0; i < k; i++) - d_v[i] = fill; + for (size_t i = 0; i < k; i++) + d_v[i] = fill; } -pmt_c64vector::pmt_c64vector(size_t k, const std::complex<double> *data) - : d_v(k) +pmt_c64vector::pmt_c64vector(size_t k, const std::complex<double>* data) : d_v(k) { - if(k) - memcpy( &d_v[0], data, k * sizeof(std::complex<double>) ); + if (k) + memcpy(&d_v[0], data, k * sizeof(std::complex<double>)); } -std::complex<double> -pmt_c64vector::ref(size_t k) const +std::complex<double> pmt_c64vector::ref(size_t k) const { - if (k >= length()) - throw out_of_range("pmt_c64vector_ref", from_long(k)); - return d_v[k]; + if (k >= length()) + throw out_of_range("pmt_c64vector_ref", from_long(k)); + return d_v[k]; } -void -pmt_c64vector::set(size_t k, std::complex<double> x) +void pmt_c64vector::set(size_t k, std::complex<double> x) { - if (k >= length()) - throw out_of_range("pmt_c64vector_set", from_long(k)); - d_v[k] = x; + if (k >= length()) + throw out_of_range("pmt_c64vector_set", from_long(k)); + d_v[k] = x; } -const std::complex<double> * -pmt_c64vector::elements(size_t &len) +const std::complex<double>* pmt_c64vector::elements(size_t& len) { - len = length(); - return len ? &d_v[0] : nullptr; + len = length(); + return len ? &d_v[0] : nullptr; } -std::complex<double> * -pmt_c64vector::writable_elements(size_t &len) +std::complex<double>* pmt_c64vector::writable_elements(size_t& len) { - len = length(); - return len ? &d_v[0] : nullptr; + len = length(); + return len ? &d_v[0] : nullptr; } -const void* -pmt_c64vector::uniform_elements(size_t &len) +const void* pmt_c64vector::uniform_elements(size_t& len) { - len = length() * sizeof(std::complex<double>); - return len ? &d_v[0] : nullptr; + len = length() * sizeof(std::complex<double>); + return len ? &d_v[0] : nullptr; } -void* -pmt_c64vector::uniform_writable_elements(size_t &len) +void* pmt_c64vector::uniform_writable_elements(size_t& len) { - len = length() * sizeof(std::complex<double>); - return len ? (&d_v[0]) : nullptr; + len = length() * sizeof(std::complex<double>); + return len ? (&d_v[0]) : nullptr; } -bool -is_c64vector(pmt_t obj) -{ - return obj->is_c64vector(); -} +bool is_c64vector(pmt_t obj) { return obj->is_c64vector(); } -pmt_t -make_c64vector(size_t k, std::complex<double> fill) +pmt_t make_c64vector(size_t k, std::complex<double> fill) { - return pmt_t(new pmt_c64vector(k, fill)); + return pmt_t(new pmt_c64vector(k, fill)); } -pmt_t -init_c64vector(size_t k, const std::complex<double> *data) +pmt_t init_c64vector(size_t k, const std::complex<double>* data) { - return pmt_t(new pmt_c64vector(k, data)); + return pmt_t(new pmt_c64vector(k, data)); } -pmt_t -init_c64vector(size_t k, const std::vector< std::complex<double> > &data) +pmt_t init_c64vector(size_t k, const std::vector<std::complex<double>>& data) { - if(k) { - return pmt_t(new pmt_c64vector(k, &data[0])); - } - return pmt_t(new pmt_c64vector(k, static_cast< std::complex<double> >(0))); // fills an empty vector with 0 + if (k) { + return pmt_t(new pmt_c64vector(k, &data[0])); + } + return pmt_t(new pmt_c64vector( + k, static_cast<std::complex<double>>(0))); // fills an empty vector with 0 } -std::complex<double> -c64vector_ref(pmt_t vector, size_t k) +std::complex<double> c64vector_ref(pmt_t vector, size_t k) { - if (!vector->is_c64vector()) - throw wrong_type("pmt_c64vector_ref", vector); - return _c64vector(vector)->ref(k); + if (!vector->is_c64vector()) + throw wrong_type("pmt_c64vector_ref", vector); + return _c64vector(vector)->ref(k); } -void -c64vector_set(pmt_t vector, size_t k, std::complex<double> obj) +void c64vector_set(pmt_t vector, size_t k, std::complex<double> obj) { - if (!vector->is_c64vector()) - throw wrong_type("pmt_c64vector_set", vector); - _c64vector(vector)->set(k, obj); + if (!vector->is_c64vector()) + throw wrong_type("pmt_c64vector_set", vector); + _c64vector(vector)->set(k, obj); } -const std::complex<double> * -c64vector_elements(pmt_t vector, size_t &len) +const std::complex<double>* c64vector_elements(pmt_t vector, size_t& len) { - if (!vector->is_c64vector()) - throw wrong_type("pmt_c64vector_elements", vector); - return _c64vector(vector)->elements(len); + if (!vector->is_c64vector()) + throw wrong_type("pmt_c64vector_elements", vector); + return _c64vector(vector)->elements(len); } -const std::vector< std::complex<double> > -c64vector_elements(pmt_t vector) +const std::vector<std::complex<double>> c64vector_elements(pmt_t vector) { - if (!vector->is_c64vector()) - throw wrong_type("pmt_c64vector_elements", vector); - size_t len; - const std::complex<double> *array = _c64vector(vector)->elements(len); - const std::vector< std::complex<double> > vec(array, array+len); - return vec; + if (!vector->is_c64vector()) + throw wrong_type("pmt_c64vector_elements", vector); + size_t len; + const std::complex<double>* array = _c64vector(vector)->elements(len); + const std::vector<std::complex<double>> vec(array, array + len); + return vec; } -std::complex<double> * -c64vector_writable_elements(pmt_t vector, size_t &len) +std::complex<double>* c64vector_writable_elements(pmt_t vector, size_t& len) { - if (!vector->is_c64vector()) - throw wrong_type("pmt_c64vector_writable_elements", vector); - return _c64vector(vector)->writable_elements(len); + if (!vector->is_c64vector()) + throw wrong_type("pmt_c64vector_writable_elements", vector); + return _c64vector(vector)->writable_elements(len); } -const std::string -pmt_c64vector::string_ref(size_t k) const +const std::string pmt_c64vector::string_ref(size_t k) const { - return boost::lexical_cast< std::string, std::complex<double> > (ref(k)); + return boost::lexical_cast<std::string, std::complex<double>>(ref(k)); } } /* namespace pmt */ diff --git a/gnuradio-runtime/lib/pmt/pmt_unv_int.h b/gnuradio-runtime/lib/pmt/pmt_unv_int.h index 4b4364b411..c2e2617f63 100644 --- a/gnuradio-runtime/lib/pmt/pmt_unv_int.h +++ b/gnuradio-runtime/lib/pmt/pmt_unv_int.h @@ -28,29 +28,29 @@ #include <vector> #include <cstdint> -namespace pmt{ +namespace pmt { //////////////////////////////////////////////////////////////////////////// // pmt_u8vector //////////////////////////////////////////////////////////////////////////// class PMT_API pmt_u8vector : public pmt_uniform_vector { - std::vector< uint8_t > d_v; + std::vector<uint8_t> d_v; public: - pmt_u8vector(size_t k, uint8_t fill); - pmt_u8vector(size_t k, const uint8_t *data); - // ~pmt_u8vector(); - - bool is_u8vector() const { return true; } - size_t length() const { return d_v.size(); } - size_t itemsize() const { return sizeof(uint8_t); } - uint8_t ref(size_t k) const; - void set(size_t k, uint8_t x); - const uint8_t *elements(size_t &len); - uint8_t *writable_elements(size_t &len); - const void *uniform_elements(size_t &len); - void *uniform_writable_elements(size_t &len); - virtual const std::string string_ref(size_t k) const; + pmt_u8vector(size_t k, uint8_t fill); + pmt_u8vector(size_t k, const uint8_t* data); + // ~pmt_u8vector(); + + bool is_u8vector() const { return true; } + size_t length() const { return d_v.size(); } + size_t itemsize() const { return sizeof(uint8_t); } + uint8_t ref(size_t k) const; + void set(size_t k, uint8_t x); + const uint8_t* elements(size_t& len); + uint8_t* writable_elements(size_t& len); + const void* uniform_elements(size_t& len); + void* uniform_writable_elements(size_t& len); + virtual const std::string string_ref(size_t k) const; }; //////////////////////////////////////////////////////////////////////////// @@ -59,23 +59,23 @@ public: class pmt_s8vector : public pmt_uniform_vector { - std::vector< int8_t > d_v; + std::vector<int8_t> d_v; public: - pmt_s8vector(size_t k, int8_t fill); - pmt_s8vector(size_t k, const int8_t *data); - // ~pmt_s8vector(); - - bool is_s8vector() const { return true; } - size_t length() const { return d_v.size(); } - size_t itemsize() const { return sizeof(int8_t); } - int8_t ref(size_t k) const; - void set(size_t k, int8_t x); - const int8_t *elements(size_t &len); - int8_t *writable_elements(size_t &len); - const void *uniform_elements(size_t &len); - void *uniform_writable_elements(size_t &len); - virtual const std::string string_ref(size_t k) const; + pmt_s8vector(size_t k, int8_t fill); + pmt_s8vector(size_t k, const int8_t* data); + // ~pmt_s8vector(); + + bool is_s8vector() const { return true; } + size_t length() const { return d_v.size(); } + size_t itemsize() const { return sizeof(int8_t); } + int8_t ref(size_t k) const; + void set(size_t k, int8_t x); + const int8_t* elements(size_t& len); + int8_t* writable_elements(size_t& len); + const void* uniform_elements(size_t& len); + void* uniform_writable_elements(size_t& len); + virtual const std::string string_ref(size_t k) const; }; //////////////////////////////////////////////////////////////////////////// @@ -84,23 +84,23 @@ public: class pmt_u16vector : public pmt_uniform_vector { - std::vector< uint16_t > d_v; + std::vector<uint16_t> d_v; public: - pmt_u16vector(size_t k, uint16_t fill); - pmt_u16vector(size_t k, const uint16_t *data); - // ~pmt_u16vector(); - - bool is_u16vector() const { return true; } - size_t length() const { return d_v.size(); } - size_t itemsize() const { return sizeof(uint16_t); } - uint16_t ref(size_t k) const; - void set(size_t k, uint16_t x); - const uint16_t *elements(size_t &len); - uint16_t *writable_elements(size_t &len); - const void *uniform_elements(size_t &len); - void *uniform_writable_elements(size_t &len); - virtual const std::string string_ref(size_t k) const; + pmt_u16vector(size_t k, uint16_t fill); + pmt_u16vector(size_t k, const uint16_t* data); + // ~pmt_u16vector(); + + bool is_u16vector() const { return true; } + size_t length() const { return d_v.size(); } + size_t itemsize() const { return sizeof(uint16_t); } + uint16_t ref(size_t k) const; + void set(size_t k, uint16_t x); + const uint16_t* elements(size_t& len); + uint16_t* writable_elements(size_t& len); + const void* uniform_elements(size_t& len); + void* uniform_writable_elements(size_t& len); + virtual const std::string string_ref(size_t k) const; }; //////////////////////////////////////////////////////////////////////////// @@ -109,23 +109,23 @@ public: class pmt_s16vector : public pmt_uniform_vector { - std::vector< int16_t > d_v; + std::vector<int16_t> d_v; public: - pmt_s16vector(size_t k, int16_t fill); - pmt_s16vector(size_t k, const int16_t *data); - // ~pmt_s16vector(); - - bool is_s16vector() const { return true; } - size_t length() const { return d_v.size(); } - size_t itemsize() const { return sizeof(int16_t); } - int16_t ref(size_t k) const; - void set(size_t k, int16_t x); - const int16_t *elements(size_t &len); - int16_t *writable_elements(size_t &len); - const void *uniform_elements(size_t &len); - void *uniform_writable_elements(size_t &len); - virtual const std::string string_ref(size_t k) const; + pmt_s16vector(size_t k, int16_t fill); + pmt_s16vector(size_t k, const int16_t* data); + // ~pmt_s16vector(); + + bool is_s16vector() const { return true; } + size_t length() const { return d_v.size(); } + size_t itemsize() const { return sizeof(int16_t); } + int16_t ref(size_t k) const; + void set(size_t k, int16_t x); + const int16_t* elements(size_t& len); + int16_t* writable_elements(size_t& len); + const void* uniform_elements(size_t& len); + void* uniform_writable_elements(size_t& len); + virtual const std::string string_ref(size_t k) const; }; //////////////////////////////////////////////////////////////////////////// @@ -134,23 +134,23 @@ public: class pmt_u32vector : public pmt_uniform_vector { - std::vector< uint32_t > d_v; + std::vector<uint32_t> d_v; public: - pmt_u32vector(size_t k, uint32_t fill); - pmt_u32vector(size_t k, const uint32_t *data); - // ~pmt_u32vector(); - - bool is_u32vector() const { return true; } - size_t length() const { return d_v.size(); } - size_t itemsize() const { return sizeof(uint32_t); } - uint32_t ref(size_t k) const; - void set(size_t k, uint32_t x); - const uint32_t *elements(size_t &len); - uint32_t *writable_elements(size_t &len); - const void *uniform_elements(size_t &len); - void *uniform_writable_elements(size_t &len); - virtual const std::string string_ref(size_t k) const; + pmt_u32vector(size_t k, uint32_t fill); + pmt_u32vector(size_t k, const uint32_t* data); + // ~pmt_u32vector(); + + bool is_u32vector() const { return true; } + size_t length() const { return d_v.size(); } + size_t itemsize() const { return sizeof(uint32_t); } + uint32_t ref(size_t k) const; + void set(size_t k, uint32_t x); + const uint32_t* elements(size_t& len); + uint32_t* writable_elements(size_t& len); + const void* uniform_elements(size_t& len); + void* uniform_writable_elements(size_t& len); + virtual const std::string string_ref(size_t k) const; }; //////////////////////////////////////////////////////////////////////////// @@ -159,23 +159,23 @@ public: class pmt_s32vector : public pmt_uniform_vector { - std::vector< int32_t > d_v; + std::vector<int32_t> d_v; public: - pmt_s32vector(size_t k, int32_t fill); - pmt_s32vector(size_t k, const int32_t *data); - // ~pmt_s32vector(); - - bool is_s32vector() const { return true; } - size_t length() const { return d_v.size(); } - size_t itemsize() const { return sizeof(int32_t); } - int32_t ref(size_t k) const; - void set(size_t k, int32_t x); - const int32_t *elements(size_t &len); - int32_t *writable_elements(size_t &len); - const void *uniform_elements(size_t &len); - void *uniform_writable_elements(size_t &len); - virtual const std::string string_ref(size_t k) const; + pmt_s32vector(size_t k, int32_t fill); + pmt_s32vector(size_t k, const int32_t* data); + // ~pmt_s32vector(); + + bool is_s32vector() const { return true; } + size_t length() const { return d_v.size(); } + size_t itemsize() const { return sizeof(int32_t); } + int32_t ref(size_t k) const; + void set(size_t k, int32_t x); + const int32_t* elements(size_t& len); + int32_t* writable_elements(size_t& len); + const void* uniform_elements(size_t& len); + void* uniform_writable_elements(size_t& len); + virtual const std::string string_ref(size_t k) const; }; //////////////////////////////////////////////////////////////////////////// @@ -184,23 +184,23 @@ public: class pmt_u64vector : public pmt_uniform_vector { - std::vector< uint64_t > d_v; + std::vector<uint64_t> d_v; public: - pmt_u64vector(size_t k, uint64_t fill); - pmt_u64vector(size_t k, const uint64_t *data); - // ~pmt_u64vector(); - - bool is_u64vector() const { return true; } - size_t length() const { return d_v.size(); } - size_t itemsize() const { return sizeof(uint64_t); } - uint64_t ref(size_t k) const; - void set(size_t k, uint64_t x); - const uint64_t *elements(size_t &len); - uint64_t *writable_elements(size_t &len); - const void *uniform_elements(size_t &len); - void *uniform_writable_elements(size_t &len); - virtual const std::string string_ref(size_t k) const; + pmt_u64vector(size_t k, uint64_t fill); + pmt_u64vector(size_t k, const uint64_t* data); + // ~pmt_u64vector(); + + bool is_u64vector() const { return true; } + size_t length() const { return d_v.size(); } + size_t itemsize() const { return sizeof(uint64_t); } + uint64_t ref(size_t k) const; + void set(size_t k, uint64_t x); + const uint64_t* elements(size_t& len); + uint64_t* writable_elements(size_t& len); + const void* uniform_elements(size_t& len); + void* uniform_writable_elements(size_t& len); + virtual const std::string string_ref(size_t k) const; }; //////////////////////////////////////////////////////////////////////////// @@ -209,23 +209,23 @@ public: class pmt_s64vector : public pmt_uniform_vector { - std::vector< int64_t > d_v; + std::vector<int64_t> d_v; public: - pmt_s64vector(size_t k, int64_t fill); - pmt_s64vector(size_t k, const int64_t *data); - // ~pmt_s64vector(); - - bool is_s64vector() const { return true; } - size_t length() const { return d_v.size(); } - size_t itemsize() const { return sizeof(int64_t); } - int64_t ref(size_t k) const; - void set(size_t k, int64_t x); - const int64_t *elements(size_t &len); - int64_t *writable_elements(size_t &len); - const void *uniform_elements(size_t &len); - void *uniform_writable_elements(size_t &len); - virtual const std::string string_ref(size_t k) const; + pmt_s64vector(size_t k, int64_t fill); + pmt_s64vector(size_t k, const int64_t* data); + // ~pmt_s64vector(); + + bool is_s64vector() const { return true; } + size_t length() const { return d_v.size(); } + size_t itemsize() const { return sizeof(int64_t); } + int64_t ref(size_t k) const; + void set(size_t k, int64_t x); + const int64_t* elements(size_t& len); + int64_t* writable_elements(size_t& len); + const void* uniform_elements(size_t& len); + void* uniform_writable_elements(size_t& len); + virtual const std::string string_ref(size_t k) const; }; //////////////////////////////////////////////////////////////////////////// @@ -234,23 +234,23 @@ public: class pmt_f32vector : public pmt_uniform_vector { - std::vector< float > d_v; + std::vector<float> d_v; public: - pmt_f32vector(size_t k, float fill); - pmt_f32vector(size_t k, const float *data); - // ~pmt_f32vector(); - - bool is_f32vector() const { return true; } - size_t length() const { return d_v.size(); } - size_t itemsize() const { return sizeof(float); } - float ref(size_t k) const; - void set(size_t k, float x); - const float *elements(size_t &len); - float *writable_elements(size_t &len); - const void *uniform_elements(size_t &len); - void *uniform_writable_elements(size_t &len); - virtual const std::string string_ref(size_t k) const; + pmt_f32vector(size_t k, float fill); + pmt_f32vector(size_t k, const float* data); + // ~pmt_f32vector(); + + bool is_f32vector() const { return true; } + size_t length() const { return d_v.size(); } + size_t itemsize() const { return sizeof(float); } + float ref(size_t k) const; + void set(size_t k, float x); + const float* elements(size_t& len); + float* writable_elements(size_t& len); + const void* uniform_elements(size_t& len); + void* uniform_writable_elements(size_t& len); + virtual const std::string string_ref(size_t k) const; }; //////////////////////////////////////////////////////////////////////////// @@ -259,23 +259,23 @@ public: class pmt_f64vector : public pmt_uniform_vector { - std::vector< double > d_v; + std::vector<double> d_v; public: - pmt_f64vector(size_t k, double fill); - pmt_f64vector(size_t k, const double *data); - // ~pmt_f64vector(); - - bool is_f64vector() const { return true; } - size_t length() const { return d_v.size(); } - size_t itemsize() const { return sizeof(double); } - double ref(size_t k) const; - void set(size_t k, double x); - const double *elements(size_t &len); - double *writable_elements(size_t &len); - const void *uniform_elements(size_t &len); - void *uniform_writable_elements(size_t &len); - virtual const std::string string_ref(size_t k) const; + pmt_f64vector(size_t k, double fill); + pmt_f64vector(size_t k, const double* data); + // ~pmt_f64vector(); + + bool is_f64vector() const { return true; } + size_t length() const { return d_v.size(); } + size_t itemsize() const { return sizeof(double); } + double ref(size_t k) const; + void set(size_t k, double x); + const double* elements(size_t& len); + double* writable_elements(size_t& len); + const void* uniform_elements(size_t& len); + void* uniform_writable_elements(size_t& len); + virtual const std::string string_ref(size_t k) const; }; //////////////////////////////////////////////////////////////////////////// @@ -284,23 +284,23 @@ public: class pmt_c32vector : public pmt_uniform_vector { - std::vector< std::complex<float> > d_v; + std::vector<std::complex<float>> d_v; public: - pmt_c32vector(size_t k, std::complex<float> fill); - pmt_c32vector(size_t k, const std::complex<float> *data); - // ~pmt_c32vector(); - - bool is_c32vector() const { return true; } - size_t length() const { return d_v.size(); } - size_t itemsize() const { return sizeof(std::complex<float>); } - std::complex<float> ref(size_t k) const; - void set(size_t k, std::complex<float> x); - const std::complex<float> *elements(size_t &len); - std::complex<float> *writable_elements(size_t &len); - const void *uniform_elements(size_t &len); - void *uniform_writable_elements(size_t &len); - virtual const std::string string_ref(size_t k) const; + pmt_c32vector(size_t k, std::complex<float> fill); + pmt_c32vector(size_t k, const std::complex<float>* data); + // ~pmt_c32vector(); + + bool is_c32vector() const { return true; } + size_t length() const { return d_v.size(); } + size_t itemsize() const { return sizeof(std::complex<float>); } + std::complex<float> ref(size_t k) const; + void set(size_t k, std::complex<float> x); + const std::complex<float>* elements(size_t& len); + std::complex<float>* writable_elements(size_t& len); + const void* uniform_elements(size_t& len); + void* uniform_writable_elements(size_t& len); + virtual const std::string string_ref(size_t k) const; }; //////////////////////////////////////////////////////////////////////////// @@ -309,23 +309,23 @@ public: class pmt_c64vector : public pmt_uniform_vector { - std::vector< std::complex<double> > d_v; + std::vector<std::complex<double>> d_v; public: - pmt_c64vector(size_t k, std::complex<double> fill); - pmt_c64vector(size_t k, const std::complex<double> *data); - // ~pmt_c64vector(); - - bool is_c64vector() const { return true; } - size_t length() const { return d_v.size(); } - size_t itemsize() const { return sizeof(std::complex<double>); } - std::complex<double> ref(size_t k) const; - void set(size_t k, std::complex<double> x); - const std::complex<double> *elements(size_t &len); - std::complex<double> *writable_elements(size_t &len); - const void *uniform_elements(size_t &len); - void *uniform_writable_elements(size_t &len); - virtual const std::string string_ref(size_t k) const; + pmt_c64vector(size_t k, std::complex<double> fill); + pmt_c64vector(size_t k, const std::complex<double>* data); + // ~pmt_c64vector(); + + bool is_c64vector() const { return true; } + size_t length() const { return d_v.size(); } + size_t itemsize() const { return sizeof(std::complex<double>); } + std::complex<double> ref(size_t k) const; + void set(size_t k, std::complex<double> x); + const std::complex<double>* elements(size_t& len); + std::complex<double>* writable_elements(size_t& len); + const void* uniform_elements(size_t& len); + void* uniform_writable_elements(size_t& len); + virtual const std::string string_ref(size_t k) const; }; } /* namespace pmt */ #endif diff --git a/gnuradio-runtime/lib/pmt/qa_pmt_prims.cc b/gnuradio-runtime/lib/pmt/qa_pmt_prims.cc index 356cf95203..b715d69df4 100644 --- a/gnuradio-runtime/lib/pmt/qa_pmt_prims.cc +++ b/gnuradio-runtime/lib/pmt/qa_pmt_prims.cc @@ -28,384 +28,397 @@ #include <cstring> #include <sstream> -BOOST_AUTO_TEST_CASE(test_symbols) { - BOOST_CHECK(!pmt::is_symbol(pmt::PMT_T)); - BOOST_CHECK(!pmt::is_symbol(pmt::PMT_F)); - BOOST_CHECK_THROW(pmt::symbol_to_string(pmt::PMT_F), pmt::wrong_type); - - pmt::pmt_t sym1 = pmt::mp("test"); - BOOST_CHECK(pmt::is_symbol(sym1)); - BOOST_CHECK_EQUAL(std::string("test"), pmt::symbol_to_string(sym1)); - BOOST_CHECK(pmt::is_true(sym1)); - BOOST_CHECK(!pmt::is_false(sym1)); - - pmt::pmt_t sym2 = pmt::mp("foo"); - pmt::pmt_t sym3 = pmt::mp("test"); - BOOST_CHECK_EQUAL(sym1, sym3); - BOOST_CHECK(sym1 != sym2); - BOOST_CHECK(sym1 == sym3); - - static const int N = 2048; - std::vector<pmt::pmt_t> v1(N); - std::vector<pmt::pmt_t> v2(N); - - // generate a bunch of symbols - for (int i = 0; i < N; i++){ - std::string buf = str(boost::format("test-%d") % i); - v1[i] = pmt::mp(buf.c_str()); - } - - // confirm that they are all unique - for (int i = 0; i < N; i++) - for (int j = i + 1; j < N; j++) - BOOST_CHECK(v1[i] != v1[j]); - - // generate the same symbols again - for (int i = 0; i < N; i++){ - std::string buf = str(boost::format("test-%d") % i); - v2[i] = pmt::mp(buf.c_str()); - } - - // confirm that we get the same ones back - for (int i = 0; i < N; i++) - BOOST_CHECK(v1[i] == v2[i]); +BOOST_AUTO_TEST_CASE(test_symbols) +{ + BOOST_CHECK(!pmt::is_symbol(pmt::PMT_T)); + BOOST_CHECK(!pmt::is_symbol(pmt::PMT_F)); + BOOST_CHECK_THROW(pmt::symbol_to_string(pmt::PMT_F), pmt::wrong_type); + + pmt::pmt_t sym1 = pmt::mp("test"); + BOOST_CHECK(pmt::is_symbol(sym1)); + BOOST_CHECK_EQUAL(std::string("test"), pmt::symbol_to_string(sym1)); + BOOST_CHECK(pmt::is_true(sym1)); + BOOST_CHECK(!pmt::is_false(sym1)); + + pmt::pmt_t sym2 = pmt::mp("foo"); + pmt::pmt_t sym3 = pmt::mp("test"); + BOOST_CHECK_EQUAL(sym1, sym3); + BOOST_CHECK(sym1 != sym2); + BOOST_CHECK(sym1 == sym3); + + static const int N = 2048; + std::vector<pmt::pmt_t> v1(N); + std::vector<pmt::pmt_t> v2(N); + + // generate a bunch of symbols + for (int i = 0; i < N; i++) { + std::string buf = str(boost::format("test-%d") % i); + v1[i] = pmt::mp(buf.c_str()); + } + + // confirm that they are all unique + for (int i = 0; i < N; i++) + for (int j = i + 1; j < N; j++) + BOOST_CHECK(v1[i] != v1[j]); + + // generate the same symbols again + for (int i = 0; i < N; i++) { + std::string buf = str(boost::format("test-%d") % i); + v2[i] = pmt::mp(buf.c_str()); + } + + // confirm that we get the same ones back + for (int i = 0; i < N; i++) + BOOST_CHECK(v1[i] == v2[i]); } -BOOST_AUTO_TEST_CASE(test_booleans) { - pmt::pmt_t sym = pmt::mp("test"); - BOOST_CHECK(pmt::is_bool(pmt::PMT_T)); - BOOST_CHECK(pmt::is_bool(pmt::PMT_F)); - BOOST_CHECK(!pmt::is_bool(sym)); - BOOST_CHECK_EQUAL(pmt::from_bool(false), pmt::PMT_F); - BOOST_CHECK_EQUAL(pmt::from_bool(true), pmt::PMT_T); - BOOST_CHECK_EQUAL(false, pmt::to_bool(pmt::PMT_F)); - BOOST_CHECK_EQUAL(true, pmt::to_bool(pmt::PMT_T)); - BOOST_CHECK_THROW(pmt::to_bool(sym), pmt::wrong_type); +BOOST_AUTO_TEST_CASE(test_booleans) +{ + pmt::pmt_t sym = pmt::mp("test"); + BOOST_CHECK(pmt::is_bool(pmt::PMT_T)); + BOOST_CHECK(pmt::is_bool(pmt::PMT_F)); + BOOST_CHECK(!pmt::is_bool(sym)); + BOOST_CHECK_EQUAL(pmt::from_bool(false), pmt::PMT_F); + BOOST_CHECK_EQUAL(pmt::from_bool(true), pmt::PMT_T); + BOOST_CHECK_EQUAL(false, pmt::to_bool(pmt::PMT_F)); + BOOST_CHECK_EQUAL(true, pmt::to_bool(pmt::PMT_T)); + BOOST_CHECK_THROW(pmt::to_bool(sym), pmt::wrong_type); } -BOOST_AUTO_TEST_CASE(test_integers) { - pmt::pmt_t p1 = pmt::from_long(1); - pmt::pmt_t m1 = pmt::from_long(-1); - BOOST_CHECK(!pmt::is_integer(pmt::PMT_T)); - BOOST_CHECK(pmt::is_integer(p1)); - BOOST_CHECK(pmt::is_integer(m1)); - BOOST_CHECK_THROW(pmt::to_long(pmt::PMT_T), pmt::wrong_type); - BOOST_CHECK_EQUAL(-1L, pmt::to_long(m1)); - BOOST_CHECK_EQUAL(1L, pmt::to_long(p1)); +BOOST_AUTO_TEST_CASE(test_integers) +{ + pmt::pmt_t p1 = pmt::from_long(1); + pmt::pmt_t m1 = pmt::from_long(-1); + BOOST_CHECK(!pmt::is_integer(pmt::PMT_T)); + BOOST_CHECK(pmt::is_integer(p1)); + BOOST_CHECK(pmt::is_integer(m1)); + BOOST_CHECK_THROW(pmt::to_long(pmt::PMT_T), pmt::wrong_type); + BOOST_CHECK_EQUAL(-1L, pmt::to_long(m1)); + BOOST_CHECK_EQUAL(1L, pmt::to_long(p1)); } -BOOST_AUTO_TEST_CASE(test_uint64s) { - pmt::pmt_t p1 = pmt::from_uint64((uint64_t)1); - pmt::pmt_t m1 = pmt::from_uint64((uint64_t)8589934592ULL); - BOOST_CHECK(!pmt::is_uint64(pmt::PMT_T)); - BOOST_CHECK(pmt::is_uint64(p1)); - BOOST_CHECK(pmt::is_uint64(m1)); - BOOST_CHECK_THROW(pmt::to_uint64(pmt::PMT_T), pmt::wrong_type); - BOOST_CHECK_EQUAL((uint64_t)8589934592ULL, (uint64_t)pmt::to_uint64(m1)); - BOOST_CHECK_EQUAL((uint64_t)1ULL, (uint64_t)pmt::to_uint64(p1)); +BOOST_AUTO_TEST_CASE(test_uint64s) +{ + pmt::pmt_t p1 = pmt::from_uint64((uint64_t)1); + pmt::pmt_t m1 = pmt::from_uint64((uint64_t)8589934592ULL); + BOOST_CHECK(!pmt::is_uint64(pmt::PMT_T)); + BOOST_CHECK(pmt::is_uint64(p1)); + BOOST_CHECK(pmt::is_uint64(m1)); + BOOST_CHECK_THROW(pmt::to_uint64(pmt::PMT_T), pmt::wrong_type); + BOOST_CHECK_EQUAL((uint64_t)8589934592ULL, (uint64_t)pmt::to_uint64(m1)); + BOOST_CHECK_EQUAL((uint64_t)1ULL, (uint64_t)pmt::to_uint64(p1)); } -BOOST_AUTO_TEST_CASE(test_reals) { - pmt::pmt_t p1 = pmt::from_double(1); - pmt::pmt_t m1 = pmt::from_double(-1); - BOOST_CHECK(!pmt::is_real(pmt::PMT_T)); - BOOST_CHECK(pmt::is_real(p1)); - BOOST_CHECK(pmt::is_real(m1)); - BOOST_CHECK_THROW(pmt::to_double(pmt::PMT_T), pmt::wrong_type); - BOOST_CHECK_EQUAL(-1.0, pmt::to_double(m1)); - BOOST_CHECK_EQUAL(1.0, pmt::to_double(p1)); - BOOST_CHECK_EQUAL(1.0, pmt::to_double(pmt::from_long(1))); - - pmt::pmt_t p2 = pmt::from_float(1); - pmt::pmt_t m2 = pmt::from_float(-1); - BOOST_CHECK(pmt::is_real(p2)); - BOOST_CHECK(pmt::is_real(m2)); - BOOST_CHECK_THROW(pmt::to_float(pmt::PMT_T), pmt::wrong_type); - BOOST_CHECK_EQUAL(float(-1.0), pmt::to_float(m2)); - BOOST_CHECK_EQUAL(float(1.0), pmt::to_float(p2)); - BOOST_CHECK_EQUAL(float(1.0), pmt::to_float(pmt::from_long(1))); +BOOST_AUTO_TEST_CASE(test_reals) +{ + pmt::pmt_t p1 = pmt::from_double(1); + pmt::pmt_t m1 = pmt::from_double(-1); + BOOST_CHECK(!pmt::is_real(pmt::PMT_T)); + BOOST_CHECK(pmt::is_real(p1)); + BOOST_CHECK(pmt::is_real(m1)); + BOOST_CHECK_THROW(pmt::to_double(pmt::PMT_T), pmt::wrong_type); + BOOST_CHECK_EQUAL(-1.0, pmt::to_double(m1)); + BOOST_CHECK_EQUAL(1.0, pmt::to_double(p1)); + BOOST_CHECK_EQUAL(1.0, pmt::to_double(pmt::from_long(1))); + + pmt::pmt_t p2 = pmt::from_float(1); + pmt::pmt_t m2 = pmt::from_float(-1); + BOOST_CHECK(pmt::is_real(p2)); + BOOST_CHECK(pmt::is_real(m2)); + BOOST_CHECK_THROW(pmt::to_float(pmt::PMT_T), pmt::wrong_type); + BOOST_CHECK_EQUAL(float(-1.0), pmt::to_float(m2)); + BOOST_CHECK_EQUAL(float(1.0), pmt::to_float(p2)); + BOOST_CHECK_EQUAL(float(1.0), pmt::to_float(pmt::from_long(1))); } -BOOST_AUTO_TEST_CASE(test_complexes) { - pmt::pmt_t p1 = pmt::make_rectangular(2, -3); - pmt::pmt_t m1 = pmt::make_rectangular(-3, 2); - pmt::pmt_t p2 = pmt::from_complex(2, -3); - pmt::pmt_t m2 = pmt::from_complex(-3, 2); - pmt::pmt_t p3 = pmt::from_complex(std::complex<double>(2, -3)); - pmt::pmt_t m3 = pmt::from_complex(std::complex<double>(-3, 2)); - BOOST_CHECK(!pmt::is_complex(pmt::PMT_T)); - BOOST_CHECK(pmt::is_complex(p1)); - BOOST_CHECK(pmt::is_complex(m1)); - BOOST_CHECK(pmt::is_complex(p2)); - BOOST_CHECK(pmt::is_complex(m2)); - BOOST_CHECK(pmt::is_complex(p3)); - BOOST_CHECK(pmt::is_complex(m3)); - BOOST_CHECK_THROW(pmt::to_complex(pmt::PMT_T), pmt::wrong_type); - BOOST_CHECK_EQUAL(std::complex<double>(2, -3), pmt::to_complex(p1)); - BOOST_CHECK_EQUAL(std::complex<double>(-3, 2), pmt::to_complex(m1)); - BOOST_CHECK_EQUAL(std::complex<double>(2, -3), pmt::to_complex(p2)); - BOOST_CHECK_EQUAL(std::complex<double>(-3, 2), pmt::to_complex(m2)); - BOOST_CHECK_EQUAL(std::complex<double>(2, -3), pmt::to_complex(p3)); - BOOST_CHECK_EQUAL(std::complex<double>(-3, 2), pmt::to_complex(m3)); - BOOST_CHECK_EQUAL(std::complex<double>(1.0, 0), pmt::to_complex(pmt::from_long(1))); - BOOST_CHECK_EQUAL(std::complex<double>(1.0, 0), pmt::to_complex(pmt::from_double(1.0))); +BOOST_AUTO_TEST_CASE(test_complexes) +{ + pmt::pmt_t p1 = pmt::make_rectangular(2, -3); + pmt::pmt_t m1 = pmt::make_rectangular(-3, 2); + pmt::pmt_t p2 = pmt::from_complex(2, -3); + pmt::pmt_t m2 = pmt::from_complex(-3, 2); + pmt::pmt_t p3 = pmt::from_complex(std::complex<double>(2, -3)); + pmt::pmt_t m3 = pmt::from_complex(std::complex<double>(-3, 2)); + BOOST_CHECK(!pmt::is_complex(pmt::PMT_T)); + BOOST_CHECK(pmt::is_complex(p1)); + BOOST_CHECK(pmt::is_complex(m1)); + BOOST_CHECK(pmt::is_complex(p2)); + BOOST_CHECK(pmt::is_complex(m2)); + BOOST_CHECK(pmt::is_complex(p3)); + BOOST_CHECK(pmt::is_complex(m3)); + BOOST_CHECK_THROW(pmt::to_complex(pmt::PMT_T), pmt::wrong_type); + BOOST_CHECK_EQUAL(std::complex<double>(2, -3), pmt::to_complex(p1)); + BOOST_CHECK_EQUAL(std::complex<double>(-3, 2), pmt::to_complex(m1)); + BOOST_CHECK_EQUAL(std::complex<double>(2, -3), pmt::to_complex(p2)); + BOOST_CHECK_EQUAL(std::complex<double>(-3, 2), pmt::to_complex(m2)); + BOOST_CHECK_EQUAL(std::complex<double>(2, -3), pmt::to_complex(p3)); + BOOST_CHECK_EQUAL(std::complex<double>(-3, 2), pmt::to_complex(m3)); + BOOST_CHECK_EQUAL(std::complex<double>(1.0, 0), pmt::to_complex(pmt::from_long(1))); + BOOST_CHECK_EQUAL(std::complex<double>(1.0, 0), + pmt::to_complex(pmt::from_double(1.0))); } -BOOST_AUTO_TEST_CASE(test_pairs) { - BOOST_CHECK(pmt::is_null(pmt::PMT_NIL)); - BOOST_CHECK(!pmt::is_pair(pmt::PMT_NIL)); - pmt::pmt_t s1 = pmt::mp("s1"); - pmt::pmt_t s2 = pmt::mp("s2"); - pmt::pmt_t s3 = pmt::mp("s3"); - - - BOOST_CHECK_EQUAL((size_t)0, pmt::length(pmt::PMT_NIL)); - BOOST_CHECK_THROW(pmt::length(s1), pmt::wrong_type); - BOOST_CHECK_THROW(pmt::length(pmt::from_double(42)), pmt::wrong_type); - - pmt::pmt_t c1 = pmt::cons(s1, pmt::PMT_NIL); - BOOST_CHECK(pmt::is_pair(c1)); - BOOST_CHECK(!pmt::is_pair(s1)); - BOOST_CHECK_EQUAL(s1, pmt::car(c1)); - BOOST_CHECK_EQUAL(pmt::PMT_NIL, pmt::cdr(c1)); - BOOST_CHECK_EQUAL((size_t) 1, pmt::length(c1)); - - pmt::pmt_t c3 = pmt::cons(s3, pmt::PMT_NIL); - pmt::pmt_t c2 = pmt::cons(s2, c3); - pmt::set_cdr(c1, c2); - BOOST_CHECK_EQUAL(c2, pmt::cdr(c1)); - pmt::set_car(c1, s3); - BOOST_CHECK_EQUAL(s3, pmt::car(c1)); - BOOST_CHECK_EQUAL((size_t)1, pmt::length(c3)); - BOOST_CHECK_EQUAL((size_t)2, pmt::length(c2)); - - BOOST_CHECK_THROW(pmt::cdr(pmt::PMT_NIL), pmt::wrong_type); - BOOST_CHECK_THROW(pmt::car(pmt::PMT_NIL), pmt::wrong_type); - BOOST_CHECK_THROW(pmt::set_car(s1, pmt::PMT_NIL), pmt::wrong_type); - BOOST_CHECK_THROW(pmt::set_cdr(s1, pmt::PMT_NIL), pmt::wrong_type); +BOOST_AUTO_TEST_CASE(test_pairs) +{ + BOOST_CHECK(pmt::is_null(pmt::PMT_NIL)); + BOOST_CHECK(!pmt::is_pair(pmt::PMT_NIL)); + pmt::pmt_t s1 = pmt::mp("s1"); + pmt::pmt_t s2 = pmt::mp("s2"); + pmt::pmt_t s3 = pmt::mp("s3"); + + + BOOST_CHECK_EQUAL((size_t)0, pmt::length(pmt::PMT_NIL)); + BOOST_CHECK_THROW(pmt::length(s1), pmt::wrong_type); + BOOST_CHECK_THROW(pmt::length(pmt::from_double(42)), pmt::wrong_type); + + pmt::pmt_t c1 = pmt::cons(s1, pmt::PMT_NIL); + BOOST_CHECK(pmt::is_pair(c1)); + BOOST_CHECK(!pmt::is_pair(s1)); + BOOST_CHECK_EQUAL(s1, pmt::car(c1)); + BOOST_CHECK_EQUAL(pmt::PMT_NIL, pmt::cdr(c1)); + BOOST_CHECK_EQUAL((size_t)1, pmt::length(c1)); + + pmt::pmt_t c3 = pmt::cons(s3, pmt::PMT_NIL); + pmt::pmt_t c2 = pmt::cons(s2, c3); + pmt::set_cdr(c1, c2); + BOOST_CHECK_EQUAL(c2, pmt::cdr(c1)); + pmt::set_car(c1, s3); + BOOST_CHECK_EQUAL(s3, pmt::car(c1)); + BOOST_CHECK_EQUAL((size_t)1, pmt::length(c3)); + BOOST_CHECK_EQUAL((size_t)2, pmt::length(c2)); + + BOOST_CHECK_THROW(pmt::cdr(pmt::PMT_NIL), pmt::wrong_type); + BOOST_CHECK_THROW(pmt::car(pmt::PMT_NIL), pmt::wrong_type); + BOOST_CHECK_THROW(pmt::set_car(s1, pmt::PMT_NIL), pmt::wrong_type); + BOOST_CHECK_THROW(pmt::set_cdr(s1, pmt::PMT_NIL), pmt::wrong_type); } -BOOST_AUTO_TEST_CASE(test_vectors) { - static const size_t N = 3; - pmt::pmt_t v1 = pmt::make_vector(N, pmt::PMT_NIL); - BOOST_CHECK_EQUAL(N, pmt::length(v1)); - pmt::pmt_t s0 = pmt::mp("s0"); - pmt::pmt_t s1 = pmt::mp("s1"); - pmt::pmt_t s2 = pmt::mp("s2"); - - pmt::vector_set(v1, 0, s0); - pmt::vector_set(v1, 1, s1); - pmt::vector_set(v1, 2, s2); - - BOOST_CHECK_EQUAL(s0, pmt::vector_ref(v1, 0)); - BOOST_CHECK_EQUAL(s1, pmt::vector_ref(v1, 1)); - BOOST_CHECK_EQUAL(s2, pmt::vector_ref(v1, 2)); - - BOOST_CHECK_THROW(pmt::vector_ref(v1, N), pmt::out_of_range); - BOOST_CHECK_THROW(pmt::vector_set(v1, N, pmt::PMT_NIL), pmt::out_of_range); - - pmt::vector_fill(v1, s0); - for (size_t i = 0; i < N; i++) - BOOST_CHECK_EQUAL(s0, pmt::vector_ref(v1, i)); +BOOST_AUTO_TEST_CASE(test_vectors) +{ + static const size_t N = 3; + pmt::pmt_t v1 = pmt::make_vector(N, pmt::PMT_NIL); + BOOST_CHECK_EQUAL(N, pmt::length(v1)); + pmt::pmt_t s0 = pmt::mp("s0"); + pmt::pmt_t s1 = pmt::mp("s1"); + pmt::pmt_t s2 = pmt::mp("s2"); + + pmt::vector_set(v1, 0, s0); + pmt::vector_set(v1, 1, s1); + pmt::vector_set(v1, 2, s2); + + BOOST_CHECK_EQUAL(s0, pmt::vector_ref(v1, 0)); + BOOST_CHECK_EQUAL(s1, pmt::vector_ref(v1, 1)); + BOOST_CHECK_EQUAL(s2, pmt::vector_ref(v1, 2)); + + BOOST_CHECK_THROW(pmt::vector_ref(v1, N), pmt::out_of_range); + BOOST_CHECK_THROW(pmt::vector_set(v1, N, pmt::PMT_NIL), pmt::out_of_range); + + pmt::vector_fill(v1, s0); + for (size_t i = 0; i < N; i++) + BOOST_CHECK_EQUAL(s0, pmt::vector_ref(v1, i)); } -static void -check_tuple(size_t len, const std::vector<pmt::pmt_t> &s, pmt::pmt_t t) +static void check_tuple(size_t len, const std::vector<pmt::pmt_t>& s, pmt::pmt_t t) { - BOOST_CHECK_EQUAL(true, pmt::is_tuple(t)); - BOOST_CHECK_EQUAL(len, pmt::length(t)); - - for (size_t i = 0; i < len; i++) - BOOST_CHECK_EQUAL(s[i], pmt::tuple_ref(t, i)); + BOOST_CHECK_EQUAL(true, pmt::is_tuple(t)); + BOOST_CHECK_EQUAL(len, pmt::length(t)); + for (size_t i = 0; i < len; i++) + BOOST_CHECK_EQUAL(s[i], pmt::tuple_ref(t, i)); } -BOOST_AUTO_TEST_CASE(test_tuples) { - pmt::pmt_t v = pmt::make_vector(10, pmt::PMT_NIL); - std::vector<pmt::pmt_t> s(10); - for (size_t i = 0; i < 10; i++){ - std::ostringstream os; - os << "s" << i; - s[i] = pmt::mp(os.str()); - pmt::vector_set(v, i, s[i]); - } +BOOST_AUTO_TEST_CASE(test_tuples) +{ + pmt::pmt_t v = pmt::make_vector(10, pmt::PMT_NIL); + std::vector<pmt::pmt_t> s(10); + for (size_t i = 0; i < 10; i++) { + std::ostringstream os; + os << "s" << i; + s[i] = pmt::mp(os.str()); + pmt::vector_set(v, i, s[i]); + } - pmt::pmt_t t; + pmt::pmt_t t; - t = pmt::make_tuple(); - check_tuple(0, s, t); + t = pmt::make_tuple(); + check_tuple(0, s, t); - t = pmt::make_tuple(s[0]); - check_tuple(1, s, t); + t = pmt::make_tuple(s[0]); + check_tuple(1, s, t); - BOOST_CHECK(pmt::is_vector(v)); - BOOST_CHECK(!pmt::is_tuple(v)); - BOOST_CHECK(pmt::is_tuple(t)); - BOOST_CHECK(!pmt::is_vector(t)); + BOOST_CHECK(pmt::is_vector(v)); + BOOST_CHECK(!pmt::is_tuple(v)); + BOOST_CHECK(pmt::is_tuple(t)); + BOOST_CHECK(!pmt::is_vector(t)); - t = pmt::make_tuple(s[0], s[1]); - check_tuple(2, s, t); + t = pmt::make_tuple(s[0], s[1]); + check_tuple(2, s, t); - t = pmt::make_tuple(s[0], s[1], s[2]); - check_tuple(3, s, t); + t = pmt::make_tuple(s[0], s[1], s[2]); + check_tuple(3, s, t); - t = pmt::make_tuple(s[0], s[1], s[2], s[3]); - check_tuple(4, s, t); + t = pmt::make_tuple(s[0], s[1], s[2], s[3]); + check_tuple(4, s, t); - t = pmt::make_tuple(s[0], s[1], s[2], s[3], s[4]); - check_tuple(5, s, t); + t = pmt::make_tuple(s[0], s[1], s[2], s[3], s[4]); + check_tuple(5, s, t); - t = pmt::make_tuple(s[0], s[1], s[2], s[3], s[4], s[5]); - check_tuple(6, s, t); + t = pmt::make_tuple(s[0], s[1], s[2], s[3], s[4], s[5]); + check_tuple(6, s, t); - t = pmt::make_tuple(s[0], s[1], s[2], s[3], s[4], s[5], s[6]); - check_tuple(7, s, t); + t = pmt::make_tuple(s[0], s[1], s[2], s[3], s[4], s[5], s[6]); + check_tuple(7, s, t); - t = pmt::make_tuple(s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7]); - check_tuple(8, s, t); + t = pmt::make_tuple(s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7]); + check_tuple(8, s, t); - t = pmt::make_tuple(s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7], s[8]); - check_tuple(9, s, t); + t = pmt::make_tuple(s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7], s[8]); + check_tuple(9, s, t); - t = pmt::make_tuple(s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7], s[8], s[9]); - check_tuple(10, s, t); + t = pmt::make_tuple(s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7], s[8], s[9]); + check_tuple(10, s, t); - t = pmt::make_tuple(s[0], s[1], s[2]); - BOOST_CHECK_THROW(pmt::tuple_ref(t, 3), pmt::out_of_range); - BOOST_CHECK_THROW(pmt::vector_ref(t, 0), pmt::wrong_type); - BOOST_CHECK_THROW(pmt::tuple_ref(v, 0), pmt::wrong_type); + t = pmt::make_tuple(s[0], s[1], s[2]); + BOOST_CHECK_THROW(pmt::tuple_ref(t, 3), pmt::out_of_range); + BOOST_CHECK_THROW(pmt::vector_ref(t, 0), pmt::wrong_type); + BOOST_CHECK_THROW(pmt::tuple_ref(v, 0), pmt::wrong_type); - t = pmt::make_tuple(s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7], s[8], s[9]); - pmt::pmt_t t2 = pmt::to_tuple(v); - BOOST_CHECK_EQUAL(size_t(10), pmt::length(v)); - BOOST_CHECK(pmt::equal(t, t2)); - //std::cout << v << std::endl; - //std::cout << t2 << std::endl; + t = pmt::make_tuple(s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7], s[8], s[9]); + pmt::pmt_t t2 = pmt::to_tuple(v); + BOOST_CHECK_EQUAL(size_t(10), pmt::length(v)); + BOOST_CHECK(pmt::equal(t, t2)); + // std::cout << v << std::endl; + // std::cout << t2 << std::endl; - t = pmt::make_tuple(s[0], s[1], s[2]); - pmt::pmt_t list0 = pmt::list3(s[0], s[1], s[2]); - BOOST_CHECK_EQUAL(size_t(3), pmt::length(list0)); - t2 = pmt::to_tuple(list0); - BOOST_CHECK_EQUAL(size_t(3), pmt::length(t2)); - BOOST_CHECK(pmt::equal(t, t2)); + t = pmt::make_tuple(s[0], s[1], s[2]); + pmt::pmt_t list0 = pmt::list3(s[0], s[1], s[2]); + BOOST_CHECK_EQUAL(size_t(3), pmt::length(list0)); + t2 = pmt::to_tuple(list0); + BOOST_CHECK_EQUAL(size_t(3), pmt::length(t2)); + BOOST_CHECK(pmt::equal(t, t2)); } -BOOST_AUTO_TEST_CASE(test_equivalence) { - pmt::pmt_t s0 = pmt::mp("s0"); - pmt::pmt_t s1 = pmt::mp("s1"); - pmt::pmt_t s2 = pmt::mp("s2"); - pmt::pmt_t list0 = pmt::cons(s0, pmt::cons(s1, pmt::cons(s2, pmt::PMT_NIL))); - pmt::pmt_t list1 = pmt::cons(s0, pmt::cons(s1, pmt::cons(s2, pmt::PMT_NIL))); - pmt::pmt_t i0 = pmt::from_long(42); - pmt::pmt_t i1 = pmt::from_long(42); - pmt::pmt_t r0 = pmt::from_double(42); - pmt::pmt_t r1 = pmt::from_double(42); - pmt::pmt_t r2 = pmt::from_double(43); - - BOOST_CHECK(pmt::eq(s0, s0)); - BOOST_CHECK(!pmt::eq(s0, s1)); - BOOST_CHECK(pmt::eqv(s0, s0)); - BOOST_CHECK(!pmt::eqv(s0, s1)); - - BOOST_CHECK(pmt::eqv(i0, i1)); - BOOST_CHECK(pmt::eqv(r0, r1)); - BOOST_CHECK(!pmt::eqv(r0, r2)); - BOOST_CHECK(!pmt::eqv(i0, r0)); - - BOOST_CHECK(!pmt::eq(list0, list1)); - BOOST_CHECK(!pmt::eqv(list0, list1)); - BOOST_CHECK(pmt::equal(list0, list1)); - - pmt::pmt_t v0 = pmt::make_vector(3, s0); - pmt::pmt_t v1 = pmt::make_vector(3, s0); - pmt::pmt_t v2 = pmt::make_vector(4, s0); - BOOST_CHECK(!pmt::eqv(v0, v1)); - BOOST_CHECK(pmt::equal(v0, v1)); - BOOST_CHECK(!pmt::equal(v0, v2)); - - pmt::vector_set(v0, 0, list0); - pmt::vector_set(v0, 1, list0); - pmt::vector_set(v1, 0, list1); - pmt::vector_set(v1, 1, list1); - BOOST_CHECK(pmt::equal(v0, v1)); +BOOST_AUTO_TEST_CASE(test_equivalence) +{ + pmt::pmt_t s0 = pmt::mp("s0"); + pmt::pmt_t s1 = pmt::mp("s1"); + pmt::pmt_t s2 = pmt::mp("s2"); + pmt::pmt_t list0 = pmt::cons(s0, pmt::cons(s1, pmt::cons(s2, pmt::PMT_NIL))); + pmt::pmt_t list1 = pmt::cons(s0, pmt::cons(s1, pmt::cons(s2, pmt::PMT_NIL))); + pmt::pmt_t i0 = pmt::from_long(42); + pmt::pmt_t i1 = pmt::from_long(42); + pmt::pmt_t r0 = pmt::from_double(42); + pmt::pmt_t r1 = pmt::from_double(42); + pmt::pmt_t r2 = pmt::from_double(43); + + BOOST_CHECK(pmt::eq(s0, s0)); + BOOST_CHECK(!pmt::eq(s0, s1)); + BOOST_CHECK(pmt::eqv(s0, s0)); + BOOST_CHECK(!pmt::eqv(s0, s1)); + + BOOST_CHECK(pmt::eqv(i0, i1)); + BOOST_CHECK(pmt::eqv(r0, r1)); + BOOST_CHECK(!pmt::eqv(r0, r2)); + BOOST_CHECK(!pmt::eqv(i0, r0)); + + BOOST_CHECK(!pmt::eq(list0, list1)); + BOOST_CHECK(!pmt::eqv(list0, list1)); + BOOST_CHECK(pmt::equal(list0, list1)); + + pmt::pmt_t v0 = pmt::make_vector(3, s0); + pmt::pmt_t v1 = pmt::make_vector(3, s0); + pmt::pmt_t v2 = pmt::make_vector(4, s0); + BOOST_CHECK(!pmt::eqv(v0, v1)); + BOOST_CHECK(pmt::equal(v0, v1)); + BOOST_CHECK(!pmt::equal(v0, v2)); + + pmt::vector_set(v0, 0, list0); + pmt::vector_set(v0, 1, list0); + pmt::vector_set(v1, 0, list1); + pmt::vector_set(v1, 1, list1); + BOOST_CHECK(pmt::equal(v0, v1)); } -BOOST_AUTO_TEST_CASE(test_misc) { - pmt::pmt_t k0 = pmt::mp("k0"); - pmt::pmt_t k1 = pmt::mp("k1"); - pmt::pmt_t k2 = pmt::mp("k2"); - pmt::pmt_t k3 = pmt::mp("k3"); - pmt::pmt_t v0 = pmt::mp("v0"); - pmt::pmt_t v1 = pmt::mp("v1"); - pmt::pmt_t v2 = pmt::mp("v2"); - pmt::pmt_t p0 = pmt::cons(k0, v0); - pmt::pmt_t p1 = pmt::cons(k1, v1); - pmt::pmt_t p2 = pmt::cons(k2, v2); - - pmt::pmt_t alist = pmt::cons(p0, pmt::cons(p1, pmt::cons(p2, pmt::PMT_NIL))); - BOOST_CHECK(pmt::eq(p1, pmt::assv(k1, alist))); - BOOST_CHECK(pmt::eq(pmt::PMT_F, pmt::assv(k3, alist))); - - pmt::pmt_t keys = pmt::cons(k0, pmt::cons(k1, pmt::cons(k2, pmt::PMT_NIL))); - pmt::pmt_t vals = pmt::cons(v0, pmt::cons(v1, pmt::cons(v2, pmt::PMT_NIL))); - BOOST_CHECK(pmt::equal(keys, pmt::map(pmt::car, alist))); - BOOST_CHECK(pmt::equal(vals, pmt::map(pmt::cdr, alist))); +BOOST_AUTO_TEST_CASE(test_misc) +{ + pmt::pmt_t k0 = pmt::mp("k0"); + pmt::pmt_t k1 = pmt::mp("k1"); + pmt::pmt_t k2 = pmt::mp("k2"); + pmt::pmt_t k3 = pmt::mp("k3"); + pmt::pmt_t v0 = pmt::mp("v0"); + pmt::pmt_t v1 = pmt::mp("v1"); + pmt::pmt_t v2 = pmt::mp("v2"); + pmt::pmt_t p0 = pmt::cons(k0, v0); + pmt::pmt_t p1 = pmt::cons(k1, v1); + pmt::pmt_t p2 = pmt::cons(k2, v2); + + pmt::pmt_t alist = pmt::cons(p0, pmt::cons(p1, pmt::cons(p2, pmt::PMT_NIL))); + BOOST_CHECK(pmt::eq(p1, pmt::assv(k1, alist))); + BOOST_CHECK(pmt::eq(pmt::PMT_F, pmt::assv(k3, alist))); + + pmt::pmt_t keys = pmt::cons(k0, pmt::cons(k1, pmt::cons(k2, pmt::PMT_NIL))); + pmt::pmt_t vals = pmt::cons(v0, pmt::cons(v1, pmt::cons(v2, pmt::PMT_NIL))); + BOOST_CHECK(pmt::equal(keys, pmt::map(pmt::car, alist))); + BOOST_CHECK(pmt::equal(vals, pmt::map(pmt::cdr, alist))); } -BOOST_AUTO_TEST_CASE(test_dict) { - pmt::pmt_t dict = pmt::make_dict(); - BOOST_CHECK(pmt::is_dict(dict)); - - pmt::pmt_t k0 = pmt::mp("k0"); - pmt::pmt_t k1 = pmt::mp("k1"); - pmt::pmt_t k2 = pmt::mp("k2"); - pmt::pmt_t k3 = pmt::mp("k3"); - pmt::pmt_t v0 = pmt::mp("v0"); - pmt::pmt_t v1 = pmt::mp("v1"); - pmt::pmt_t v2 = pmt::mp("v2"); - pmt::pmt_t v3 = pmt::mp("v3"); - pmt::pmt_t not_found = pmt::cons(pmt::PMT_NIL, pmt::PMT_NIL); - - BOOST_CHECK(!pmt::dict_has_key(dict, k0)); - dict = pmt::dict_add(dict, k0, v0); - BOOST_CHECK(pmt::dict_has_key(dict, k0)); - BOOST_CHECK(pmt::eqv(pmt::dict_ref(dict, k0, not_found), v0)); - BOOST_CHECK(pmt::eqv(pmt::dict_ref(dict, k1, not_found), not_found)); - dict = pmt::dict_add(dict, k1, v1); - dict = pmt::dict_add(dict, k2, v2); - BOOST_CHECK(pmt::eqv(pmt::dict_ref(dict, k1, not_found), v1)); - dict = pmt::dict_add(dict, k1, v3); - BOOST_CHECK(pmt::eqv(pmt::dict_ref(dict, k1, not_found), v3)); - - pmt::pmt_t keys = pmt::list3(k1, k2, k0); - pmt::pmt_t vals = pmt::list3(v3, v2, v0); - //std::cout << "pmt::dict_keys: " << pmt::dict_keys(dict) << std::endl; - //std::cout << "pmt::dict_values: " << pmt::dict_values(dict) << std::endl; - BOOST_CHECK(pmt::equal(keys, pmt::dict_keys(dict))); - BOOST_CHECK(pmt::equal(vals, pmt::dict_values(dict))); +BOOST_AUTO_TEST_CASE(test_dict) +{ + pmt::pmt_t dict = pmt::make_dict(); + BOOST_CHECK(pmt::is_dict(dict)); + + pmt::pmt_t k0 = pmt::mp("k0"); + pmt::pmt_t k1 = pmt::mp("k1"); + pmt::pmt_t k2 = pmt::mp("k2"); + pmt::pmt_t k3 = pmt::mp("k3"); + pmt::pmt_t v0 = pmt::mp("v0"); + pmt::pmt_t v1 = pmt::mp("v1"); + pmt::pmt_t v2 = pmt::mp("v2"); + pmt::pmt_t v3 = pmt::mp("v3"); + pmt::pmt_t not_found = pmt::cons(pmt::PMT_NIL, pmt::PMT_NIL); + + BOOST_CHECK(!pmt::dict_has_key(dict, k0)); + dict = pmt::dict_add(dict, k0, v0); + BOOST_CHECK(pmt::dict_has_key(dict, k0)); + BOOST_CHECK(pmt::eqv(pmt::dict_ref(dict, k0, not_found), v0)); + BOOST_CHECK(pmt::eqv(pmt::dict_ref(dict, k1, not_found), not_found)); + dict = pmt::dict_add(dict, k1, v1); + dict = pmt::dict_add(dict, k2, v2); + BOOST_CHECK(pmt::eqv(pmt::dict_ref(dict, k1, not_found), v1)); + dict = pmt::dict_add(dict, k1, v3); + BOOST_CHECK(pmt::eqv(pmt::dict_ref(dict, k1, not_found), v3)); + + pmt::pmt_t keys = pmt::list3(k1, k2, k0); + pmt::pmt_t vals = pmt::list3(v3, v2, v0); + // std::cout << "pmt::dict_keys: " << pmt::dict_keys(dict) << std::endl; + // std::cout << "pmt::dict_values: " << pmt::dict_values(dict) << std::endl; + BOOST_CHECK(pmt::equal(keys, pmt::dict_keys(dict))); + BOOST_CHECK(pmt::equal(vals, pmt::dict_values(dict))); } -BOOST_AUTO_TEST_CASE(test_io) { - pmt::pmt_t k0 = pmt::mp("k0"); - pmt::pmt_t k1 = pmt::mp("k1"); - pmt::pmt_t k2 = pmt::mp("k2"); - pmt::pmt_t k3 = pmt::mp("k3"); +BOOST_AUTO_TEST_CASE(test_io) +{ + pmt::pmt_t k0 = pmt::mp("k0"); + pmt::pmt_t k1 = pmt::mp("k1"); + pmt::pmt_t k2 = pmt::mp("k2"); + pmt::pmt_t k3 = pmt::mp("k3"); - BOOST_CHECK_EQUAL(std::string("k0"), pmt::write_string(k0)); + BOOST_CHECK_EQUAL(std::string("k0"), pmt::write_string(k0)); } -BOOST_AUTO_TEST_CASE(test_lists) { - pmt::pmt_t s0 = pmt::mp("s0"); - pmt::pmt_t s1 = pmt::mp("s1"); - pmt::pmt_t s2 = pmt::mp("s2"); - pmt::pmt_t s3 = pmt::mp("s3"); - - pmt::pmt_t l1 = pmt::list4(s0, s1, s2, s3); - pmt::pmt_t l2 = pmt::list3(s0, s1, s2); - pmt::pmt_t l3 = pmt::list_add(l2, s3); - BOOST_CHECK(pmt::equal(l1, l3)); +BOOST_AUTO_TEST_CASE(test_lists) +{ + pmt::pmt_t s0 = pmt::mp("s0"); + pmt::pmt_t s1 = pmt::mp("s1"); + pmt::pmt_t s2 = pmt::mp("s2"); + pmt::pmt_t s3 = pmt::mp("s3"); + + pmt::pmt_t l1 = pmt::list4(s0, s1, s2, s3); + pmt::pmt_t l2 = pmt::list3(s0, s1, s2); + pmt::pmt_t l3 = pmt::list_add(l2, s3); + BOOST_CHECK(pmt::equal(l1, l3)); } // ------------------------------------------------------------------------ @@ -414,45 +427,45 @@ BOOST_AUTO_TEST_CASE(test_lists) { // It can't be declared in the scope of test_any because of template // namespace problems. -class foo { +class foo +{ public: - double d_double; - int d_int; - foo(double d=0, int i=0) : d_double(d), d_int(i) {} + double d_double; + int d_int; + foo(double d = 0, int i = 0) : d_double(d), d_int(i) {} }; -bool operator==(const foo &a, const foo &b) +bool operator==(const foo& a, const foo& b) { - return a.d_double == b.d_double && a.d_int == b.d_int; + return a.d_double == b.d_double && a.d_int == b.d_int; } -std::ostream& operator<<(std::ostream &os, const foo obj) +std::ostream& operator<<(std::ostream& os, const foo obj) { - os << "<foo: " << obj.d_double << ", " << obj.d_int << ">"; - return os; + os << "<foo: " << obj.d_double << ", " << obj.d_int << ">"; + return os; } -BOOST_AUTO_TEST_CASE(test_any) { - boost::any a0; - boost::any a1; - boost::any a2; +BOOST_AUTO_TEST_CASE(test_any) +{ + boost::any a0; + boost::any a1; + boost::any a2; - a0 = std::string("Hello!"); - a1 = 42; - a2 = foo(3.250, 21); + a0 = std::string("Hello!"); + a1 = 42; + a2 = foo(3.250, 21); - pmt::pmt_t p0 = pmt::make_any(a0); - pmt::pmt_t p1 = pmt::make_any(a1); - pmt::pmt_t p2 = pmt::make_any(a2); + pmt::pmt_t p0 = pmt::make_any(a0); + pmt::pmt_t p1 = pmt::make_any(a1); + pmt::pmt_t p2 = pmt::make_any(a2); - BOOST_CHECK_EQUAL(std::string("Hello!"), - boost::any_cast<std::string>(pmt::any_ref(p0))); + BOOST_CHECK_EQUAL(std::string("Hello!"), + boost::any_cast<std::string>(pmt::any_ref(p0))); - BOOST_CHECK_EQUAL(42, - boost::any_cast<int>(pmt::any_ref(p1))); + BOOST_CHECK_EQUAL(42, boost::any_cast<int>(pmt::any_ref(p1))); - BOOST_CHECK_EQUAL(foo(3.250, 21), - boost::any_cast<foo>(pmt::any_ref(p2))); + BOOST_CHECK_EQUAL(foo(3.250, 21), boost::any_cast<foo>(pmt::any_ref(p2))); } // ------------------------------------------------------------------------ @@ -460,116 +473,117 @@ BOOST_AUTO_TEST_CASE(test_any) { class qa_pmt_msg_accepter_nop : public gr::messages::msg_accepter { public: - qa_pmt_msg_accepter_nop(){} - ~qa_pmt_msg_accepter_nop(); - void post(pmt::pmt_t,pmt::pmt_t){} + qa_pmt_msg_accepter_nop() {} + ~qa_pmt_msg_accepter_nop(); + void post(pmt::pmt_t, pmt::pmt_t) {} }; -qa_pmt_msg_accepter_nop::~qa_pmt_msg_accepter_nop(){} +qa_pmt_msg_accepter_nop::~qa_pmt_msg_accepter_nop() {} -BOOST_AUTO_TEST_CASE(test_msg_accepter) { - pmt::pmt_t sym = pmt::mp("my-symbol"); - - boost::any a0; - a0 = std::string("Hello!"); - pmt::pmt_t p0 = pmt::make_any(a0); +BOOST_AUTO_TEST_CASE(test_msg_accepter) +{ + pmt::pmt_t sym = pmt::mp("my-symbol"); - gr::messages::msg_accepter_sptr ma0 = \ - gr::messages::msg_accepter_sptr(new qa_pmt_msg_accepter_nop()); - pmt::pmt_t p1 = pmt::make_msg_accepter(ma0); + boost::any a0; + a0 = std::string("Hello!"); + pmt::pmt_t p0 = pmt::make_any(a0); - BOOST_CHECK_EQUAL(ma0.get(), pmt::msg_accepter_ref(p1).get()); + gr::messages::msg_accepter_sptr ma0 = + gr::messages::msg_accepter_sptr(new qa_pmt_msg_accepter_nop()); + pmt::pmt_t p1 = pmt::make_msg_accepter(ma0); - BOOST_CHECK_THROW(pmt::msg_accepter_ref(sym), pmt::wrong_type); - BOOST_CHECK_THROW(pmt::msg_accepter_ref(p0), pmt::wrong_type); + BOOST_CHECK_EQUAL(ma0.get(), pmt::msg_accepter_ref(p1).get()); - // just confirm interfaces on send are OK - pmt::pmt_t port(pmt::intern("port")); - gr::messages::send(ma0.get(), port, sym); - gr::messages::send(ma0, port, sym); - gr::messages::send(p1, port, sym); + BOOST_CHECK_THROW(pmt::msg_accepter_ref(sym), pmt::wrong_type); + BOOST_CHECK_THROW(pmt::msg_accepter_ref(p0), pmt::wrong_type); + // just confirm interfaces on send are OK + pmt::pmt_t port(pmt::intern("port")); + gr::messages::send(ma0.get(), port, sym); + gr::messages::send(ma0, port, sym); + gr::messages::send(p1, port, sym); } // ------------------------------------------------------------------------ -BOOST_AUTO_TEST_CASE(test_serialize) { - std::stringbuf sb; // fake channel - pmt::pmt_t a = pmt::mp("a"); - pmt::pmt_t b = pmt::mp("b"); - pmt::pmt_t c = pmt::mp("c"); - - sb.str(""); // reset channel to empty - - // write stuff to channel - - pmt::serialize(pmt::PMT_NIL, sb); - pmt::serialize(pmt::mp("foobarvia"), sb); - pmt::serialize(pmt::from_long(123456789), sb); - pmt::serialize(pmt::from_long(-123456789), sb); - pmt::serialize(pmt::cons(pmt::PMT_NIL, pmt::PMT_NIL), sb); - pmt::serialize(pmt::cons(a, b), sb); - pmt::serialize(pmt::list1(a), sb); - pmt::serialize(pmt::list2(a, b), sb); - pmt::serialize(pmt::list3(a, b, c), sb); - pmt::serialize(pmt::list3(a, pmt::list3(c, b, a), c), sb); - pmt::serialize(pmt::PMT_T, sb); - pmt::serialize(pmt::PMT_F, sb); - - // read it back - - BOOST_CHECK(pmt::equal(pmt::deserialize(sb), pmt::PMT_NIL)); - BOOST_CHECK(pmt::equal(pmt::deserialize(sb), pmt::mp("foobarvia"))); - BOOST_CHECK(pmt::equal(pmt::deserialize(sb), pmt::from_long(123456789))); - BOOST_CHECK(pmt::equal(pmt::deserialize(sb), pmt::from_long(-123456789))); - BOOST_CHECK(pmt::equal(pmt::deserialize(sb), pmt::cons(pmt::PMT_NIL, pmt::PMT_NIL))); - BOOST_CHECK(pmt::equal(pmt::deserialize(sb), pmt::cons(a, b))); - BOOST_CHECK(pmt::equal(pmt::deserialize(sb), pmt::list1(a))); - BOOST_CHECK(pmt::equal(pmt::deserialize(sb), pmt::list2(a, b))); - BOOST_CHECK(pmt::equal(pmt::deserialize(sb), pmt::list3(a, b, c))); - BOOST_CHECK(pmt::equal(pmt::deserialize(sb), pmt::list3(a, pmt::list3(c, b, a), c))); - BOOST_CHECK(pmt::equal(pmt::deserialize(sb), pmt::PMT_T)); - BOOST_CHECK(pmt::equal(pmt::deserialize(sb), pmt::PMT_F)); - - BOOST_CHECK(pmt::equal(pmt::deserialize(sb), pmt::PMT_EOF)); // last item - - - // FIXME add tests for real, complex, vector, uniform-vector, dict - // FIXME add tests for malformed input too. - +BOOST_AUTO_TEST_CASE(test_serialize) +{ + std::stringbuf sb; // fake channel + pmt::pmt_t a = pmt::mp("a"); + pmt::pmt_t b = pmt::mp("b"); + pmt::pmt_t c = pmt::mp("c"); + + sb.str(""); // reset channel to empty + + // write stuff to channel + + pmt::serialize(pmt::PMT_NIL, sb); + pmt::serialize(pmt::mp("foobarvia"), sb); + pmt::serialize(pmt::from_long(123456789), sb); + pmt::serialize(pmt::from_long(-123456789), sb); + pmt::serialize(pmt::cons(pmt::PMT_NIL, pmt::PMT_NIL), sb); + pmt::serialize(pmt::cons(a, b), sb); + pmt::serialize(pmt::list1(a), sb); + pmt::serialize(pmt::list2(a, b), sb); + pmt::serialize(pmt::list3(a, b, c), sb); + pmt::serialize(pmt::list3(a, pmt::list3(c, b, a), c), sb); + pmt::serialize(pmt::PMT_T, sb); + pmt::serialize(pmt::PMT_F, sb); + + // read it back + + BOOST_CHECK(pmt::equal(pmt::deserialize(sb), pmt::PMT_NIL)); + BOOST_CHECK(pmt::equal(pmt::deserialize(sb), pmt::mp("foobarvia"))); + BOOST_CHECK(pmt::equal(pmt::deserialize(sb), pmt::from_long(123456789))); + BOOST_CHECK(pmt::equal(pmt::deserialize(sb), pmt::from_long(-123456789))); + BOOST_CHECK(pmt::equal(pmt::deserialize(sb), pmt::cons(pmt::PMT_NIL, pmt::PMT_NIL))); + BOOST_CHECK(pmt::equal(pmt::deserialize(sb), pmt::cons(a, b))); + BOOST_CHECK(pmt::equal(pmt::deserialize(sb), pmt::list1(a))); + BOOST_CHECK(pmt::equal(pmt::deserialize(sb), pmt::list2(a, b))); + BOOST_CHECK(pmt::equal(pmt::deserialize(sb), pmt::list3(a, b, c))); + BOOST_CHECK(pmt::equal(pmt::deserialize(sb), pmt::list3(a, pmt::list3(c, b, a), c))); + BOOST_CHECK(pmt::equal(pmt::deserialize(sb), pmt::PMT_T)); + BOOST_CHECK(pmt::equal(pmt::deserialize(sb), pmt::PMT_F)); + + BOOST_CHECK(pmt::equal(pmt::deserialize(sb), pmt::PMT_EOF)); // last item + + + // FIXME add tests for real, complex, vector, uniform-vector, dict + // FIXME add tests for malformed input too. } -BOOST_AUTO_TEST_CASE(test_sets) { - pmt::pmt_t s1 = pmt::mp("s1"); - pmt::pmt_t s2 = pmt::mp("s2"); - pmt::pmt_t s3 = pmt::mp("s3"); - - pmt::pmt_t l1 = pmt::list1(s1); - pmt::pmt_t l2 = pmt::list2(s2,s3); - pmt::pmt_t l3 = pmt::list3(s1,s2,s3); - - BOOST_CHECK(pmt::is_pair(pmt::memq(s1,l1))); - BOOST_CHECK(pmt::is_false(pmt::memq(s3,l1))); - - BOOST_CHECK(pmt::subsetp(l1,l3)); - BOOST_CHECK(pmt::subsetp(l2,l3)); - BOOST_CHECK(!pmt::subsetp(l1,l2)); - BOOST_CHECK(!pmt::subsetp(l2,l1)); - BOOST_CHECK(!pmt::subsetp(l3,l2)); +BOOST_AUTO_TEST_CASE(test_sets) +{ + pmt::pmt_t s1 = pmt::mp("s1"); + pmt::pmt_t s2 = pmt::mp("s2"); + pmt::pmt_t s3 = pmt::mp("s3"); + + pmt::pmt_t l1 = pmt::list1(s1); + pmt::pmt_t l2 = pmt::list2(s2, s3); + pmt::pmt_t l3 = pmt::list3(s1, s2, s3); + + BOOST_CHECK(pmt::is_pair(pmt::memq(s1, l1))); + BOOST_CHECK(pmt::is_false(pmt::memq(s3, l1))); + + BOOST_CHECK(pmt::subsetp(l1, l3)); + BOOST_CHECK(pmt::subsetp(l2, l3)); + BOOST_CHECK(!pmt::subsetp(l1, l2)); + BOOST_CHECK(!pmt::subsetp(l2, l1)); + BOOST_CHECK(!pmt::subsetp(l3, l2)); } -BOOST_AUTO_TEST_CASE(test_sugar) { - BOOST_CHECK(pmt::is_symbol(pmt::mp("my-symbol"))); - BOOST_CHECK_EQUAL((long) 10, pmt::to_long(pmt::mp(10))); - BOOST_CHECK_EQUAL((double) 1e6, pmt::to_double(pmt::mp(1e6))); - BOOST_CHECK_EQUAL(std::complex<double>(2, 3), - pmt::to_complex(pmt::mp(std::complex<double>(2, 3)))); - - int buf[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; - pmt::pmt_t blob = pmt::mp(buf, sizeof(buf)); - const void *data = pmt::blob_data(blob); - size_t nbytes = pmt::blob_length(blob); - BOOST_CHECK_EQUAL(sizeof(buf), nbytes); - BOOST_CHECK(memcmp(buf, data, nbytes) == 0); +BOOST_AUTO_TEST_CASE(test_sugar) +{ + BOOST_CHECK(pmt::is_symbol(pmt::mp("my-symbol"))); + BOOST_CHECK_EQUAL((long)10, pmt::to_long(pmt::mp(10))); + BOOST_CHECK_EQUAL((double)1e6, pmt::to_double(pmt::mp(1e6))); + BOOST_CHECK_EQUAL(std::complex<double>(2, 3), + pmt::to_complex(pmt::mp(std::complex<double>(2, 3)))); + + int buf[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + pmt::pmt_t blob = pmt::mp(buf, sizeof(buf)); + const void* data = pmt::blob_data(blob); + size_t nbytes = pmt::blob_length(blob); + BOOST_CHECK_EQUAL(sizeof(buf), nbytes); + BOOST_CHECK(memcmp(buf, data, nbytes) == 0); } - diff --git a/gnuradio-runtime/lib/pmt/qa_pmt_unv.cc b/gnuradio-runtime/lib/pmt/qa_pmt_unv.cc index 9cc2a35e17..9dd9452e5e 100644 --- a/gnuradio-runtime/lib/pmt/qa_pmt_unv.cc +++ b/gnuradio-runtime/lib/pmt/qa_pmt_unv.cc @@ -31,399 +31,413 @@ using namespace pmt; -BOOST_AUTO_TEST_CASE(test_u8vector) { - static const size_t N = 3; - pmt::pmt_t v1 = pmt::make_u8vector(N, 0); - BOOST_CHECK_EQUAL(N, pmt::length(v1)); - uint8_t s0 = uint8_t(10); - uint8_t s1 = uint8_t(20); - uint8_t s2 = uint8_t(30); - - pmt::u8vector_set(v1, 0, s0); - pmt::u8vector_set(v1, 1, s1); - pmt::u8vector_set(v1, 2, s2); - - BOOST_CHECK_EQUAL(s0, pmt::u8vector_ref(v1, 0)); - BOOST_CHECK_EQUAL(s1, pmt::u8vector_ref(v1, 1)); - BOOST_CHECK_EQUAL(s2, pmt::u8vector_ref(v1, 2)); - - BOOST_CHECK_THROW(pmt::u8vector_ref(v1, N), pmt::out_of_range); - BOOST_CHECK_THROW(pmt::u8vector_set(v1, N, uint8_t(0)), pmt::out_of_range); - - size_t len; - const uint8_t *rd = pmt::u8vector_elements(v1, len); - BOOST_CHECK_EQUAL(len, N); - BOOST_CHECK_EQUAL(s0, rd[0]); - BOOST_CHECK_EQUAL(s1, rd[1]); - BOOST_CHECK_EQUAL(s2, rd[2]); - - uint8_t *wr = pmt::u8vector_writable_elements(v1, len); - BOOST_CHECK_EQUAL(len, N); - wr[0] = uint8_t(0); - BOOST_CHECK_EQUAL(uint8_t(0), wr[0]); - BOOST_CHECK_EQUAL(s1, wr[1]); - BOOST_CHECK_EQUAL(s2, wr[2]); +BOOST_AUTO_TEST_CASE(test_u8vector) +{ + static const size_t N = 3; + pmt::pmt_t v1 = pmt::make_u8vector(N, 0); + BOOST_CHECK_EQUAL(N, pmt::length(v1)); + uint8_t s0 = uint8_t(10); + uint8_t s1 = uint8_t(20); + uint8_t s2 = uint8_t(30); + + pmt::u8vector_set(v1, 0, s0); + pmt::u8vector_set(v1, 1, s1); + pmt::u8vector_set(v1, 2, s2); + + BOOST_CHECK_EQUAL(s0, pmt::u8vector_ref(v1, 0)); + BOOST_CHECK_EQUAL(s1, pmt::u8vector_ref(v1, 1)); + BOOST_CHECK_EQUAL(s2, pmt::u8vector_ref(v1, 2)); + + BOOST_CHECK_THROW(pmt::u8vector_ref(v1, N), pmt::out_of_range); + BOOST_CHECK_THROW(pmt::u8vector_set(v1, N, uint8_t(0)), pmt::out_of_range); + + size_t len; + const uint8_t* rd = pmt::u8vector_elements(v1, len); + BOOST_CHECK_EQUAL(len, N); + BOOST_CHECK_EQUAL(s0, rd[0]); + BOOST_CHECK_EQUAL(s1, rd[1]); + BOOST_CHECK_EQUAL(s2, rd[2]); + + uint8_t* wr = pmt::u8vector_writable_elements(v1, len); + BOOST_CHECK_EQUAL(len, N); + wr[0] = uint8_t(0); + BOOST_CHECK_EQUAL(uint8_t(0), wr[0]); + BOOST_CHECK_EQUAL(s1, wr[1]); + BOOST_CHECK_EQUAL(s2, wr[2]); } -BOOST_AUTO_TEST_CASE(test_s8vector) { - static const size_t N = 3; - pmt::pmt_t v1 = pmt::make_s8vector(N, 0); - BOOST_CHECK_EQUAL(N, pmt::length(v1)); - int8_t s0 = int8_t(10); - int8_t s1 = int8_t(20); - int8_t s2 = int8_t(30); - - pmt::s8vector_set(v1, 0, s0); - pmt::s8vector_set(v1, 1, s1); - pmt::s8vector_set(v1, 2, s2); - - BOOST_CHECK_EQUAL(s0, pmt::s8vector_ref(v1, 0)); - BOOST_CHECK_EQUAL(s1, pmt::s8vector_ref(v1, 1)); - BOOST_CHECK_EQUAL(s2, pmt::s8vector_ref(v1, 2)); - - BOOST_CHECK_THROW(pmt::s8vector_ref(v1, N), pmt::out_of_range); - BOOST_CHECK_THROW(pmt::s8vector_set(v1, N, int8_t(0)), pmt::out_of_range); - - size_t len; - const int8_t *rd = pmt::s8vector_elements(v1, len); - BOOST_CHECK_EQUAL(len, N); - BOOST_CHECK_EQUAL(s0, rd[0]); - BOOST_CHECK_EQUAL(s1, rd[1]); - BOOST_CHECK_EQUAL(s2, rd[2]); - - int8_t *wr = pmt::s8vector_writable_elements(v1, len); - BOOST_CHECK_EQUAL(len, N); - wr[0] = int8_t(0); - BOOST_CHECK_EQUAL(int8_t(0), wr[0]); - BOOST_CHECK_EQUAL(s1, wr[1]); - BOOST_CHECK_EQUAL(s2, wr[2]); +BOOST_AUTO_TEST_CASE(test_s8vector) +{ + static const size_t N = 3; + pmt::pmt_t v1 = pmt::make_s8vector(N, 0); + BOOST_CHECK_EQUAL(N, pmt::length(v1)); + int8_t s0 = int8_t(10); + int8_t s1 = int8_t(20); + int8_t s2 = int8_t(30); + + pmt::s8vector_set(v1, 0, s0); + pmt::s8vector_set(v1, 1, s1); + pmt::s8vector_set(v1, 2, s2); + + BOOST_CHECK_EQUAL(s0, pmt::s8vector_ref(v1, 0)); + BOOST_CHECK_EQUAL(s1, pmt::s8vector_ref(v1, 1)); + BOOST_CHECK_EQUAL(s2, pmt::s8vector_ref(v1, 2)); + + BOOST_CHECK_THROW(pmt::s8vector_ref(v1, N), pmt::out_of_range); + BOOST_CHECK_THROW(pmt::s8vector_set(v1, N, int8_t(0)), pmt::out_of_range); + + size_t len; + const int8_t* rd = pmt::s8vector_elements(v1, len); + BOOST_CHECK_EQUAL(len, N); + BOOST_CHECK_EQUAL(s0, rd[0]); + BOOST_CHECK_EQUAL(s1, rd[1]); + BOOST_CHECK_EQUAL(s2, rd[2]); + + int8_t* wr = pmt::s8vector_writable_elements(v1, len); + BOOST_CHECK_EQUAL(len, N); + wr[0] = int8_t(0); + BOOST_CHECK_EQUAL(int8_t(0), wr[0]); + BOOST_CHECK_EQUAL(s1, wr[1]); + BOOST_CHECK_EQUAL(s2, wr[2]); } -BOOST_AUTO_TEST_CASE(test_u16vector) { - static const size_t N = 3; - pmt::pmt_t v1 = pmt::make_u16vector(N, 0); - BOOST_CHECK_EQUAL(N, pmt::length(v1)); - uint16_t s0 = uint16_t(10); - uint16_t s1 = uint16_t(20); - uint16_t s2 = uint16_t(30); - - pmt::u16vector_set(v1, 0, s0); - pmt::u16vector_set(v1, 1, s1); - pmt::u16vector_set(v1, 2, s2); - - BOOST_CHECK_EQUAL(s0, pmt::u16vector_ref(v1, 0)); - BOOST_CHECK_EQUAL(s1, pmt::u16vector_ref(v1, 1)); - BOOST_CHECK_EQUAL(s2, pmt::u16vector_ref(v1, 2)); - - BOOST_CHECK_THROW(pmt::u16vector_ref(v1, N), pmt::out_of_range); - BOOST_CHECK_THROW(pmt::u16vector_set(v1, N, uint16_t(0)), pmt::out_of_range); - - size_t len; - const uint16_t *rd = pmt::u16vector_elements(v1, len); - BOOST_CHECK_EQUAL(len, N); - BOOST_CHECK_EQUAL(s0, rd[0]); - BOOST_CHECK_EQUAL(s1, rd[1]); - BOOST_CHECK_EQUAL(s2, rd[2]); - - uint16_t *wr = pmt::u16vector_writable_elements(v1, len); - BOOST_CHECK_EQUAL(len, N); - wr[0] = uint16_t(0); - BOOST_CHECK_EQUAL(uint16_t(0), wr[0]); - BOOST_CHECK_EQUAL(s1, wr[1]); - BOOST_CHECK_EQUAL(s2, wr[2]); +BOOST_AUTO_TEST_CASE(test_u16vector) +{ + static const size_t N = 3; + pmt::pmt_t v1 = pmt::make_u16vector(N, 0); + BOOST_CHECK_EQUAL(N, pmt::length(v1)); + uint16_t s0 = uint16_t(10); + uint16_t s1 = uint16_t(20); + uint16_t s2 = uint16_t(30); + + pmt::u16vector_set(v1, 0, s0); + pmt::u16vector_set(v1, 1, s1); + pmt::u16vector_set(v1, 2, s2); + + BOOST_CHECK_EQUAL(s0, pmt::u16vector_ref(v1, 0)); + BOOST_CHECK_EQUAL(s1, pmt::u16vector_ref(v1, 1)); + BOOST_CHECK_EQUAL(s2, pmt::u16vector_ref(v1, 2)); + + BOOST_CHECK_THROW(pmt::u16vector_ref(v1, N), pmt::out_of_range); + BOOST_CHECK_THROW(pmt::u16vector_set(v1, N, uint16_t(0)), pmt::out_of_range); + + size_t len; + const uint16_t* rd = pmt::u16vector_elements(v1, len); + BOOST_CHECK_EQUAL(len, N); + BOOST_CHECK_EQUAL(s0, rd[0]); + BOOST_CHECK_EQUAL(s1, rd[1]); + BOOST_CHECK_EQUAL(s2, rd[2]); + + uint16_t* wr = pmt::u16vector_writable_elements(v1, len); + BOOST_CHECK_EQUAL(len, N); + wr[0] = uint16_t(0); + BOOST_CHECK_EQUAL(uint16_t(0), wr[0]); + BOOST_CHECK_EQUAL(s1, wr[1]); + BOOST_CHECK_EQUAL(s2, wr[2]); } -BOOST_AUTO_TEST_CASE(test_s16vector) { - static const size_t N = 3; - pmt::pmt_t v1 = pmt::make_s16vector(N, 0); - BOOST_CHECK_EQUAL(N, pmt::length(v1)); - int16_t s0 = int16_t(10); - int16_t s1 = int16_t(20); - int16_t s2 = int16_t(30); - - pmt::s16vector_set(v1, 0, s0); - pmt::s16vector_set(v1, 1, s1); - pmt::s16vector_set(v1, 2, s2); - - BOOST_CHECK_EQUAL(s0, pmt::s16vector_ref(v1, 0)); - BOOST_CHECK_EQUAL(s1, pmt::s16vector_ref(v1, 1)); - BOOST_CHECK_EQUAL(s2, pmt::s16vector_ref(v1, 2)); - - BOOST_CHECK_THROW(pmt::s16vector_ref(v1, N), pmt::out_of_range); - BOOST_CHECK_THROW(pmt::s16vector_set(v1, N, int16_t(0)), pmt::out_of_range); - - size_t len; - const int16_t *rd = pmt::s16vector_elements(v1, len); - BOOST_CHECK_EQUAL(len, N); - BOOST_CHECK_EQUAL(s0, rd[0]); - BOOST_CHECK_EQUAL(s1, rd[1]); - BOOST_CHECK_EQUAL(s2, rd[2]); - - int16_t *wr = pmt::s16vector_writable_elements(v1, len); - BOOST_CHECK_EQUAL(len, N); - wr[0] = int16_t(0); - BOOST_CHECK_EQUAL(int16_t(0), wr[0]); - BOOST_CHECK_EQUAL(s1, wr[1]); - BOOST_CHECK_EQUAL(s2, wr[2]); +BOOST_AUTO_TEST_CASE(test_s16vector) +{ + static const size_t N = 3; + pmt::pmt_t v1 = pmt::make_s16vector(N, 0); + BOOST_CHECK_EQUAL(N, pmt::length(v1)); + int16_t s0 = int16_t(10); + int16_t s1 = int16_t(20); + int16_t s2 = int16_t(30); + + pmt::s16vector_set(v1, 0, s0); + pmt::s16vector_set(v1, 1, s1); + pmt::s16vector_set(v1, 2, s2); + + BOOST_CHECK_EQUAL(s0, pmt::s16vector_ref(v1, 0)); + BOOST_CHECK_EQUAL(s1, pmt::s16vector_ref(v1, 1)); + BOOST_CHECK_EQUAL(s2, pmt::s16vector_ref(v1, 2)); + + BOOST_CHECK_THROW(pmt::s16vector_ref(v1, N), pmt::out_of_range); + BOOST_CHECK_THROW(pmt::s16vector_set(v1, N, int16_t(0)), pmt::out_of_range); + + size_t len; + const int16_t* rd = pmt::s16vector_elements(v1, len); + BOOST_CHECK_EQUAL(len, N); + BOOST_CHECK_EQUAL(s0, rd[0]); + BOOST_CHECK_EQUAL(s1, rd[1]); + BOOST_CHECK_EQUAL(s2, rd[2]); + + int16_t* wr = pmt::s16vector_writable_elements(v1, len); + BOOST_CHECK_EQUAL(len, N); + wr[0] = int16_t(0); + BOOST_CHECK_EQUAL(int16_t(0), wr[0]); + BOOST_CHECK_EQUAL(s1, wr[1]); + BOOST_CHECK_EQUAL(s2, wr[2]); } -BOOST_AUTO_TEST_CASE(test_u32vector) { - static const size_t N = 3; - pmt::pmt_t v1 = pmt::make_u32vector(N, 0); - BOOST_CHECK_EQUAL(N, pmt::length(v1)); - uint32_t s0 = uint32_t(10); - uint32_t s1 = uint32_t(20); - uint32_t s2 = uint32_t(30); - - pmt::u32vector_set(v1, 0, s0); - pmt::u32vector_set(v1, 1, s1); - pmt::u32vector_set(v1, 2, s2); - - BOOST_CHECK_EQUAL(s0, pmt::u32vector_ref(v1, 0)); - BOOST_CHECK_EQUAL(s1, pmt::u32vector_ref(v1, 1)); - BOOST_CHECK_EQUAL(s2, pmt::u32vector_ref(v1, 2)); - - BOOST_CHECK_THROW(pmt::u32vector_ref(v1, N), pmt::out_of_range); - BOOST_CHECK_THROW(pmt::u32vector_set(v1, N, uint32_t(0)), pmt::out_of_range); - - size_t len; - const uint32_t *rd = pmt::u32vector_elements(v1, len); - BOOST_CHECK_EQUAL(len, N); - BOOST_CHECK_EQUAL(s0, rd[0]); - BOOST_CHECK_EQUAL(s1, rd[1]); - BOOST_CHECK_EQUAL(s2, rd[2]); - - uint32_t *wr = pmt::u32vector_writable_elements(v1, len); - BOOST_CHECK_EQUAL(len, N); - wr[0] = uint32_t(0); - BOOST_CHECK_EQUAL(uint32_t(0), wr[0]); - BOOST_CHECK_EQUAL(s1, wr[1]); - BOOST_CHECK_EQUAL(s2, wr[2]); +BOOST_AUTO_TEST_CASE(test_u32vector) +{ + static const size_t N = 3; + pmt::pmt_t v1 = pmt::make_u32vector(N, 0); + BOOST_CHECK_EQUAL(N, pmt::length(v1)); + uint32_t s0 = uint32_t(10); + uint32_t s1 = uint32_t(20); + uint32_t s2 = uint32_t(30); + + pmt::u32vector_set(v1, 0, s0); + pmt::u32vector_set(v1, 1, s1); + pmt::u32vector_set(v1, 2, s2); + + BOOST_CHECK_EQUAL(s0, pmt::u32vector_ref(v1, 0)); + BOOST_CHECK_EQUAL(s1, pmt::u32vector_ref(v1, 1)); + BOOST_CHECK_EQUAL(s2, pmt::u32vector_ref(v1, 2)); + + BOOST_CHECK_THROW(pmt::u32vector_ref(v1, N), pmt::out_of_range); + BOOST_CHECK_THROW(pmt::u32vector_set(v1, N, uint32_t(0)), pmt::out_of_range); + + size_t len; + const uint32_t* rd = pmt::u32vector_elements(v1, len); + BOOST_CHECK_EQUAL(len, N); + BOOST_CHECK_EQUAL(s0, rd[0]); + BOOST_CHECK_EQUAL(s1, rd[1]); + BOOST_CHECK_EQUAL(s2, rd[2]); + + uint32_t* wr = pmt::u32vector_writable_elements(v1, len); + BOOST_CHECK_EQUAL(len, N); + wr[0] = uint32_t(0); + BOOST_CHECK_EQUAL(uint32_t(0), wr[0]); + BOOST_CHECK_EQUAL(s1, wr[1]); + BOOST_CHECK_EQUAL(s2, wr[2]); } -BOOST_AUTO_TEST_CASE(test_s32vector) { - static const size_t N = 3; - pmt::pmt_t v1 = pmt::make_s32vector(N, 0); - BOOST_CHECK_EQUAL(N, pmt::length(v1)); - int32_t s0 = int32_t(10); - int32_t s1 = int32_t(20); - int32_t s2 = int32_t(30); - - pmt::s32vector_set(v1, 0, s0); - pmt::s32vector_set(v1, 1, s1); - pmt::s32vector_set(v1, 2, s2); - - BOOST_CHECK_EQUAL(s0, pmt::s32vector_ref(v1, 0)); - BOOST_CHECK_EQUAL(s1, pmt::s32vector_ref(v1, 1)); - BOOST_CHECK_EQUAL(s2, pmt::s32vector_ref(v1, 2)); - - BOOST_CHECK_THROW(pmt::s32vector_ref(v1, N), pmt::out_of_range); - BOOST_CHECK_THROW(pmt::s32vector_set(v1, N, int32_t(0)), pmt::out_of_range); - - size_t len; - const int32_t *rd = pmt::s32vector_elements(v1, len); - BOOST_CHECK_EQUAL(len, N); - BOOST_CHECK_EQUAL(s0, rd[0]); - BOOST_CHECK_EQUAL(s1, rd[1]); - BOOST_CHECK_EQUAL(s2, rd[2]); - - int32_t *wr = pmt::s32vector_writable_elements(v1, len); - BOOST_CHECK_EQUAL(len, N); - wr[0] = int32_t(0); - BOOST_CHECK_EQUAL(int32_t(0), wr[0]); - BOOST_CHECK_EQUAL(s1, wr[1]); - BOOST_CHECK_EQUAL(s2, wr[2]); +BOOST_AUTO_TEST_CASE(test_s32vector) +{ + static const size_t N = 3; + pmt::pmt_t v1 = pmt::make_s32vector(N, 0); + BOOST_CHECK_EQUAL(N, pmt::length(v1)); + int32_t s0 = int32_t(10); + int32_t s1 = int32_t(20); + int32_t s2 = int32_t(30); + + pmt::s32vector_set(v1, 0, s0); + pmt::s32vector_set(v1, 1, s1); + pmt::s32vector_set(v1, 2, s2); + + BOOST_CHECK_EQUAL(s0, pmt::s32vector_ref(v1, 0)); + BOOST_CHECK_EQUAL(s1, pmt::s32vector_ref(v1, 1)); + BOOST_CHECK_EQUAL(s2, pmt::s32vector_ref(v1, 2)); + + BOOST_CHECK_THROW(pmt::s32vector_ref(v1, N), pmt::out_of_range); + BOOST_CHECK_THROW(pmt::s32vector_set(v1, N, int32_t(0)), pmt::out_of_range); + + size_t len; + const int32_t* rd = pmt::s32vector_elements(v1, len); + BOOST_CHECK_EQUAL(len, N); + BOOST_CHECK_EQUAL(s0, rd[0]); + BOOST_CHECK_EQUAL(s1, rd[1]); + BOOST_CHECK_EQUAL(s2, rd[2]); + + int32_t* wr = pmt::s32vector_writable_elements(v1, len); + BOOST_CHECK_EQUAL(len, N); + wr[0] = int32_t(0); + BOOST_CHECK_EQUAL(int32_t(0), wr[0]); + BOOST_CHECK_EQUAL(s1, wr[1]); + BOOST_CHECK_EQUAL(s2, wr[2]); } -BOOST_AUTO_TEST_CASE(test_u64vector) { - static const size_t N = 3; - pmt::pmt_t v1 = pmt::make_u64vector(N, 0); - BOOST_CHECK_EQUAL(N, pmt::length(v1)); - uint64_t s0 = uint64_t(10); - uint64_t s1 = uint64_t(20); - uint64_t s2 = uint64_t(30); - - pmt::u64vector_set(v1, 0, s0); - pmt::u64vector_set(v1, 1, s1); - pmt::u64vector_set(v1, 2, s2); - - BOOST_CHECK_EQUAL(s0, pmt::u64vector_ref(v1, 0)); - BOOST_CHECK_EQUAL(s1, pmt::u64vector_ref(v1, 1)); - BOOST_CHECK_EQUAL(s2, pmt::u64vector_ref(v1, 2)); - - BOOST_CHECK_THROW(pmt::u64vector_ref(v1, N), pmt::out_of_range); - BOOST_CHECK_THROW(pmt::u64vector_set(v1, N, uint64_t(0)), pmt::out_of_range); - - size_t len; - const uint64_t *rd = pmt::u64vector_elements(v1, len); - BOOST_CHECK_EQUAL(len, N); - BOOST_CHECK_EQUAL(s0, rd[0]); - BOOST_CHECK_EQUAL(s1, rd[1]); - BOOST_CHECK_EQUAL(s2, rd[2]); - - uint64_t *wr = pmt::u64vector_writable_elements(v1, len); - BOOST_CHECK_EQUAL(len, N); - wr[0] = uint64_t(0); - BOOST_CHECK_EQUAL(uint64_t(0), wr[0]); - BOOST_CHECK_EQUAL(s1, wr[1]); - BOOST_CHECK_EQUAL(s2, wr[2]); +BOOST_AUTO_TEST_CASE(test_u64vector) +{ + static const size_t N = 3; + pmt::pmt_t v1 = pmt::make_u64vector(N, 0); + BOOST_CHECK_EQUAL(N, pmt::length(v1)); + uint64_t s0 = uint64_t(10); + uint64_t s1 = uint64_t(20); + uint64_t s2 = uint64_t(30); + + pmt::u64vector_set(v1, 0, s0); + pmt::u64vector_set(v1, 1, s1); + pmt::u64vector_set(v1, 2, s2); + + BOOST_CHECK_EQUAL(s0, pmt::u64vector_ref(v1, 0)); + BOOST_CHECK_EQUAL(s1, pmt::u64vector_ref(v1, 1)); + BOOST_CHECK_EQUAL(s2, pmt::u64vector_ref(v1, 2)); + + BOOST_CHECK_THROW(pmt::u64vector_ref(v1, N), pmt::out_of_range); + BOOST_CHECK_THROW(pmt::u64vector_set(v1, N, uint64_t(0)), pmt::out_of_range); + + size_t len; + const uint64_t* rd = pmt::u64vector_elements(v1, len); + BOOST_CHECK_EQUAL(len, N); + BOOST_CHECK_EQUAL(s0, rd[0]); + BOOST_CHECK_EQUAL(s1, rd[1]); + BOOST_CHECK_EQUAL(s2, rd[2]); + + uint64_t* wr = pmt::u64vector_writable_elements(v1, len); + BOOST_CHECK_EQUAL(len, N); + wr[0] = uint64_t(0); + BOOST_CHECK_EQUAL(uint64_t(0), wr[0]); + BOOST_CHECK_EQUAL(s1, wr[1]); + BOOST_CHECK_EQUAL(s2, wr[2]); } -BOOST_AUTO_TEST_CASE(test_s64vector) { - static const size_t N = 3; - pmt::pmt_t v1 = pmt::make_s64vector(N, 0); - BOOST_CHECK_EQUAL(N, pmt::length(v1)); - int64_t s0 = int64_t(10); - int64_t s1 = int64_t(20); - int64_t s2 = int64_t(30); - - pmt::s64vector_set(v1, 0, s0); - pmt::s64vector_set(v1, 1, s1); - pmt::s64vector_set(v1, 2, s2); - - BOOST_CHECK_EQUAL(s0, pmt::s64vector_ref(v1, 0)); - BOOST_CHECK_EQUAL(s1, pmt::s64vector_ref(v1, 1)); - BOOST_CHECK_EQUAL(s2, pmt::s64vector_ref(v1, 2)); - - BOOST_CHECK_THROW(pmt::s64vector_ref(v1, N), pmt::out_of_range); - BOOST_CHECK_THROW(pmt::s64vector_set(v1, N, int64_t(0)), pmt::out_of_range); - - size_t len; - const int64_t *rd = pmt::s64vector_elements(v1, len); - BOOST_CHECK_EQUAL(len, N); - BOOST_CHECK_EQUAL(s0, rd[0]); - BOOST_CHECK_EQUAL(s1, rd[1]); - BOOST_CHECK_EQUAL(s2, rd[2]); - - int64_t *wr = pmt::s64vector_writable_elements(v1, len); - BOOST_CHECK_EQUAL(len, N); - wr[0] = int64_t(0); - BOOST_CHECK_EQUAL(int64_t(0), wr[0]); - BOOST_CHECK_EQUAL(s1, wr[1]); - BOOST_CHECK_EQUAL(s2, wr[2]); +BOOST_AUTO_TEST_CASE(test_s64vector) +{ + static const size_t N = 3; + pmt::pmt_t v1 = pmt::make_s64vector(N, 0); + BOOST_CHECK_EQUAL(N, pmt::length(v1)); + int64_t s0 = int64_t(10); + int64_t s1 = int64_t(20); + int64_t s2 = int64_t(30); + + pmt::s64vector_set(v1, 0, s0); + pmt::s64vector_set(v1, 1, s1); + pmt::s64vector_set(v1, 2, s2); + + BOOST_CHECK_EQUAL(s0, pmt::s64vector_ref(v1, 0)); + BOOST_CHECK_EQUAL(s1, pmt::s64vector_ref(v1, 1)); + BOOST_CHECK_EQUAL(s2, pmt::s64vector_ref(v1, 2)); + + BOOST_CHECK_THROW(pmt::s64vector_ref(v1, N), pmt::out_of_range); + BOOST_CHECK_THROW(pmt::s64vector_set(v1, N, int64_t(0)), pmt::out_of_range); + + size_t len; + const int64_t* rd = pmt::s64vector_elements(v1, len); + BOOST_CHECK_EQUAL(len, N); + BOOST_CHECK_EQUAL(s0, rd[0]); + BOOST_CHECK_EQUAL(s1, rd[1]); + BOOST_CHECK_EQUAL(s2, rd[2]); + + int64_t* wr = pmt::s64vector_writable_elements(v1, len); + BOOST_CHECK_EQUAL(len, N); + wr[0] = int64_t(0); + BOOST_CHECK_EQUAL(int64_t(0), wr[0]); + BOOST_CHECK_EQUAL(s1, wr[1]); + BOOST_CHECK_EQUAL(s2, wr[2]); } -BOOST_AUTO_TEST_CASE(test_f32vector) { - static const size_t N = 3; - pmt::pmt_t v1 = pmt::make_f32vector(N, 0); - BOOST_CHECK_EQUAL(N, pmt::length(v1)); - float s0 = float(10); - float s1 = float(20); - float s2 = float(30); - - pmt::f32vector_set(v1, 0, s0); - pmt::f32vector_set(v1, 1, s1); - pmt::f32vector_set(v1, 2, s2); - - BOOST_CHECK_EQUAL(s0, pmt::f32vector_ref(v1, 0)); - BOOST_CHECK_EQUAL(s1, pmt::f32vector_ref(v1, 1)); - BOOST_CHECK_EQUAL(s2, pmt::f32vector_ref(v1, 2)); - - BOOST_CHECK_THROW(pmt::f32vector_ref(v1, N), pmt::out_of_range); - BOOST_CHECK_THROW(pmt::f32vector_set(v1, N, float(0)), pmt::out_of_range); - - size_t len; - const float *rd = pmt::f32vector_elements(v1, len); - BOOST_CHECK_EQUAL(len, N); - BOOST_CHECK_EQUAL(s0, rd[0]); - BOOST_CHECK_EQUAL(s1, rd[1]); - BOOST_CHECK_EQUAL(s2, rd[2]); - - float *wr = pmt::f32vector_writable_elements(v1, len); - BOOST_CHECK_EQUAL(len, N); - wr[0] = float(0); - BOOST_CHECK_EQUAL(float(0), wr[0]); - BOOST_CHECK_EQUAL(s1, wr[1]); - BOOST_CHECK_EQUAL(s2, wr[2]); +BOOST_AUTO_TEST_CASE(test_f32vector) +{ + static const size_t N = 3; + pmt::pmt_t v1 = pmt::make_f32vector(N, 0); + BOOST_CHECK_EQUAL(N, pmt::length(v1)); + float s0 = float(10); + float s1 = float(20); + float s2 = float(30); + + pmt::f32vector_set(v1, 0, s0); + pmt::f32vector_set(v1, 1, s1); + pmt::f32vector_set(v1, 2, s2); + + BOOST_CHECK_EQUAL(s0, pmt::f32vector_ref(v1, 0)); + BOOST_CHECK_EQUAL(s1, pmt::f32vector_ref(v1, 1)); + BOOST_CHECK_EQUAL(s2, pmt::f32vector_ref(v1, 2)); + + BOOST_CHECK_THROW(pmt::f32vector_ref(v1, N), pmt::out_of_range); + BOOST_CHECK_THROW(pmt::f32vector_set(v1, N, float(0)), pmt::out_of_range); + + size_t len; + const float* rd = pmt::f32vector_elements(v1, len); + BOOST_CHECK_EQUAL(len, N); + BOOST_CHECK_EQUAL(s0, rd[0]); + BOOST_CHECK_EQUAL(s1, rd[1]); + BOOST_CHECK_EQUAL(s2, rd[2]); + + float* wr = pmt::f32vector_writable_elements(v1, len); + BOOST_CHECK_EQUAL(len, N); + wr[0] = float(0); + BOOST_CHECK_EQUAL(float(0), wr[0]); + BOOST_CHECK_EQUAL(s1, wr[1]); + BOOST_CHECK_EQUAL(s2, wr[2]); } -BOOST_AUTO_TEST_CASE(test_f64vector) { - static const size_t N = 3; - pmt::pmt_t v1 = pmt::make_f64vector(N, 0); - BOOST_CHECK_EQUAL(N, pmt::length(v1)); - double s0 = double(10); - double s1 = double(20); - double s2 = double(30); - - pmt::f64vector_set(v1, 0, s0); - pmt::f64vector_set(v1, 1, s1); - pmt::f64vector_set(v1, 2, s2); - - BOOST_CHECK_EQUAL(s0, pmt::f64vector_ref(v1, 0)); - BOOST_CHECK_EQUAL(s1, pmt::f64vector_ref(v1, 1)); - BOOST_CHECK_EQUAL(s2, pmt::f64vector_ref(v1, 2)); - - BOOST_CHECK_THROW(pmt::f64vector_ref(v1, N), pmt::out_of_range); - BOOST_CHECK_THROW(pmt::f64vector_set(v1, N, double(0)), pmt::out_of_range); - - size_t len; - const double *rd = pmt::f64vector_elements(v1, len); - BOOST_CHECK_EQUAL(len, N); - BOOST_CHECK_EQUAL(s0, rd[0]); - BOOST_CHECK_EQUAL(s1, rd[1]); - BOOST_CHECK_EQUAL(s2, rd[2]); - - double *wr = pmt::f64vector_writable_elements(v1, len); - BOOST_CHECK_EQUAL(len, N); - wr[0] = double(0); - BOOST_CHECK_EQUAL(double(0), wr[0]); - BOOST_CHECK_EQUAL(s1, wr[1]); - BOOST_CHECK_EQUAL(s2, wr[2]); +BOOST_AUTO_TEST_CASE(test_f64vector) +{ + static const size_t N = 3; + pmt::pmt_t v1 = pmt::make_f64vector(N, 0); + BOOST_CHECK_EQUAL(N, pmt::length(v1)); + double s0 = double(10); + double s1 = double(20); + double s2 = double(30); + + pmt::f64vector_set(v1, 0, s0); + pmt::f64vector_set(v1, 1, s1); + pmt::f64vector_set(v1, 2, s2); + + BOOST_CHECK_EQUAL(s0, pmt::f64vector_ref(v1, 0)); + BOOST_CHECK_EQUAL(s1, pmt::f64vector_ref(v1, 1)); + BOOST_CHECK_EQUAL(s2, pmt::f64vector_ref(v1, 2)); + + BOOST_CHECK_THROW(pmt::f64vector_ref(v1, N), pmt::out_of_range); + BOOST_CHECK_THROW(pmt::f64vector_set(v1, N, double(0)), pmt::out_of_range); + + size_t len; + const double* rd = pmt::f64vector_elements(v1, len); + BOOST_CHECK_EQUAL(len, N); + BOOST_CHECK_EQUAL(s0, rd[0]); + BOOST_CHECK_EQUAL(s1, rd[1]); + BOOST_CHECK_EQUAL(s2, rd[2]); + + double* wr = pmt::f64vector_writable_elements(v1, len); + BOOST_CHECK_EQUAL(len, N); + wr[0] = double(0); + BOOST_CHECK_EQUAL(double(0), wr[0]); + BOOST_CHECK_EQUAL(s1, wr[1]); + BOOST_CHECK_EQUAL(s2, wr[2]); } -BOOST_AUTO_TEST_CASE(test_c32vector) { - static const size_t N = 3; - pmt::pmt_t v1 = pmt::make_c32vector(N, 0); - BOOST_CHECK_EQUAL(N, pmt::length(v1)); - std::complex<float> s0 = std::complex<float>(10); - std::complex<float> s1 = std::complex<float>(20); - std::complex<float> s2 = std::complex<float>(30); - - pmt::c32vector_set(v1, 0, s0); - pmt::c32vector_set(v1, 1, s1); - pmt::c32vector_set(v1, 2, s2); - - BOOST_CHECK_EQUAL(s0, pmt::c32vector_ref(v1, 0)); - BOOST_CHECK_EQUAL(s1, pmt::c32vector_ref(v1, 1)); - BOOST_CHECK_EQUAL(s2, pmt::c32vector_ref(v1, 2)); - - BOOST_CHECK_THROW(pmt::c32vector_ref(v1, N), pmt::out_of_range); - BOOST_CHECK_THROW(pmt::c32vector_set(v1, N, std::complex<float>(0)), pmt::out_of_range); - - size_t len; - const std::complex<float> *rd = pmt::c32vector_elements(v1, len); - BOOST_CHECK_EQUAL(len, N); - BOOST_CHECK_EQUAL(s0, rd[0]); - BOOST_CHECK_EQUAL(s1, rd[1]); - BOOST_CHECK_EQUAL(s2, rd[2]); - - std::complex<float> *wr = pmt::c32vector_writable_elements(v1, len); - BOOST_CHECK_EQUAL(len, N); - wr[0] = std::complex<float>(0); - BOOST_CHECK_EQUAL(std::complex<float>(0), wr[0]); - BOOST_CHECK_EQUAL(s1, wr[1]); - BOOST_CHECK_EQUAL(s2, wr[2]); +BOOST_AUTO_TEST_CASE(test_c32vector) +{ + static const size_t N = 3; + pmt::pmt_t v1 = pmt::make_c32vector(N, 0); + BOOST_CHECK_EQUAL(N, pmt::length(v1)); + std::complex<float> s0 = std::complex<float>(10); + std::complex<float> s1 = std::complex<float>(20); + std::complex<float> s2 = std::complex<float>(30); + + pmt::c32vector_set(v1, 0, s0); + pmt::c32vector_set(v1, 1, s1); + pmt::c32vector_set(v1, 2, s2); + + BOOST_CHECK_EQUAL(s0, pmt::c32vector_ref(v1, 0)); + BOOST_CHECK_EQUAL(s1, pmt::c32vector_ref(v1, 1)); + BOOST_CHECK_EQUAL(s2, pmt::c32vector_ref(v1, 2)); + + BOOST_CHECK_THROW(pmt::c32vector_ref(v1, N), pmt::out_of_range); + BOOST_CHECK_THROW(pmt::c32vector_set(v1, N, std::complex<float>(0)), + pmt::out_of_range); + + size_t len; + const std::complex<float>* rd = pmt::c32vector_elements(v1, len); + BOOST_CHECK_EQUAL(len, N); + BOOST_CHECK_EQUAL(s0, rd[0]); + BOOST_CHECK_EQUAL(s1, rd[1]); + BOOST_CHECK_EQUAL(s2, rd[2]); + + std::complex<float>* wr = pmt::c32vector_writable_elements(v1, len); + BOOST_CHECK_EQUAL(len, N); + wr[0] = std::complex<float>(0); + BOOST_CHECK_EQUAL(std::complex<float>(0), wr[0]); + BOOST_CHECK_EQUAL(s1, wr[1]); + BOOST_CHECK_EQUAL(s2, wr[2]); } -BOOST_AUTO_TEST_CASE(test_c64vector) { - static const size_t N = 3; - pmt::pmt_t v1 = pmt::make_c64vector(N, 0); - BOOST_CHECK_EQUAL(N, pmt::length(v1)); - std::complex<double> s0 = std::complex<double>(10); - std::complex<double> s1 = std::complex<double>(20); - std::complex<double> s2 = std::complex<double>(30); - - pmt::c64vector_set(v1, 0, s0); - pmt::c64vector_set(v1, 1, s1); - pmt::c64vector_set(v1, 2, s2); - - BOOST_CHECK_EQUAL(s0, pmt::c64vector_ref(v1, 0)); - BOOST_CHECK_EQUAL(s1, pmt::c64vector_ref(v1, 1)); - BOOST_CHECK_EQUAL(s2, pmt::c64vector_ref(v1, 2)); - - BOOST_CHECK_THROW(pmt::c64vector_ref(v1, N), pmt::out_of_range); - BOOST_CHECK_THROW(pmt::c64vector_set(v1, N, std::complex<double>(0)), pmt::out_of_range); - - size_t len; - const std::complex<double> *rd = pmt::c64vector_elements(v1, len); - BOOST_CHECK_EQUAL(len, N); - BOOST_CHECK_EQUAL(s0, rd[0]); - BOOST_CHECK_EQUAL(s1, rd[1]); - BOOST_CHECK_EQUAL(s2, rd[2]); - - std::complex<double> *wr = pmt::c64vector_writable_elements(v1, len); - BOOST_CHECK_EQUAL(len, N); - wr[0] = std::complex<double>(0); - BOOST_CHECK_EQUAL(std::complex<double>(0), wr[0]); - BOOST_CHECK_EQUAL(s1, wr[1]); - BOOST_CHECK_EQUAL(s2, wr[2]); +BOOST_AUTO_TEST_CASE(test_c64vector) +{ + static const size_t N = 3; + pmt::pmt_t v1 = pmt::make_c64vector(N, 0); + BOOST_CHECK_EQUAL(N, pmt::length(v1)); + std::complex<double> s0 = std::complex<double>(10); + std::complex<double> s1 = std::complex<double>(20); + std::complex<double> s2 = std::complex<double>(30); + + pmt::c64vector_set(v1, 0, s0); + pmt::c64vector_set(v1, 1, s1); + pmt::c64vector_set(v1, 2, s2); + + BOOST_CHECK_EQUAL(s0, pmt::c64vector_ref(v1, 0)); + BOOST_CHECK_EQUAL(s1, pmt::c64vector_ref(v1, 1)); + BOOST_CHECK_EQUAL(s2, pmt::c64vector_ref(v1, 2)); + + BOOST_CHECK_THROW(pmt::c64vector_ref(v1, N), pmt::out_of_range); + BOOST_CHECK_THROW(pmt::c64vector_set(v1, N, std::complex<double>(0)), + pmt::out_of_range); + + size_t len; + const std::complex<double>* rd = pmt::c64vector_elements(v1, len); + BOOST_CHECK_EQUAL(len, N); + BOOST_CHECK_EQUAL(s0, rd[0]); + BOOST_CHECK_EQUAL(s1, rd[1]); + BOOST_CHECK_EQUAL(s2, rd[2]); + + std::complex<double>* wr = pmt::c64vector_writable_elements(v1, len); + BOOST_CHECK_EQUAL(len, N); + wr[0] = std::complex<double>(0); + BOOST_CHECK_EQUAL(std::complex<double>(0), wr[0]); + BOOST_CHECK_EQUAL(s1, wr[1]); + BOOST_CHECK_EQUAL(s2, wr[2]); } diff --git a/gnuradio-runtime/lib/prefs.cc b/gnuradio-runtime/lib/prefs.cc index 426fbd33c2..218926d312 100644 --- a/gnuradio-runtime/lib/prefs.cc +++ b/gnuradio-runtime/lib/prefs.cc @@ -43,195 +43,187 @@ typedef std::ifstream::char_type char_t; namespace gr { - prefs * - prefs::singleton() - { +prefs* prefs::singleton() +{ static prefs instance; // Guaranteed to be destroyed. - // Instantiated on first use. + // Instantiated on first use. return &instance; - } +} - prefs::prefs() - { - _read_files(_sys_prefs_filenames()); - } +prefs::prefs() { _read_files(_sys_prefs_filenames()); } - prefs::~prefs() - { +prefs::~prefs() +{ // nop - } +} - std::vector<std::string> - prefs::_sys_prefs_filenames() - { +std::vector<std::string> prefs::_sys_prefs_filenames() +{ std::vector<std::string> fnames; fs::path dir = prefsdir(); - if(fs::is_directory(dir)) { - fs::directory_iterator diritr(dir); - while(diritr != fs::directory_iterator()) { - fs::path p = *diritr++; - if(p.extension() == ".conf") - fnames.push_back(p.string()); - } - std::sort(fnames.begin(), fnames.end()); + if (fs::is_directory(dir)) { + fs::directory_iterator diritr(dir); + while (diritr != fs::directory_iterator()) { + fs::path p = *diritr++; + if (p.extension() == ".conf") + fnames.push_back(p.string()); + } + std::sort(fnames.begin(), fnames.end()); } // Find if there is a ~/.gnuradio/config.conf file and add this to // the end of the file list to override any preferences in the // installed path config files. fs::path userconf = fs::path(gr::userconf_path()) / "config.conf"; - if(fs::exists(userconf)) { - fnames.push_back(userconf.string()); + if (fs::exists(userconf)) { + fnames.push_back(userconf.string()); } return fnames; - } - - void - prefs::_read_files(const std::vector<std::string> &filenames) - { - BOOST_FOREACH( std::string fname, filenames) { - std::ifstream infile(fname.c_str()); - if(infile.good()) { - try { - po::basic_parsed_options<char_t> parsed = po::parse_config_file(infile, po::options_description(), true); - BOOST_FOREACH(po::basic_option<char_t> o, (parsed.options) ){ - std::string okey = o.string_key; - size_t pos = okey.find("."); - std::string section, key; - if(pos != std::string::npos) { - section = okey.substr(0,pos); - key = okey.substr(pos+1); - } else { - section = "default"; - key = okey; +} + +void prefs::_read_files(const std::vector<std::string>& filenames) +{ + BOOST_FOREACH (std::string fname, filenames) { + std::ifstream infile(fname.c_str()); + if (infile.good()) { + try { + po::basic_parsed_options<char_t> parsed = + po::parse_config_file(infile, po::options_description(), true); + BOOST_FOREACH (po::basic_option<char_t> o, (parsed.options)) { + std::string okey = o.string_key; + size_t pos = okey.find("."); + std::string section, key; + if (pos != std::string::npos) { + section = okey.substr(0, pos); + key = okey.substr(pos + 1); + } else { + section = "default"; + key = okey; + } + std::transform( + section.begin(), section.end(), section.begin(), ::tolower); + std::transform(key.begin(), key.end(), key.begin(), ::tolower); + // value of a basic_option is always a std::vector<string>; we only + // allow single values, so: + std::string value = o.value[0]; + d_config_map[section][key] = value; + } + } catch (std::exception e) { + std::cerr << "WARNING: Config file '" << fname + << "' failed to parse:" << std::endl; + std::cerr << e.what() << std::endl; + std::cerr << "Skipping it" << std::endl; } - std::transform(section.begin(), section.end(), section.begin(), ::tolower); - std::transform(key.begin(), key.end(), key.begin(), ::tolower); - // value of a basic_option is always a std::vector<string>; we only allow single values, so: - std::string value = o.value[0]; - d_config_map[section][key] = value; - } - } catch(std::exception e) { - std::cerr << "WARNING: Config file '" << fname << "' failed to parse:" << std::endl; - std::cerr << e.what() << std::endl; - std::cerr << "Skipping it" << std::endl; + } else { // infile.good(); + std::cerr << "WARNING: Config file '" << fname + << "' could not be opened for reading." << std::endl; } - } else { // infile.good(); - std::cerr << "WARNING: Config file '" << fname << "' could not be opened for reading." << std::endl; - } } - } +} - void - prefs::add_config_file(const std::string &configfile) - { +void prefs::add_config_file(const std::string& configfile) +{ std::vector<std::string> filenames; filenames.push_back(configfile); _read_files(filenames); - } +} - std::string - prefs::to_string() - { +std::string prefs::to_string() +{ config_map_itr sections; config_map_elem_itr options; std::stringstream s; - for(sections = d_config_map.begin(); sections != d_config_map.end(); sections++) { - s << "[" << sections->first << "]" << std::endl; - for(options = sections->second.begin(); options != sections->second.end(); options++) { - s << options->first << " = " << options->second << std::endl; - } - s << std::endl; + for (sections = d_config_map.begin(); sections != d_config_map.end(); sections++) { + s << "[" << sections->first << "]" << std::endl; + for (options = sections->second.begin(); options != sections->second.end(); + options++) { + s << options->first << " = " << options->second << std::endl; + } + s << std::endl; } return s.str(); - } +} - void - prefs::save() - { +void prefs::save() +{ std::string conf = to_string(); fs::path userconf = fs::path(gr::userconf_path()) / "config.conf"; fs::ofstream fout(userconf); fout << conf; fout.close(); - } +} - char * - prefs::option_to_env(std::string section, std::string option) - { +char* prefs::option_to_env(std::string section, std::string option) +{ std::stringstream envname; - std::string secname=section, optname=option; + std::string secname = section, optname = option; std::transform(section.begin(), section.end(), secname.begin(), ::toupper); std::transform(option.begin(), option.end(), optname.begin(), ::toupper); envname << "GR_CONF_" << secname << "_" << optname; return getenv(envname.str().c_str()); - } +} - bool - prefs::has_section(const std::string §ion) - { +bool prefs::has_section(const std::string& section) +{ std::string s = section; std::transform(section.begin(), section.end(), s.begin(), ::tolower); return d_config_map.count(s) > 0; - } +} - bool - prefs::has_option(const std::string §ion, const std::string &option) - { - if(option_to_env(section, option)) - return true; +bool prefs::has_option(const std::string& section, const std::string& option) +{ + if (option_to_env(section, option)) + return true; - if(has_section(section)) { - std::string s = section; - std::transform(section.begin(), section.end(), s.begin(), ::tolower); + if (has_section(section)) { + std::string s = section; + std::transform(section.begin(), section.end(), s.begin(), ::tolower); - std::string o = option; - std::transform(option.begin(), option.end(), o.begin(), ::tolower); + std::string o = option; + std::transform(option.begin(), option.end(), o.begin(), ::tolower); - config_map_itr sec = d_config_map.find(s); - return sec->second.count(o) > 0; - } - else { - return false; - } - } - - const std::string - prefs::get_string(const std::string §ion, const std::string &option, - const std::string &default_val) - { - char *env = option_to_env(section, option); - if(env) - return std::string(env); - - if(has_option(section, option)) { - std::string s = section; - std::transform(section.begin(), section.end(), s.begin(), ::tolower); - - std::string o = option; - std::transform(option.begin(), option.end(), o.begin(), ::tolower); - - config_map_itr sec = d_config_map.find(s); - config_map_elem_itr opt = sec->second.find(o); - return opt->second; + config_map_itr sec = d_config_map.find(s); + return sec->second.count(o) > 0; + } else { + return false; } - else { - return default_val; +} + +const std::string prefs::get_string(const std::string& section, + const std::string& option, + const std::string& default_val) +{ + char* env = option_to_env(section, option); + if (env) + return std::string(env); + + if (has_option(section, option)) { + std::string s = section; + std::transform(section.begin(), section.end(), s.begin(), ::tolower); + + std::string o = option; + std::transform(option.begin(), option.end(), o.begin(), ::tolower); + + config_map_itr sec = d_config_map.find(s); + config_map_elem_itr opt = sec->second.find(o); + return opt->second; + } else { + return default_val; } - } +} - void - prefs::set_string(const std::string §ion, const std::string &option, - const std::string &val) - { +void prefs::set_string(const std::string& section, + const std::string& option, + const std::string& val) +{ std::string s = section; std::transform(section.begin(), section.end(), s.begin(), ::tolower); @@ -243,34 +235,31 @@ namespace gr { opt_map[o] = val; d_config_map[s] = opt_map; - } - - bool - prefs::get_bool(const std::string §ion, const std::string &option, - bool default_val) - { - if(has_option(section, option)) { - std::string str = get_string(section, option, ""); - if(str == "") { - return default_val; - } - std::transform(str.begin(), str.end(), str.begin(), ::tolower); - if((str == "true") || (str == "on") || (str == "1")) - return true; - else if((str == "false") || (str == "off") || (str == "0")) - return false; - else +} + +bool prefs::get_bool(const std::string& section, + const std::string& option, + bool default_val) +{ + if (has_option(section, option)) { + std::string str = get_string(section, option, ""); + if (str == "") { + return default_val; + } + std::transform(str.begin(), str.end(), str.begin(), ::tolower); + if ((str == "true") || (str == "on") || (str == "1")) + return true; + else if ((str == "false") || (str == "off") || (str == "0")) + return false; + else + return default_val; + } else { return default_val; } - else { - return default_val; - } - } +} - void - prefs::set_bool(const std::string §ion, const std::string &option, - bool val) - { +void prefs::set_bool(const std::string& section, const std::string& option, bool val) +{ std::string s = section; std::transform(section.begin(), section.end(), s.begin(), ::tolower); @@ -284,31 +273,28 @@ namespace gr { opt_map[o] = sstr.str(); d_config_map[s] = opt_map; - } - - long - prefs::get_long(const std::string §ion, const std::string &option, - long default_val) - { - if(has_option(section, option)) { - std::string str = get_string(section, option, ""); - if(str == "") { +} + +long prefs::get_long(const std::string& section, + const std::string& option, + long default_val) +{ + if (has_option(section, option)) { + std::string str = get_string(section, option, ""); + if (str == "") { + return default_val; + } + std::stringstream sstr(str); + long n; + sstr >> n; + return n; + } else { return default_val; - } - std::stringstream sstr(str); - long n; - sstr >> n; - return n; - } - else { - return default_val; } - } +} - void - prefs::set_long(const std::string §ion, const std::string &option, - long val) - { +void prefs::set_long(const std::string& section, const std::string& option, long val) +{ std::string s = section; std::transform(section.begin(), section.end(), s.begin(), ::tolower); @@ -322,31 +308,28 @@ namespace gr { opt_map[o] = sstr.str(); d_config_map[s] = opt_map; - } - - double - prefs::get_double(const std::string §ion, const std::string &option, - double default_val) - { - if(has_option(section, option)) { - std::string str = get_string(section, option, ""); - if(str == "") { +} + +double prefs::get_double(const std::string& section, + const std::string& option, + double default_val) +{ + if (has_option(section, option)) { + std::string str = get_string(section, option, ""); + if (str == "") { + return default_val; + } + std::stringstream sstr(str); + double n; + sstr >> n; + return n; + } else { return default_val; - } - std::stringstream sstr(str); - double n; - sstr >> n; - return n; - } - else { - return default_val; } - } +} - void - prefs::set_double(const std::string §ion, const std::string &option, - double val) - { +void prefs::set_double(const std::string& section, const std::string& option, double val) +{ std::string s = section; std::transform(section.begin(), section.end(), s.begin(), ::tolower); @@ -360,6 +343,6 @@ namespace gr { opt_map[o] = sstr.str(); d_config_map[s] = opt_map; - } +} } /* namespace gr */ diff --git a/gnuradio-runtime/lib/qa_buffer.cc b/gnuradio-runtime/lib/qa_buffer.cc index 89cb5eca59..64b1d0fc1f 100644 --- a/gnuradio-runtime/lib/qa_buffer.cc +++ b/gnuradio-runtime/lib/qa_buffer.cc @@ -31,19 +31,15 @@ #include <stdlib.h> -static void -leak_check(void f()) +static void leak_check(void f()) { - long buffer_count = gr::buffer_ncurrently_allocated(); - long buffer_reader_count = gr::buffer_reader_ncurrently_allocated(); + long buffer_count = gr::buffer_ncurrently_allocated(); + long buffer_reader_count = gr::buffer_reader_ncurrently_allocated(); - f(); + f(); - BOOST_CHECK_EQUAL( - buffer_reader_count, - gr::buffer_reader_ncurrently_allocated() - ); - BOOST_CHECK_EQUAL(buffer_count, gr::buffer_ncurrently_allocated()); + BOOST_CHECK_EQUAL(buffer_reader_count, gr::buffer_reader_ncurrently_allocated()); + BOOST_CHECK_EQUAL(buffer_count, gr::buffer_ncurrently_allocated()); } @@ -51,239 +47,226 @@ leak_check(void f()) // test single writer, no readers... // -static void -t0_body() +static void t0_body() { - int nitems = 4000 / sizeof(int); - int counter = 0; + int nitems = 4000 / sizeof(int); + int counter = 0; - gr::buffer_sptr buf(gr::make_buffer(nitems, sizeof(int), gr::block_sptr())); + gr::buffer_sptr buf(gr::make_buffer(nitems, sizeof(int), gr::block_sptr())); - int last_sa; - int sa; + int last_sa; + int sa; - sa = buf->space_available(); - BOOST_CHECK(sa > 0); - last_sa = sa; - - for(int i = 0; i < 5; i++) { sa = buf->space_available(); - BOOST_CHECK_EQUAL(last_sa, sa); + BOOST_CHECK(sa > 0); last_sa = sa; - int *p = (int*)buf->write_pointer(); - BOOST_CHECK(p != 0); + for (int i = 0; i < 5; i++) { + sa = buf->space_available(); + BOOST_CHECK_EQUAL(last_sa, sa); + last_sa = sa; - for(int j = 0; j < sa; j++) - *p++ = counter++; + int* p = (int*)buf->write_pointer(); + BOOST_CHECK(p != 0); - buf->update_write_pointer(sa); - } + for (int j = 0; j < sa; j++) + *p++ = counter++; + + buf->update_write_pointer(sa); + } } // ---------------------------------------------------------------------------- // test single writer, single reader // -static void -t1_body() +static void t1_body() { - int nitems = 4000 / sizeof(int); - int write_counter = 0; - int read_counter = 0; + int nitems = 4000 / sizeof(int); + int write_counter = 0; + int read_counter = 0; - gr::buffer_sptr buf(gr::make_buffer(nitems, sizeof(int), gr::block_sptr())); - gr::buffer_reader_sptr r1(gr::buffer_add_reader(buf, 0, gr::block_sptr())); + gr::buffer_sptr buf(gr::make_buffer(nitems, sizeof(int), gr::block_sptr())); + gr::buffer_reader_sptr r1(gr::buffer_add_reader(buf, 0, gr::block_sptr())); - int sa; + int sa; - // write 1/3 of buffer + // write 1/3 of buffer - sa = buf->space_available(); - BOOST_CHECK(sa > 0); + sa = buf->space_available(); + BOOST_CHECK(sa > 0); - int *p = (int*)buf->write_pointer(); - BOOST_CHECK(p != 0); + int* p = (int*)buf->write_pointer(); + BOOST_CHECK(p != 0); - for(int j = 0; j < sa/3; j++) { - *p++ = write_counter++; - } - buf->update_write_pointer(sa/3); + for (int j = 0; j < sa / 3; j++) { + *p++ = write_counter++; + } + buf->update_write_pointer(sa / 3); - // write the next 1/3 (1/2 of what's left) + // write the next 1/3 (1/2 of what's left) - sa = buf->space_available(); - BOOST_CHECK(sa > 0); + sa = buf->space_available(); + BOOST_CHECK(sa > 0); - p = (int*)buf->write_pointer(); - BOOST_CHECK(p != 0); + p = (int*)buf->write_pointer(); + BOOST_CHECK(p != 0); - for(int j = 0; j < sa/2; j++) { - *p++ = write_counter++; - } - buf->update_write_pointer(sa/2); + for (int j = 0; j < sa / 2; j++) { + *p++ = write_counter++; + } + buf->update_write_pointer(sa / 2); - // check that we can read it OK + // check that we can read it OK - int ia = r1->items_available(); - BOOST_CHECK_EQUAL(write_counter, ia); + int ia = r1->items_available(); + BOOST_CHECK_EQUAL(write_counter, ia); - int *rp = (int*)r1->read_pointer(); - BOOST_CHECK(rp != 0); + int* rp = (int*)r1->read_pointer(); + BOOST_CHECK(rp != 0); - for(int i = 0; i < ia/2; i++) { - BOOST_CHECK_EQUAL(read_counter, *rp); - read_counter++; - rp++; - } - r1->update_read_pointer(ia/2); + for (int i = 0; i < ia / 2; i++) { + BOOST_CHECK_EQUAL(read_counter, *rp); + read_counter++; + rp++; + } + r1->update_read_pointer(ia / 2); - // read the rest + // read the rest - ia = r1->items_available(); - rp = (int *) r1->read_pointer(); - BOOST_CHECK(rp != 0); + ia = r1->items_available(); + rp = (int*)r1->read_pointer(); + BOOST_CHECK(rp != 0); - for(int i = 0; i < ia; i++) { - BOOST_CHECK_EQUAL(read_counter, *rp); - read_counter++; - rp++; - } - r1->update_read_pointer(ia); + for (int i = 0; i < ia; i++) { + BOOST_CHECK_EQUAL(read_counter, *rp); + read_counter++; + rp++; + } + r1->update_read_pointer(ia); } // ---------------------------------------------------------------------------- // single writer, single reader: check wrap-around // -static void -t2_body() +static void t2_body() { - // 64K is the largest granularity we've seen so far (MS windows file mapping). - // This allows a bit of "white box testing" + // 64K is the largest granularity we've seen so far (MS windows file mapping). + // This allows a bit of "white box testing" - int nitems = (64 * (1L << 10)) / sizeof(int); // 64K worth of ints + int nitems = (64 * (1L << 10)) / sizeof(int); // 64K worth of ints - gr::buffer_sptr buf(gr::make_buffer(nitems, sizeof(int), gr::block_sptr())); - gr::buffer_reader_sptr r1(gr::buffer_add_reader(buf, 0, gr::block_sptr())); + gr::buffer_sptr buf(gr::make_buffer(nitems, sizeof(int), gr::block_sptr())); + gr::buffer_reader_sptr r1(gr::buffer_add_reader(buf, 0, gr::block_sptr())); - int read_counter = 0; - int write_counter = 0; - int n; - int *wp = 0; - int *rp = 0; + int read_counter = 0; + int write_counter = 0; + int n; + int* wp = 0; + int* rp = 0; - // Write 3/4 of buffer + // Write 3/4 of buffer - n = (int)(buf->space_available() * 0.75); - wp = (int*)buf->write_pointer(); + n = (int)(buf->space_available() * 0.75); + wp = (int*)buf->write_pointer(); - for(int i = 0; i < n; i++) - *wp++ = write_counter++; - buf->update_write_pointer(n); + for (int i = 0; i < n; i++) + *wp++ = write_counter++; + buf->update_write_pointer(n); - // Now read it all + // Now read it all - int m = r1->items_available(); - BOOST_CHECK_EQUAL(n, m); - rp = (int*)r1->read_pointer(); + int m = r1->items_available(); + BOOST_CHECK_EQUAL(n, m); + rp = (int*)r1->read_pointer(); - for(int i = 0; i < m; i++) { - BOOST_CHECK_EQUAL(read_counter, *rp); - read_counter++; - rp++; - } - r1->update_read_pointer(m); + for (int i = 0; i < m; i++) { + BOOST_CHECK_EQUAL(read_counter, *rp); + read_counter++; + rp++; + } + r1->update_read_pointer(m); - // Now write as much as we can. - // This will wrap around the buffer + // Now write as much as we can. + // This will wrap around the buffer - n = buf->space_available(); - BOOST_CHECK_EQUAL(nitems - 1, n); // white box test - wp = (int*)buf->write_pointer(); + n = buf->space_available(); + BOOST_CHECK_EQUAL(nitems - 1, n); // white box test + wp = (int*)buf->write_pointer(); - for(int i = 0; i < n; i++) - *wp++ = write_counter++; - buf->update_write_pointer(n); + for (int i = 0; i < n; i++) + *wp++ = write_counter++; + buf->update_write_pointer(n); - // now read it all + // now read it all - m = r1->items_available(); - BOOST_CHECK_EQUAL(n, m); - rp = (int*)r1->read_pointer(); + m = r1->items_available(); + BOOST_CHECK_EQUAL(n, m); + rp = (int*)r1->read_pointer(); - for(int i = 0; i < m; i++) { - BOOST_CHECK_EQUAL(read_counter, *rp); - read_counter++; - rp++; - } - r1->update_read_pointer(m); + for (int i = 0; i < m; i++) { + BOOST_CHECK_EQUAL(read_counter, *rp); + read_counter++; + rp++; + } + r1->update_read_pointer(m); } // ---------------------------------------------------------------------------- // single writer, N readers, randomized order and lengths // ---------------------------------------------------------------------------- -static void -t3_body() +static void t3_body() { - int nitems = (64 * (1L << 10)) / sizeof(int); - - static const int N = 5; - gr::buffer_sptr buf(gr::make_buffer(nitems, sizeof(int), gr::block_sptr())); - gr::buffer_reader_sptr reader[N]; - int read_counter[N]; - int write_counter = 0; - gr::random random; - - for(int i = 0; i < N; i++) { - read_counter[i] = 0; - reader[i] = buffer_add_reader(buf, 0, gr::block_sptr()); - } + int nitems = (64 * (1L << 10)) / sizeof(int); + + static const int N = 5; + gr::buffer_sptr buf(gr::make_buffer(nitems, sizeof(int), gr::block_sptr())); + gr::buffer_reader_sptr reader[N]; + int read_counter[N]; + int write_counter = 0; + gr::random random; + + for (int i = 0; i < N; i++) { + read_counter[i] = 0; + reader[i] = buffer_add_reader(buf, 0, gr::block_sptr()); + } - for(int lc = 0; lc < 1000; lc++) { + for (int lc = 0; lc < 1000; lc++) { - // write some + // write some - int n = (int)(buf->space_available() * random.ran1()); - int *wp = (int*)buf->write_pointer(); + int n = (int)(buf->space_available() * random.ran1()); + int* wp = (int*)buf->write_pointer(); - for(int i = 0; i < n; i++) - *wp++ = write_counter++; + for (int i = 0; i < n; i++) + *wp++ = write_counter++; - buf->update_write_pointer(n); + buf->update_write_pointer(n); - // pick a random reader and read some + // pick a random reader and read some - int r = (int)(N * random.ran1()); + int r = (int)(N * random.ran1()); - int m = reader[r]->items_available(); - int *rp = (int*)reader[r]->read_pointer(); + int m = reader[r]->items_available(); + int* rp = (int*)reader[r]->read_pointer(); - for(int i = 0; i < m; i++) { - BOOST_CHECK_EQUAL(read_counter[r], *rp); - read_counter[r]++; - rp++; + for (int i = 0; i < m; i++) { + BOOST_CHECK_EQUAL(read_counter[r], *rp); + read_counter[r]++; + rp++; + } + reader[r]->update_read_pointer(m); } - reader[r]->update_read_pointer (m); - } } // ---------------------------------------------------------------------------- -BOOST_AUTO_TEST_CASE(t0) { - leak_check(t0_body); -} - -BOOST_AUTO_TEST_CASE(t1) { - leak_check(t1_body); -} +BOOST_AUTO_TEST_CASE(t0) { leak_check(t0_body); } -BOOST_AUTO_TEST_CASE(t2) { - leak_check(t2_body); -} +BOOST_AUTO_TEST_CASE(t1) { leak_check(t1_body); } -BOOST_AUTO_TEST_CASE(t3) { - leak_check(t3_body); -} +BOOST_AUTO_TEST_CASE(t2) { leak_check(t2_body); } +BOOST_AUTO_TEST_CASE(t3) { leak_check(t3_body); } diff --git a/gnuradio-runtime/lib/qa_circular_file.cc b/gnuradio-runtime/lib/qa_circular_file.cc index 06599caaab..164650819d 100644 --- a/gnuradio-runtime/lib/qa_circular_file.cc +++ b/gnuradio-runtime/lib/qa_circular_file.cc @@ -28,40 +28,39 @@ #include <boost/test/unit_test.hpp> #include <unistd.h> -static const char *test_file = "qa_gr_circular_file.data"; +static const char* test_file = "qa_gr_circular_file.data"; static const int BUFFER_SIZE = 8192; static const int NWRITE = 8192 * 9 / 8; -BOOST_AUTO_TEST_CASE(t1) { +BOOST_AUTO_TEST_CASE(t1) +{ #ifdef HAVE_MMAP - gr::circular_file *cf_writer; - gr::circular_file *cf_reader; + gr::circular_file* cf_writer; + gr::circular_file* cf_reader; - // write the data... - cf_writer = new gr::circular_file(test_file, true, - BUFFER_SIZE * sizeof(short)); + // write the data... + cf_writer = new gr::circular_file(test_file, true, BUFFER_SIZE * sizeof(short)); - short sd; - for(int i = 0; i < NWRITE; i++) { - sd = i; - cf_writer->write(&sd, sizeof (sd)); - } + short sd; + for (int i = 0; i < NWRITE; i++) { + sd = i; + cf_writer->write(&sd, sizeof(sd)); + } - delete cf_writer; + delete cf_writer; - // now read it back... - cf_reader = new gr::circular_file(test_file); - for(int i = 0; i < BUFFER_SIZE; i++) { - int n = cf_reader->read (&sd, sizeof(sd)); - BOOST_CHECK_EQUAL((int) sizeof (sd), n); - BOOST_CHECK_EQUAL(NWRITE - BUFFER_SIZE + i, (int)sd); - } + // now read it back... + cf_reader = new gr::circular_file(test_file); + for (int i = 0; i < BUFFER_SIZE; i++) { + int n = cf_reader->read(&sd, sizeof(sd)); + BOOST_CHECK_EQUAL((int)sizeof(sd), n); + BOOST_CHECK_EQUAL(NWRITE - BUFFER_SIZE + i, (int)sd); + } - int n = cf_reader->read(&sd, sizeof(sd)); - BOOST_CHECK_EQUAL(0, n); + int n = cf_reader->read(&sd, sizeof(sd)); + BOOST_CHECK_EQUAL(0, n); - delete cf_reader; - unlink(test_file); + delete cf_reader; + unlink(test_file); #endif // HAVE_MMAP } - diff --git a/gnuradio-runtime/lib/qa_io_signature.cc b/gnuradio-runtime/lib/qa_io_signature.cc index d09188ed74..24502b2922 100644 --- a/gnuradio-runtime/lib/qa_io_signature.cc +++ b/gnuradio-runtime/lib/qa_io_signature.cc @@ -28,18 +28,15 @@ #include <boost/test/unit_test.hpp> #include <stdexcept> -BOOST_AUTO_TEST_CASE(t0) { - gr::io_signature::make(1, 1, sizeof(int)); -} +BOOST_AUTO_TEST_CASE(t0) { gr::io_signature::make(1, 1, sizeof(int)); } -BOOST_AUTO_TEST_CASE(t1) { - BOOST_REQUIRE_THROW( - gr::io_signature::make(3, 1, sizeof(int)), - std::invalid_argument - ); +BOOST_AUTO_TEST_CASE(t1) +{ + BOOST_REQUIRE_THROW(gr::io_signature::make(3, 1, sizeof(int)), std::invalid_argument); } -BOOST_AUTO_TEST_CASE(t2) { +BOOST_AUTO_TEST_CASE(t2) +{ gr::io_signature::sptr p = gr::io_signature::make(3, gr::io_signature::IO_INFINITE, sizeof(int)); @@ -47,7 +44,8 @@ BOOST_AUTO_TEST_CASE(t2) { BOOST_CHECK_EQUAL(p->sizeof_stream_item(0), (int)sizeof(int)); } -BOOST_AUTO_TEST_CASE(t3) { +BOOST_AUTO_TEST_CASE(t3) +{ gr::io_signature::sptr p = gr::io_signature::make3(0, 5, 1, 2, 3); BOOST_CHECK_EQUAL(p->min_streams(), 0); diff --git a/gnuradio-runtime/lib/qa_logger.cc b/gnuradio-runtime/lib/qa_logger.cc index dc47b53cef..ca322cb9ff 100644 --- a/gnuradio-runtime/lib/qa_logger.cc +++ b/gnuradio-runtime/lib/qa_logger.cc @@ -32,19 +32,20 @@ #include <gnuradio/logger.h> #include <boost/test/unit_test.hpp> -BOOST_AUTO_TEST_CASE(t1) { +BOOST_AUTO_TEST_CASE(t1) +{ #ifdef ENABLE_GR_LOG - // This doesn't really test anything, more just - // making sure nothing's gone horribly wrong. + // This doesn't really test anything, more just + // making sure nothing's gone horribly wrong. - GR_LOG_GETLOGGER(LOG,"main"); - GR_ADD_CONSOLE_APPENDER("main","cout","%d{%H:%M:%S} : %m%n"); - GR_LOG_NOTICE(LOG,"test from c++ NOTICE"); - GR_LOG_DEBUG(LOG,"test from c++ DEBUG"); - GR_LOG_INFO(LOG,"test from c++ INFO"); - GR_LOG_WARN(LOG,"test from c++ WARN"); - GR_LOG_ERROR(LOG,"test from c++ ERROR"); - GR_LOG_FATAL(LOG,"test from c++ FATAL"); - BOOST_CHECK(true); + GR_LOG_GETLOGGER(LOG, "main"); + GR_ADD_CONSOLE_APPENDER("main", "cout", "%d{%H:%M:%S} : %m%n"); + GR_LOG_NOTICE(LOG, "test from c++ NOTICE"); + GR_LOG_DEBUG(LOG, "test from c++ DEBUG"); + GR_LOG_INFO(LOG, "test from c++ INFO"); + GR_LOG_WARN(LOG, "test from c++ WARN"); + GR_LOG_ERROR(LOG, "test from c++ ERROR"); + GR_LOG_FATAL(LOG, "test from c++ FATAL"); + BOOST_CHECK(true); #endif } diff --git a/gnuradio-runtime/lib/qa_vmcircbuf.cc b/gnuradio-runtime/lib/qa_vmcircbuf.cc index 4b8b8273fb..7b418ac903 100644 --- a/gnuradio-runtime/lib/qa_vmcircbuf.cc +++ b/gnuradio-runtime/lib/qa_vmcircbuf.cc @@ -27,8 +27,9 @@ #include "vmcircbuf.h" #include <boost/test/unit_test.hpp> -BOOST_AUTO_TEST_CASE(test_all) { - int verbose = 1; // summary +BOOST_AUTO_TEST_CASE(test_all) +{ + int verbose = 1; // summary - BOOST_REQUIRE(gr::vmcircbuf_sysconfig::test_all_factories(verbose)); + BOOST_REQUIRE(gr::vmcircbuf_sysconfig::test_all_factories(verbose)); } diff --git a/gnuradio-runtime/lib/realtime.cc b/gnuradio-runtime/lib/realtime.cc index 603e97a2f1..d7a5462eeb 100644 --- a/gnuradio-runtime/lib/realtime.cc +++ b/gnuradio-runtime/lib/realtime.cc @@ -28,10 +28,9 @@ namespace gr { - rt_status_t - enable_realtime_scheduling() - { +rt_status_t enable_realtime_scheduling() +{ return gr::impl::enable_realtime_scheduling(); - } +} } /* namespace gr */ diff --git a/gnuradio-runtime/lib/realtime_impl.cc b/gnuradio-runtime/lib/realtime_impl.cc index 83afd9568d..de624f9ad7 100644 --- a/gnuradio-runtime/lib/realtime_impl.cc +++ b/gnuradio-runtime/lib/realtime_impl.cc @@ -42,25 +42,24 @@ #include <pthread.h> namespace gr { - namespace impl { - - /*! - * Rescale our virtual priority so that it maps to the middle 1/2 of - * the priorities given by min_real_pri and max_real_pri. - */ - static int - rescale_virtual_pri(int virtual_pri, int min_real_pri, int max_real_pri) - { - float rmin = min_real_pri + (0.25 * (max_real_pri - min_real_pri)); - float rmax = min_real_pri + (0.75 * (max_real_pri - min_real_pri)); - float m = (rmax - rmin) / (rt_priority_max() - rt_priority_min()); - float y = m * (virtual_pri - rt_priority_min()) + rmin; - int y_int = static_cast<int>(rint(y)); - return std::max(min_real_pri, std::min(max_real_pri, y_int)); - } +namespace impl { - } // namespace impl -} // namespace gr +/*! + * Rescale our virtual priority so that it maps to the middle 1/2 of + * the priorities given by min_real_pri and max_real_pri. + */ +static int rescale_virtual_pri(int virtual_pri, int min_real_pri, int max_real_pri) +{ + float rmin = min_real_pri + (0.25 * (max_real_pri - min_real_pri)); + float rmax = min_real_pri + (0.75 * (max_real_pri - min_real_pri)); + float m = (rmax - rmin) / (rt_priority_max() - rt_priority_min()); + float y = m * (virtual_pri - rt_priority_min()) + rmin; + int y_int = static_cast<int>(rint(y)); + return std::max(min_real_pri, std::min(max_real_pri, y_int)); +} + +} // namespace impl +} // namespace gr #endif @@ -70,123 +69,117 @@ namespace gr { #include <windows.h> namespace gr { - namespace impl { +namespace impl { - rt_status_t enable_realtime_scheduling(rt_sched_param p) - { - //set the priority class on the process - int pri_class = (true)? REALTIME_PRIORITY_CLASS : NORMAL_PRIORITY_CLASS; - if(SetPriorityClass(GetCurrentProcess(), pri_class) == 0) +rt_status_t enable_realtime_scheduling(rt_sched_param p) +{ + // set the priority class on the process + int pri_class = (true) ? REALTIME_PRIORITY_CLASS : NORMAL_PRIORITY_CLASS; + if (SetPriorityClass(GetCurrentProcess(), pri_class) == 0) return RT_OTHER_ERROR; - //scale the priority value to the constants - int priorities[] = { - THREAD_PRIORITY_IDLE, THREAD_PRIORITY_LOWEST, THREAD_PRIORITY_BELOW_NORMAL, THREAD_PRIORITY_NORMAL, - THREAD_PRIORITY_ABOVE_NORMAL, THREAD_PRIORITY_HIGHEST, THREAD_PRIORITY_TIME_CRITICAL - }; - const double priority = double(p.priority)/(rt_priority_max() - rt_priority_min()); - size_t pri_index = size_t((priority+1.0)*6/2.0); // -1 -> 0, +1 -> 6 - pri_index %= sizeof(priorities)/sizeof(*priorities); //range check - - //set the thread priority on the thread - if(SetThreadPriority(GetCurrentThread(), priorities[pri_index]) == 0) + // scale the priority value to the constants + int priorities[] = { THREAD_PRIORITY_IDLE, THREAD_PRIORITY_LOWEST, + THREAD_PRIORITY_BELOW_NORMAL, THREAD_PRIORITY_NORMAL, + THREAD_PRIORITY_ABOVE_NORMAL, THREAD_PRIORITY_HIGHEST, + THREAD_PRIORITY_TIME_CRITICAL }; + const double priority = double(p.priority) / (rt_priority_max() - rt_priority_min()); + size_t pri_index = size_t((priority + 1.0) * 6 / 2.0); // -1 -> 0, +1 -> 6 + pri_index %= sizeof(priorities) / sizeof(*priorities); // range check + + // set the thread priority on the thread + if (SetThreadPriority(GetCurrentThread(), priorities[pri_index]) == 0) return RT_OTHER_ERROR; - //printf("SetPriorityClass + SetThreadPriority\n"); - return RT_OK; - } + // printf("SetPriorityClass + SetThreadPriority\n"); + return RT_OK; +} - } // namespace impl +} // namespace impl } // namespace gr #elif defined(HAVE_PTHREAD_SETSCHEDPARAM) namespace gr { - namespace impl { - - rt_status_t - enable_realtime_scheduling(rt_sched_param p) - { - int policy = p.policy == RT_SCHED_FIFO ? SCHED_FIFO : SCHED_RR; - int min_real_pri = sched_get_priority_min(policy); - int max_real_pri = sched_get_priority_max(policy); - int pri = rescale_virtual_pri(p.priority, min_real_pri, max_real_pri); - - // FIXME check hard and soft limits with getrlimit, and limit the value we ask for. - // fprintf(stderr, "pthread_setschedparam: policy = %d, pri = %d\n", policy, pri); - - struct sched_param param; - memset (¶m, 0, sizeof (param)); - param.sched_priority = pri; - int result = pthread_setschedparam (pthread_self(), policy, ¶m); - if(result != 0) { - if(result == EPERM) // N.B., return value, not errno - return RT_NO_PRIVS; +namespace impl { + +rt_status_t enable_realtime_scheduling(rt_sched_param p) +{ + int policy = p.policy == RT_SCHED_FIFO ? SCHED_FIFO : SCHED_RR; + int min_real_pri = sched_get_priority_min(policy); + int max_real_pri = sched_get_priority_max(policy); + int pri = rescale_virtual_pri(p.priority, min_real_pri, max_real_pri); + + // FIXME check hard and soft limits with getrlimit, and limit the value we ask for. + // fprintf(stderr, "pthread_setschedparam: policy = %d, pri = %d\n", policy, pri); + + struct sched_param param; + memset(¶m, 0, sizeof(param)); + param.sched_priority = pri; + int result = pthread_setschedparam(pthread_self(), policy, ¶m); + if (result != 0) { + if (result == EPERM) // N.B., return value, not errno + return RT_NO_PRIVS; else { - fprintf(stderr, - "pthread_setschedparam: failed to set real time priority: %s\n", - strerror(result)); - return RT_OTHER_ERROR; + fprintf(stderr, + "pthread_setschedparam: failed to set real time priority: %s\n", + strerror(result)); + return RT_OTHER_ERROR; } - } - - //printf("SCHED_FIFO enabled with priority = %d\n", pri); - return RT_OK; } - } // namespace impl + // printf("SCHED_FIFO enabled with priority = %d\n", pri); + return RT_OK; +} + +} // namespace impl } // namespace gr #elif defined(HAVE_SCHED_SETSCHEDULER) namespace gr { - namespace impl { - - rt_status_t - enable_realtime_scheduling(rt_sched_param p) - { - int policy = p.policy == RT_SCHED_FIFO ? SCHED_FIFO : SCHED_RR; - int min_real_pri = sched_get_priority_min(policy); - int max_real_pri = sched_get_priority_max(policy); - int pri = rescale_virtual_pri(p.priority, min_real_pri, max_real_pri); - - // FIXME check hard and soft limits with getrlimit, and limit the value we ask for. - // fprintf(stderr, "sched_setscheduler: policy = %d, pri = %d\n", policy, pri); - - int pid = 0; // this process - struct sched_param param; - memset(¶m, 0, sizeof(param)); - param.sched_priority = pri; - int result = sched_setscheduler(pid, policy, ¶m); - if(result != 0){ - if(errno == EPERM) - return RT_NO_PRIVS; +namespace impl { + +rt_status_t enable_realtime_scheduling(rt_sched_param p) +{ + int policy = p.policy == RT_SCHED_FIFO ? SCHED_FIFO : SCHED_RR; + int min_real_pri = sched_get_priority_min(policy); + int max_real_pri = sched_get_priority_max(policy); + int pri = rescale_virtual_pri(p.priority, min_real_pri, max_real_pri); + + // FIXME check hard and soft limits with getrlimit, and limit the value we ask for. + // fprintf(stderr, "sched_setscheduler: policy = %d, pri = %d\n", policy, pri); + + int pid = 0; // this process + struct sched_param param; + memset(¶m, 0, sizeof(param)); + param.sched_priority = pri; + int result = sched_setscheduler(pid, policy, ¶m); + if (result != 0) { + if (errno == EPERM) + return RT_NO_PRIVS; else { - perror("sched_setscheduler: failed to set real time priority"); - return RT_OTHER_ERROR; + perror("sched_setscheduler: failed to set real time priority"); + return RT_OTHER_ERROR; } - } - - //printf("SCHED_FIFO enabled with priority = %d\n", pri); - return RT_OK; } - } // namespace impl + // printf("SCHED_FIFO enabled with priority = %d\n", pri); + return RT_OK; +} + +} // namespace impl } // namespace gr #else namespace gr { - namespace impl { +namespace impl { - rt_status_t - enable_realtime_scheduling(rt_sched_param p) - { - return RT_NOT_IMPLEMENTED; - } +rt_status_t enable_realtime_scheduling(rt_sched_param p) { return RT_NOT_IMPLEMENTED; } - } // namespace impl +} // namespace impl } // namespace gr #endif diff --git a/gnuradio-runtime/lib/scheduler.cc b/gnuradio-runtime/lib/scheduler.cc index 38d95e6fb2..f054e4c753 100644 --- a/gnuradio-runtime/lib/scheduler.cc +++ b/gnuradio-runtime/lib/scheduler.cc @@ -27,13 +27,8 @@ namespace gr { - scheduler::scheduler(flat_flowgraph_sptr ffg, - int max_noutput_items) - { - } +scheduler::scheduler(flat_flowgraph_sptr ffg, int max_noutput_items) {} - scheduler::~scheduler() - { - } +scheduler::~scheduler() {} } /* namespace gr */ diff --git a/gnuradio-runtime/lib/scheduler.h b/gnuradio-runtime/lib/scheduler.h index 0924808965..36bec12961 100644 --- a/gnuradio-runtime/lib/scheduler.h +++ b/gnuradio-runtime/lib/scheduler.h @@ -29,19 +29,19 @@ namespace gr { - class scheduler; - typedef boost::shared_ptr<scheduler> scheduler_sptr; +class scheduler; +typedef boost::shared_ptr<scheduler> scheduler_sptr; - /*! - * \brief Abstract scheduler that takes a flattened flow graph and - * runs it. - * - * Preconditions: details, buffers and buffer readers have been - * assigned. - */ - class GR_RUNTIME_API scheduler : boost::noncopyable - { - public: +/*! + * \brief Abstract scheduler that takes a flattened flow graph and + * runs it. + * + * Preconditions: details, buffers and buffer readers have been + * assigned. + */ +class GR_RUNTIME_API scheduler : boost::noncopyable +{ +public: /*! * \brief Construct a scheduler and begin evaluating the graph. * @@ -61,7 +61,7 @@ namespace gr { * \brief Block until the graph is done. */ virtual void wait() = 0; - }; +}; } /* namespace gr */ diff --git a/gnuradio-runtime/lib/scheduler_tpb.cc b/gnuradio-runtime/lib/scheduler_tpb.cc index fe593670f8..a255aa4946 100644 --- a/gnuradio-runtime/lib/scheduler_tpb.cc +++ b/gnuradio-runtime/lib/scheduler_tpb.cc @@ -31,32 +31,34 @@ namespace gr { - class tpb_container - { +class tpb_container +{ block_sptr d_block; int d_max_noutput_items; thread::barrier_sptr d_start_sync; - public: - tpb_container(block_sptr block, int max_noutput_items, thread::barrier_sptr start_sync) - : d_block(block), d_max_noutput_items(max_noutput_items), d_start_sync(start_sync) {} +public: + tpb_container(block_sptr block, + int max_noutput_items, + thread::barrier_sptr start_sync) + : d_block(block), d_max_noutput_items(max_noutput_items), d_start_sync(start_sync) + { + } void operator()() { - tpb_thread_body body(d_block, d_start_sync, d_max_noutput_items); + tpb_thread_body body(d_block, d_start_sync, d_max_noutput_items); } - }; +}; - scheduler_sptr - scheduler_tpb::make(flat_flowgraph_sptr ffg, int max_noutput_items) - { +scheduler_sptr scheduler_tpb::make(flat_flowgraph_sptr ffg, int max_noutput_items) +{ return scheduler_sptr(new scheduler_tpb(ffg, max_noutput_items)); - } +} - scheduler_tpb::scheduler_tpb(flat_flowgraph_sptr ffg, - int max_noutput_items) +scheduler_tpb::scheduler_tpb(flat_flowgraph_sptr ffg, int max_noutput_items) : scheduler(ffg, max_noutput_items) - { +{ int block_max_noutput_items; // Get a topologically sorted vector of all the blocks in use. @@ -69,48 +71,35 @@ namespace gr { // Ensure that the done flag is clear on all blocks - for(size_t i = 0; i < blocks.size(); i++) { - blocks[i]->detail()->set_done(false); + for (size_t i = 0; i < blocks.size(); i++) { + blocks[i]->detail()->set_done(false); } thread::barrier_sptr start_sync = - boost::make_shared<thread::barrier>(blocks.size()+1); + boost::make_shared<thread::barrier>(blocks.size() + 1); // Fire off a thead for each block - for(size_t i = 0; i < blocks.size(); i++) { - std::stringstream name; - name << "thread-per-block[" << i << "]: " << blocks[i]; - - // If set, use internal value instead of global value - if(blocks[i]->is_set_max_noutput_items()) { - block_max_noutput_items = blocks[i]->max_noutput_items(); - } - else { - block_max_noutput_items = max_noutput_items; - } - d_threads.create_thread(thread::thread_body_wrapper<tpb_container>( - tpb_container(blocks[i], block_max_noutput_items, start_sync), - name.str())); + for (size_t i = 0; i < blocks.size(); i++) { + std::stringstream name; + name << "thread-per-block[" << i << "]: " << blocks[i]; + + // If set, use internal value instead of global value + if (blocks[i]->is_set_max_noutput_items()) { + block_max_noutput_items = blocks[i]->max_noutput_items(); + } else { + block_max_noutput_items = max_noutput_items; + } + d_threads.create_thread(thread::thread_body_wrapper<tpb_container>( + tpb_container(blocks[i], block_max_noutput_items, start_sync), name.str())); } start_sync->wait(); - } - - scheduler_tpb::~scheduler_tpb() - { - stop(); - } - - void - scheduler_tpb::stop() - { - d_threads.interrupt_all(); - } - - void - scheduler_tpb::wait() - { - d_threads.join_all(); - } +} + +scheduler_tpb::~scheduler_tpb() { stop(); } + +void scheduler_tpb::stop() { d_threads.interrupt_all(); } + +void scheduler_tpb::wait() { d_threads.join_all(); } } /* namespace gr */ diff --git a/gnuradio-runtime/lib/scheduler_tpb.h b/gnuradio-runtime/lib/scheduler_tpb.h index f5ab21f269..a353d1aae0 100644 --- a/gnuradio-runtime/lib/scheduler_tpb.h +++ b/gnuradio-runtime/lib/scheduler_tpb.h @@ -28,14 +28,14 @@ namespace gr { - /*! - * \brief Concrete scheduler that uses a kernel thread-per-block - */ - class GR_RUNTIME_API scheduler_tpb : public scheduler - { +/*! + * \brief Concrete scheduler that uses a kernel thread-per-block + */ +class GR_RUNTIME_API scheduler_tpb : public scheduler +{ gr::thread::thread_group d_threads; - protected: +protected: /*! * \brief Construct a scheduler and begin evaluating the graph. * @@ -44,9 +44,8 @@ namespace gr { */ scheduler_tpb(flat_flowgraph_sptr ffg, int max_noutput_items); - public: - static scheduler_sptr make(flat_flowgraph_sptr ffg, - int max_noutput_items=100000); +public: + static scheduler_sptr make(flat_flowgraph_sptr ffg, int max_noutput_items = 100000); ~scheduler_tpb(); @@ -59,7 +58,7 @@ namespace gr { * \brief Block until the graph is done. */ void wait(); - }; +}; } /* namespace gr */ diff --git a/gnuradio-runtime/lib/sptr_magic.cc b/gnuradio-runtime/lib/sptr_magic.cc index bffef04756..03693cdc8f 100644 --- a/gnuradio-runtime/lib/sptr_magic.cc +++ b/gnuradio-runtime/lib/sptr_magic.cc @@ -32,61 +32,51 @@ namespace gnuradio { - static gr::thread::mutex s_mutex; - typedef std::map<gr::basic_block*, gr::basic_block_sptr> sptr_map; - static sptr_map s_map; +static gr::thread::mutex s_mutex; +typedef std::map<gr::basic_block*, gr::basic_block_sptr> sptr_map; +static sptr_map s_map; - struct disarmable_deleter - { +struct disarmable_deleter { bool armed; - disarmable_deleter() - { - armed = true; - } + disarmable_deleter() { armed = true; } - void operator()(void *p) const + void operator()(void* p) const { - if (armed) - delete static_cast<gr::basic_block *>(p); + if (armed) + delete static_cast<gr::basic_block*>(p); } - void disarm() - { - armed = false; - } - }; + void disarm() { armed = false; } +}; - void - detail::sptr_magic::create_and_stash_initial_sptr(gr::hier_block2 *p) - { +void detail::sptr_magic::create_and_stash_initial_sptr(gr::hier_block2* p) +{ gr::basic_block_sptr sptr(p, disarmable_deleter()); gr::thread::scoped_lock guard(s_mutex); - s_map.insert(sptr_map::value_type(static_cast<gr::basic_block *>(p), sptr)); - } + s_map.insert(sptr_map::value_type(static_cast<gr::basic_block*>(p), sptr)); +} - void - detail::sptr_magic::cancel_initial_sptr(gr::hier_block2 *p) - { +void detail::sptr_magic::cancel_initial_sptr(gr::hier_block2* p) +{ gr::thread::scoped_lock guard(s_mutex); - sptr_map::iterator pos = s_map.find(static_cast<gr::basic_block *>(p)); - if(pos == s_map.end()) - return; /* Not in the map, nothing to do */ + sptr_map::iterator pos = s_map.find(static_cast<gr::basic_block*>(p)); + if (pos == s_map.end()) + return; /* Not in the map, nothing to do */ gr::basic_block_sptr sptr = pos->second; s_map.erase(pos); boost::get_deleter<disarmable_deleter, gr::basic_block>(sptr)->disarm(); - } +} - gr::basic_block_sptr - detail::sptr_magic::fetch_initial_sptr(gr::basic_block *p) - { +gr::basic_block_sptr detail::sptr_magic::fetch_initial_sptr(gr::basic_block* p) +{ /* * If p isn't a subclass of gr::hier_block2, just create the * shared ptr and return it. */ - gr::hier_block2 *hb2 = dynamic_cast<gr::hier_block2 *>(p); - if(!hb2) { - return gr::basic_block_sptr(p); + gr::hier_block2* hb2 = dynamic_cast<gr::hier_block2*>(p); + if (!hb2) { + return gr::basic_block_sptr(p); } /* @@ -94,12 +84,12 @@ namespace gnuradio { * and stashed it away. Fish it out and return it. */ gr::thread::scoped_lock guard(s_mutex); - sptr_map::iterator pos = s_map.find(static_cast<gr::basic_block *>(p)); - if(pos == s_map.end()) - throw std::invalid_argument("sptr_magic: invalid pointer!"); + sptr_map::iterator pos = s_map.find(static_cast<gr::basic_block*>(p)); + if (pos == s_map.end()) + throw std::invalid_argument("sptr_magic: invalid pointer!"); gr::basic_block_sptr sptr = pos->second; s_map.erase(pos); return sptr; - } } +} // namespace gnuradio diff --git a/gnuradio-runtime/lib/sync_block.cc b/gnuradio-runtime/lib/sync_block.cc index e00b80c79e..8597b93b41 100644 --- a/gnuradio-runtime/lib/sync_block.cc +++ b/gnuradio-runtime/lib/sync_block.cc @@ -28,45 +28,40 @@ namespace gr { - sync_block::sync_block(const std::string &name, - io_signature::sptr input_signature, - io_signature::sptr output_signature) +sync_block::sync_block(const std::string& name, + io_signature::sptr input_signature, + io_signature::sptr output_signature) : block(name, input_signature, output_signature) - { +{ set_fixed_rate(true); - } +} - void - sync_block::forecast(int noutput_items, - gr_vector_int &ninput_items_required) - { +void sync_block::forecast(int noutput_items, gr_vector_int& ninput_items_required) +{ unsigned ninputs = ninput_items_required.size(); - for(unsigned i = 0; i < ninputs; i++) - ninput_items_required[i] = fixed_rate_noutput_to_ninput(noutput_items); - } + for (unsigned i = 0; i < ninputs; i++) + ninput_items_required[i] = fixed_rate_noutput_to_ninput(noutput_items); +} - int - sync_block::fixed_rate_noutput_to_ninput(int noutput_items) - { +int sync_block::fixed_rate_noutput_to_ninput(int noutput_items) +{ return noutput_items + history() - 1; - } +} - int - sync_block::fixed_rate_ninput_to_noutput(int ninput_items) - { +int sync_block::fixed_rate_ninput_to_noutput(int ninput_items) +{ return std::max(0, ninput_items - (int)history() + 1); - } +} - int - sync_block::general_work(int noutput_items, - gr_vector_int &ninput_items, - gr_vector_const_void_star &input_items, - gr_vector_void_star &output_items) - { +int sync_block::general_work(int noutput_items, + gr_vector_int& ninput_items, + gr_vector_const_void_star& input_items, + gr_vector_void_star& output_items) +{ int r = work(noutput_items, input_items, output_items); - if(r > 0) - consume_each(r); + if (r > 0) + consume_each(r); return r; - } +} } /* namespace gr */ diff --git a/gnuradio-runtime/lib/sync_decimator.cc b/gnuradio-runtime/lib/sync_decimator.cc index a9c2d1eeff..2c15a982fd 100644 --- a/gnuradio-runtime/lib/sync_decimator.cc +++ b/gnuradio-runtime/lib/sync_decimator.cc @@ -28,45 +28,41 @@ namespace gr { - sync_decimator::sync_decimator(const std::string &name, - io_signature::sptr input_signature, - io_signature::sptr output_signature, - unsigned decimation) +sync_decimator::sync_decimator(const std::string& name, + io_signature::sptr input_signature, + io_signature::sptr output_signature, + unsigned decimation) : sync_block(name, input_signature, output_signature) - { +{ set_decimation(decimation); - } +} - void - sync_decimator::forecast(int noutput_items, gr_vector_int &ninput_items_required) - { +void sync_decimator::forecast(int noutput_items, gr_vector_int& ninput_items_required) +{ unsigned ninputs = ninput_items_required.size(); - for(unsigned i = 0; i < ninputs; i++) - ninput_items_required[i] = fixed_rate_noutput_to_ninput(noutput_items); - } + for (unsigned i = 0; i < ninputs; i++) + ninput_items_required[i] = fixed_rate_noutput_to_ninput(noutput_items); +} - int - sync_decimator::fixed_rate_noutput_to_ninput(int noutput_items) - { +int sync_decimator::fixed_rate_noutput_to_ninput(int noutput_items) +{ return noutput_items * decimation() + history() - 1; - } +} - int - sync_decimator::fixed_rate_ninput_to_noutput(int ninput_items) - { +int sync_decimator::fixed_rate_ninput_to_noutput(int ninput_items) +{ return std::max(0, ninput_items - (int)history() + 1) / decimation(); - } +} - int - sync_decimator::general_work(int noutput_items, - gr_vector_int &ninput_items, - gr_vector_const_void_star &input_items, - gr_vector_void_star &output_items) - { +int sync_decimator::general_work(int noutput_items, + gr_vector_int& ninput_items, + gr_vector_const_void_star& input_items, + gr_vector_void_star& output_items) +{ int r = work(noutput_items, input_items, output_items); - if(r > 0) - consume_each(r * decimation ()); + if (r > 0) + consume_each(r * decimation()); return r; - } +} } /* namespace gr */ diff --git a/gnuradio-runtime/lib/sync_interpolator.cc b/gnuradio-runtime/lib/sync_interpolator.cc index 5721f24f0f..d3c7ac6ef7 100644 --- a/gnuradio-runtime/lib/sync_interpolator.cc +++ b/gnuradio-runtime/lib/sync_interpolator.cc @@ -28,46 +28,41 @@ namespace gr { - sync_interpolator::sync_interpolator(const std::string &name, - io_signature::sptr input_signature, - io_signature::sptr output_signature, - unsigned interpolation) +sync_interpolator::sync_interpolator(const std::string& name, + io_signature::sptr input_signature, + io_signature::sptr output_signature, + unsigned interpolation) : sync_block(name, input_signature, output_signature) - { +{ set_interpolation(interpolation); - } +} - void - sync_interpolator::forecast(int noutput_items, - gr_vector_int &ninput_items_required) - { +void sync_interpolator::forecast(int noutput_items, gr_vector_int& ninput_items_required) +{ unsigned ninputs = ninput_items_required.size(); - for(unsigned i = 0; i < ninputs; i++) - ninput_items_required[i] = fixed_rate_noutput_to_ninput(noutput_items); - } + for (unsigned i = 0; i < ninputs; i++) + ninput_items_required[i] = fixed_rate_noutput_to_ninput(noutput_items); +} - int - sync_interpolator::fixed_rate_noutput_to_ninput(int noutput_items) - { +int sync_interpolator::fixed_rate_noutput_to_ninput(int noutput_items) +{ return noutput_items / interpolation() + history() - 1; - } +} - int - sync_interpolator::fixed_rate_ninput_to_noutput(int ninput_items) - { +int sync_interpolator::fixed_rate_ninput_to_noutput(int ninput_items) +{ return std::max(0, ninput_items - (int)history() + 1) * interpolation(); - } +} - int - sync_interpolator::general_work(int noutput_items, - gr_vector_int &ninput_items, - gr_vector_const_void_star &input_items, - gr_vector_void_star &output_items) - { +int sync_interpolator::general_work(int noutput_items, + gr_vector_int& ninput_items, + gr_vector_const_void_star& input_items, + gr_vector_void_star& output_items) +{ int r = work(noutput_items, input_items, output_items); - if(r > 0) - consume_each(r / interpolation()); + if (r > 0) + consume_each(r / interpolation()); return r; - } +} } /* namespace gr */ diff --git a/gnuradio-runtime/lib/sys_paths.cc b/gnuradio-runtime/lib/sys_paths.cc index f63d7730e4..068a38a51d 100644 --- a/gnuradio-runtime/lib/sys_paths.cc +++ b/gnuradio-runtime/lib/sys_paths.cc @@ -27,54 +27,54 @@ namespace gr { - const char *tmp_path() - { - const char *path; +const char* tmp_path() +{ + const char* path; - //first case, try TMP environment variable + // first case, try TMP environment variable path = getenv("TMP"); - if(path) - return path; + if (path) + return path; - //second case, try P_tmpdir when its defined - #ifdef P_tmpdir - if(P_tmpdir) - return P_tmpdir; - #endif /*P_tmpdir*/ +// second case, try P_tmpdir when its defined +#ifdef P_tmpdir + if (P_tmpdir) + return P_tmpdir; +#endif /*P_tmpdir*/ - //fall-through case, nothing worked + // fall-through case, nothing worked return "/tmp"; - } +} - const char *appdata_path() - { - const char *path; +const char* appdata_path() +{ + const char* path; - //first case, try HOME environment variable (unix) + // first case, try HOME environment variable (unix) path = getenv("HOME"); - if(path) - return path; + if (path) + return path; - //second case, try APPDATA environment variable (windows) + // second case, try APPDATA environment variable (windows) path = getenv("APPDATA"); - if(path) - return path; + if (path) + return path; - //fall-through case, nothing worked + // fall-through case, nothing worked return tmp_path(); - } +} - std::string __userconf_path() - { +std::string __userconf_path() +{ boost::filesystem::path p(appdata_path()); p = p / ".gnuradio"; return p.string(); - } +} - const char *userconf_path() - { +const char* userconf_path() +{ static std::string p(__userconf_path()); return p.c_str(); - } +} -} /* namespace gr */ +} /* namespace gr */ diff --git a/gnuradio-runtime/lib/tagged_stream_block.cc b/gnuradio-runtime/lib/tagged_stream_block.cc index 252a235fbf..1617bb3698 100644 --- a/gnuradio-runtime/lib/tagged_stream_block.cc +++ b/gnuradio-runtime/lib/tagged_stream_block.cc @@ -29,108 +29,104 @@ namespace gr { - tagged_stream_block::tagged_stream_block(const std::string &name, - io_signature::sptr input_signature, - io_signature::sptr output_signature, - const std::string &length_tag_key) +tagged_stream_block::tagged_stream_block(const std::string& name, + io_signature::sptr input_signature, + io_signature::sptr output_signature, + const std::string& length_tag_key) : block(name, input_signature, output_signature), d_length_tag_key(pmt::string_to_symbol(length_tag_key)), d_n_input_items_reqd(input_signature->min_streams(), 0), d_length_tag_key_str(length_tag_key) - { - } - - // This is evil hackery: We trick the scheduler into creating the right number of input items - void - tagged_stream_block::forecast(int noutput_items, - gr_vector_int &ninput_items_required) - { +{ +} + +// This is evil hackery: We trick the scheduler into creating the right number of input +// items +void tagged_stream_block::forecast(int noutput_items, + gr_vector_int& ninput_items_required) +{ unsigned ninputs = ninput_items_required.size(); - for(unsigned i = 0; i < ninputs; i++) { - if (i < d_n_input_items_reqd.size() && d_n_input_items_reqd[i] != 0) { - ninput_items_required[i] = d_n_input_items_reqd[i]; - } - else { - // If there's no item, there's no tag--so there must at least be one! - ninput_items_required[i] = std::max(1, (int)std::floor((double) noutput_items / relative_rate() + 0.5)); - } + for (unsigned i = 0; i < ninputs; i++) { + if (i < d_n_input_items_reqd.size() && d_n_input_items_reqd[i] != 0) { + ninput_items_required[i] = d_n_input_items_reqd[i]; + } else { + // If there's no item, there's no tag--so there must at least be one! + ninput_items_required[i] = std::max( + 1, (int)std::floor((double)noutput_items / relative_rate() + 0.5)); + } } - } - - void - tagged_stream_block::parse_length_tags(const std::vector<std::vector<tag_t> > &tags, - gr_vector_int &n_input_items_reqd) - { - for(unsigned i = 0; i < tags.size(); i++) { - for(unsigned k = 0; k < tags[i].size(); k++) { - if(tags[i][k].key == d_length_tag_key) { - n_input_items_reqd[i] = pmt::to_long(tags[i][k].value); - remove_item_tag(i, tags[i][k]); +} + +void tagged_stream_block::parse_length_tags(const std::vector<std::vector<tag_t>>& tags, + gr_vector_int& n_input_items_reqd) +{ + for (unsigned i = 0; i < tags.size(); i++) { + for (unsigned k = 0; k < tags[i].size(); k++) { + if (tags[i][k].key == d_length_tag_key) { + n_input_items_reqd[i] = pmt::to_long(tags[i][k].value); + remove_item_tag(i, tags[i][k]); + } } - } } - } +} - int - tagged_stream_block::calculate_output_stream_length(const gr_vector_int &ninput_items) - { +int tagged_stream_block::calculate_output_stream_length(const gr_vector_int& ninput_items) +{ int noutput_items = *std::max_element(ninput_items.begin(), ninput_items.end()); return (int)std::floor(relative_rate() * noutput_items + 0.5); - } - - void - tagged_stream_block::update_length_tags(int n_produced, int n_ports) - { - for(int i = 0; i < n_ports; i++) { - add_item_tag(i, nitems_written(i), - d_length_tag_key, - pmt::from_long(n_produced)); +} + +void tagged_stream_block::update_length_tags(int n_produced, int n_ports) +{ + for (int i = 0; i < n_ports; i++) { + add_item_tag(i, nitems_written(i), d_length_tag_key, pmt::from_long(n_produced)); } return; - } +} - bool - tagged_stream_block::check_topology(int ninputs, int /* noutputs */) - { +bool tagged_stream_block::check_topology(int ninputs, int /* noutputs */) +{ d_n_input_items_reqd.resize(ninputs, 0); return true; - } +} - int - tagged_stream_block::general_work(int noutput_items, - gr_vector_int &ninput_items, - gr_vector_const_void_star &input_items, - gr_vector_void_star &output_items) - { - if(d_length_tag_key_str.empty()) { - return work(noutput_items, ninput_items, input_items, output_items); +int tagged_stream_block::general_work(int noutput_items, + gr_vector_int& ninput_items, + gr_vector_const_void_star& input_items, + gr_vector_void_star& output_items) +{ + if (d_length_tag_key_str.empty()) { + return work(noutput_items, ninput_items, input_items, output_items); } // Read TSB tags, unless we... // ...don't have inputs or ... ... we already set it in a previous run. - if(!d_n_input_items_reqd.empty() && d_n_input_items_reqd[0] == 0) { - std::vector<std::vector<tag_t> > tags(input_items.size(), std::vector<tag_t>()); - for(unsigned i = 0; i < input_items.size(); i++) { - get_tags_in_range(tags[i], i, nitems_read(i), nitems_read(i)+1); - } - d_n_input_items_reqd.assign(input_items.size(), -1); - parse_length_tags(tags, d_n_input_items_reqd); + if (!d_n_input_items_reqd.empty() && d_n_input_items_reqd[0] == 0) { + std::vector<std::vector<tag_t>> tags(input_items.size(), std::vector<tag_t>()); + for (unsigned i = 0; i < input_items.size(); i++) { + get_tags_in_range(tags[i], i, nitems_read(i), nitems_read(i) + 1); + } + d_n_input_items_reqd.assign(input_items.size(), -1); + parse_length_tags(tags, d_n_input_items_reqd); } - for(unsigned i = 0; i < input_items.size(); i++) { - if(d_n_input_items_reqd[i] == -1) { - GR_LOG_FATAL(d_logger, boost::format("Missing a required length tag on port %1% at item #%2%") % i % nitems_read(i)); - throw std::runtime_error("Missing length tag."); - } - if(d_n_input_items_reqd[i] > ninput_items[i]) { - return 0; - } + for (unsigned i = 0; i < input_items.size(); i++) { + if (d_n_input_items_reqd[i] == -1) { + GR_LOG_FATAL( + d_logger, + boost::format("Missing a required length tag on port %1% at item #%2%") % + i % nitems_read(i)); + throw std::runtime_error("Missing length tag."); + } + if (d_n_input_items_reqd[i] > ninput_items[i]) { + return 0; + } } int min_output_size = calculate_output_stream_length(d_n_input_items_reqd); - if(noutput_items < min_output_size) { - set_min_noutput_items(min_output_size); - return 0; + if (noutput_items < min_output_size) { + set_min_noutput_items(min_output_size); + return 0; } set_min_noutput_items(1); @@ -138,19 +134,19 @@ namespace gr { int n_produced = work(noutput_items, d_n_input_items_reqd, input_items, output_items); ////////////////////// - if(n_produced == WORK_DONE) { - return n_produced; + if (n_produced == WORK_DONE) { + return n_produced; } - for(int i = 0; i < (int) d_n_input_items_reqd.size(); i++) { - consume(i, d_n_input_items_reqd[i]); + for (int i = 0; i < (int)d_n_input_items_reqd.size(); i++) { + consume(i, d_n_input_items_reqd[i]); } if (n_produced > 0) { - update_length_tags(n_produced, output_items.size()); + update_length_tags(n_produced, output_items.size()); } d_n_input_items_reqd.assign(input_items.size(), 0); return n_produced; - } +} -} /* namespace gr */ +} /* namespace gr */ diff --git a/gnuradio-runtime/lib/test.cc b/gnuradio-runtime/lib/test.cc index 37da40e641..04fe8a30d6 100644 --- a/gnuradio-runtime/lib/test.cc +++ b/gnuradio-runtime/lib/test.cc @@ -32,150 +32,169 @@ namespace gr { - test_sptr - make_test(const std::string &name, - int min_inputs, int max_inputs, unsigned int sizeof_input_item, - int min_outputs, int max_outputs, unsigned int sizeof_output_item, - unsigned int history, unsigned int output_multiple, double relative_rate, - bool fixed_rate, consume_type_t cons_type, produce_type_t prod_type) - { - return gnuradio::get_initial_sptr - (new test(name, min_inputs, max_inputs, sizeof_input_item, - min_outputs, max_outputs, sizeof_output_item, - history, output_multiple, relative_rate, - fixed_rate,cons_type, prod_type)); - } +test_sptr make_test(const std::string& name, + int min_inputs, + int max_inputs, + unsigned int sizeof_input_item, + int min_outputs, + int max_outputs, + unsigned int sizeof_output_item, + unsigned int history, + unsigned int output_multiple, + double relative_rate, + bool fixed_rate, + consume_type_t cons_type, + produce_type_t prod_type) +{ + return gnuradio::get_initial_sptr(new test(name, + min_inputs, + max_inputs, + sizeof_input_item, + min_outputs, + max_outputs, + sizeof_output_item, + history, + output_multiple, + relative_rate, + fixed_rate, + cons_type, + prod_type)); +} - test::test(const std::string &name, - int min_inputs, int max_inputs, - unsigned int sizeof_input_item, - int min_outputs, int max_outputs, - unsigned int sizeof_output_item, - unsigned int history, - unsigned int output_multiple, - double relative_rate, - bool fixed_rate, - consume_type_t cons_type, produce_type_t prod_type) - : block (name, - io_signature::make(min_inputs, max_inputs, sizeof_input_item), - io_signature::make(min_outputs, max_outputs, sizeof_output_item)), - d_sizeof_input_item(sizeof_input_item), - d_sizeof_output_item(sizeof_output_item), - d_check_topology(true), - d_consume_type(cons_type), - d_min_consume(0), - d_max_consume(0), - d_produce_type(prod_type), - d_min_produce(0), - d_max_produce(0) - { +test::test(const std::string& name, + int min_inputs, + int max_inputs, + unsigned int sizeof_input_item, + int min_outputs, + int max_outputs, + unsigned int sizeof_output_item, + unsigned int history, + unsigned int output_multiple, + double relative_rate, + bool fixed_rate, + consume_type_t cons_type, + produce_type_t prod_type) + : block(name, + io_signature::make(min_inputs, max_inputs, sizeof_input_item), + io_signature::make(min_outputs, max_outputs, sizeof_output_item)), + d_sizeof_input_item(sizeof_input_item), + d_sizeof_output_item(sizeof_output_item), + d_check_topology(true), + d_consume_type(cons_type), + d_min_consume(0), + d_max_consume(0), + d_produce_type(prod_type), + d_min_produce(0), + d_max_produce(0) +{ set_history(history); set_output_multiple(output_multiple); set_relative_rate(relative_rate); set_fixed_rate(fixed_rate); - } +} - int - test::general_work(int noutput_items, - gr_vector_int &ninput_items, - gr_vector_const_void_star &input_items, - gr_vector_void_star &output_items) - { - //touch all inputs and outputs to detect segfaults - unsigned ninputs = input_items.size (); - unsigned noutputs= output_items.size(); - for(unsigned i = 0; i < ninputs; i++) { - char * in=(char *)input_items[i]; - if(ninput_items[i]< (int)(noutput_items+history())) { - std::cerr << "ERROR: ninput_items[" << i << "] < noutput_items+history()" << std::endl; - std::cerr << "ninput_items[" << i << "] = " << ninput_items[i] << std::endl; - std::cerr << "noutput_items+history() = " << noutput_items+history() << std::endl; - std::cerr << "noutput_items = " << noutput_items << std::endl; - std::cerr << "history() = " << history() << std::endl; - throw std::runtime_error ("test"); - } - else { - for (int j = 0; j < ninput_items[i]; j++) { - //Touch every available input_item - //We use a class variable to avoid the compiler to optimize this away - for(unsigned int k = 0; k < d_sizeof_input_item; k++) - d_temp= in[j*d_sizeof_input_item+k]; +int test::general_work(int noutput_items, + gr_vector_int& ninput_items, + gr_vector_const_void_star& input_items, + gr_vector_void_star& output_items) +{ + // touch all inputs and outputs to detect segfaults + unsigned ninputs = input_items.size(); + unsigned noutputs = output_items.size(); + for (unsigned i = 0; i < ninputs; i++) { + char* in = (char*)input_items[i]; + if (ninput_items[i] < (int)(noutput_items + history())) { + std::cerr << "ERROR: ninput_items[" << i << "] < noutput_items+history()" + << std::endl; + std::cerr << "ninput_items[" << i << "] = " << ninput_items[i] << std::endl; + std::cerr << "noutput_items+history() = " << noutput_items + history() + << std::endl; + std::cerr << "noutput_items = " << noutput_items << std::endl; + std::cerr << "history() = " << history() << std::endl; + throw std::runtime_error("test"); + } else { + for (int j = 0; j < ninput_items[i]; j++) { + // Touch every available input_item + // We use a class variable to avoid the compiler to optimize this away + for (unsigned int k = 0; k < d_sizeof_input_item; k++) + d_temp = in[j * d_sizeof_input_item + k]; + } + switch (d_consume_type) { + case CONSUME_NOUTPUT_ITEMS: + consume(i, noutput_items); + break; + case CONSUME_NOUTPUT_ITEMS_LIMIT_MAX: + consume(i, std::min(noutput_items, d_max_consume)); + break; + case CONSUME_NOUTPUT_ITEMS_LIMIT_MIN: + consume( + i, std::min(std::max(noutput_items, d_min_consume), ninput_items[i])); + break; + case CONSUME_ALL_AVAILABLE: + consume(i, ninput_items[i]); + break; + case CONSUME_ALL_AVAILABLE_LIMIT_MAX: + consume(i, std::min(ninput_items[i], d_max_consume)); + break; + /* //This could result in segfault, uncomment if you want to test + this case CONSUME_ALL_AVAILABLE_LIMIT_MIN: + consume(i,std::max(ninput_items[i],d_max_consume)); + break;*/ + case CONSUME_ZERO: + consume(i, 0); + break; + case CONSUME_ONE: + consume(i, 1); + break; + case CONSUME_MINUS_ONE: + consume(i, -1); + break; + default: + consume(i, noutput_items); + } } - switch(d_consume_type){ - case CONSUME_NOUTPUT_ITEMS: - consume(i,noutput_items); - break; - case CONSUME_NOUTPUT_ITEMS_LIMIT_MAX: - consume(i,std::min(noutput_items,d_max_consume)); - break; - case CONSUME_NOUTPUT_ITEMS_LIMIT_MIN: - consume(i,std::min(std::max(noutput_items,d_min_consume),ninput_items[i])); - break; - case CONSUME_ALL_AVAILABLE: - consume(i,ninput_items[i]); - break; - case CONSUME_ALL_AVAILABLE_LIMIT_MAX: - consume(i,std::min(ninput_items[i],d_max_consume)); - break; -/* //This could result in segfault, uncomment if you want to test this - case CONSUME_ALL_AVAILABLE_LIMIT_MIN: - consume(i,std::max(ninput_items[i],d_max_consume)); - break;*/ - case CONSUME_ZERO: - consume(i,0); - break; - case CONSUME_ONE: - consume(i,1); - break; - case CONSUME_MINUS_ONE: - consume(i,-1); - break; - default: - consume(i,noutput_items); - } - } } - for(unsigned i = 0; i < noutputs; i++) { - char * out=(char *)output_items[i]; - { - for(int j=0;j<noutput_items;j++) { - //Touch every available output_item - for(unsigned int k=0;k<d_sizeof_output_item;k++) - out[j*d_sizeof_input_item+k]=0; + for (unsigned i = 0; i < noutputs; i++) { + char* out = (char*)output_items[i]; + { + for (int j = 0; j < noutput_items; j++) { + // Touch every available output_item + for (unsigned int k = 0; k < d_sizeof_output_item; k++) + out[j * d_sizeof_input_item + k] = 0; + } } - } } - //Now copy input to output until max ninputs or max noutputs is reached - int common_nports=std::min(ninputs,noutputs); - if(d_sizeof_output_item==d_sizeof_input_item) - for(int i = 0; i < common_nports; i++) { - memcpy(output_items[i],input_items[i],noutput_items*d_sizeof_input_item); - } - int noutput_items_produced=0; - switch(d_produce_type) { + // Now copy input to output until max ninputs or max noutputs is reached + int common_nports = std::min(ninputs, noutputs); + if (d_sizeof_output_item == d_sizeof_input_item) + for (int i = 0; i < common_nports; i++) { + memcpy(output_items[i], input_items[i], noutput_items * d_sizeof_input_item); + } + int noutput_items_produced = 0; + switch (d_produce_type) { case PRODUCE_NOUTPUT_ITEMS: - noutput_items_produced=noutput_items; - break; + noutput_items_produced = noutput_items; + break; case PRODUCE_NOUTPUT_ITEMS_LIMIT_MAX: - noutput_items_produced=std::min(noutput_items,d_max_produce); - break; -/* //This could result in segfault, uncomment if you want to test this - case PRODUCE_NOUTPUT_ITEMS_LIMIT_MIN: - noutput_items_produced=std::max(noutput_items,d_min_produce); - break;*/ + noutput_items_produced = std::min(noutput_items, d_max_produce); + break; + /* //This could result in segfault, uncomment if you want to test this + case PRODUCE_NOUTPUT_ITEMS_LIMIT_MIN: + noutput_items_produced=std::max(noutput_items,d_min_produce); + break;*/ case PRODUCE_ZERO: - noutput_items_produced=0; - break; + noutput_items_produced = 0; + break; case PRODUCE_ONE: - noutput_items_produced=1; - break; + noutput_items_produced = 1; + break; case PRODUCE_MINUS_ONE: - noutput_items_produced=-1; - break; + noutput_items_produced = -1; + break; default: - noutput_items_produced=noutput_items; + noutput_items_produced = noutput_items; } return noutput_items_produced; - } +} } /* namespace gr */ diff --git a/gnuradio-runtime/lib/test.h b/gnuradio-runtime/lib/test.h index a8019bc3b7..51e17ac49a 100644 --- a/gnuradio-runtime/lib/test.h +++ b/gnuradio-runtime/lib/test.h @@ -30,41 +30,47 @@ namespace gr { - class test; - typedef boost::shared_ptr<test> test_sptr; - - // public constructor - GR_RUNTIME_API test_sptr - make_test(const std::string &name=std::string("test"), - int min_inputs=1, int max_inputs=1, unsigned int sizeof_input_item=1, - int min_outputs=1, int max_outputs=1, unsigned int sizeof_output_item=1, - unsigned int history=1,unsigned int output_multiple=1,double relative_rate=1.0, - bool fixed_rate=true,consume_type_t cons_type=CONSUME_NOUTPUT_ITEMS, - produce_type_t prod_type=PRODUCE_NOUTPUT_ITEMS); - - /*! - * \brief Test class for testing runtime system (setting up buffers and such.) - * \ingroup misc - * - * This block does not do any useful actual data processing. It - * just exposes setting all standard block parameters using the - * constructor or public methods. - * - * This block can be useful when testing the runtime system. - * You can force this block to have a large history, decimation - * factor and/or large output_multiple. - * The runtime system should detect this and create large enough buffers - * all through the signal chain. - */ - class GR_RUNTIME_API test : public block - { - public: +class test; +typedef boost::shared_ptr<test> test_sptr; + +// public constructor +GR_RUNTIME_API test_sptr make_test(const std::string& name = std::string("test"), + int min_inputs = 1, + int max_inputs = 1, + unsigned int sizeof_input_item = 1, + int min_outputs = 1, + int max_outputs = 1, + unsigned int sizeof_output_item = 1, + unsigned int history = 1, + unsigned int output_multiple = 1, + double relative_rate = 1.0, + bool fixed_rate = true, + consume_type_t cons_type = CONSUME_NOUTPUT_ITEMS, + produce_type_t prod_type = PRODUCE_NOUTPUT_ITEMS); + +/*! + * \brief Test class for testing runtime system (setting up buffers and such.) + * \ingroup misc + * + * This block does not do any useful actual data processing. It + * just exposes setting all standard block parameters using the + * constructor or public methods. + * + * This block can be useful when testing the runtime system. + * You can force this block to have a large history, decimation + * factor and/or large output_multiple. + * The runtime system should detect this and create large enough buffers + * all through the signal chain. + */ +class GR_RUNTIME_API test : public block +{ +public: ~test() {} int general_work(int noutput_items, - gr_vector_int &ninput_items, - gr_vector_const_void_star &input_items, - gr_vector_void_star &output_items); + gr_vector_int& ninput_items, + gr_vector_const_void_star& input_items, + gr_vector_void_star& output_items); // ---------------------------------------------------------------- // override these to define your behavior @@ -80,12 +86,12 @@ namespace gr { * number of data items required on each input stream. The * estimate doesn't have to be exact, but should be close. */ - void forecast(int noutput_items, - gr_vector_int &ninput_items_required) + void forecast(int noutput_items, gr_vector_int& ninput_items_required) { - unsigned ninputs = ninput_items_required.size(); - for(unsigned i = 0; i < ninputs; i++) - ninput_items_required[i] = (int)((double)noutput_items / relative_rate()) + (int)history(); + unsigned ninputs = ninput_items_required.size(); + for (unsigned i = 0; i < ninputs; i++) + ninput_items_required[i] = + (int)((double)noutput_items / relative_rate()) + (int)history(); } /*! @@ -94,9 +100,7 @@ namespace gr { * \param check_topology value to return when check_topology is * called (true or false) default check_topology returns true */ - void set_check_topology(bool check_topology) { - d_check_topology=check_topology; - } + void set_check_topology(bool check_topology) { d_check_topology = check_topology; } /*! * \brief Confirm that ninputs and noutputs is an acceptable combination. @@ -111,9 +115,7 @@ namespace gr { * This check is in addition to the constraints specified by the * input and output gr::io_signatures. */ - bool check_topology(int ninputs, int noutputs) { - return d_check_topology; - } + bool check_topology(int ninputs, int noutputs) { return d_check_topology; } // ---------------------------------------------------------------- /* @@ -129,8 +131,9 @@ namespace gr { * returns true. Generally speaking, you don't need to override * this. */ - int fixed_rate_ninput_to_noutput(int ninput) { - return (int)((double)ninput/relative_rate()); + int fixed_rate_ninput_to_noutput(int ninput) + { + return (int)((double)ninput / relative_rate()); } /*! @@ -138,26 +141,23 @@ namespace gr { * required to produce noutput. N.B. this is only defined if * fixed_rate returns true. */ - int fixed_rate_noutput_to_ninput(int noutput) { - return (int)((double)noutput*relative_rate()); + int fixed_rate_noutput_to_ninput(int noutput) + { + return (int)((double)noutput * relative_rate()); } /*! * \brief Set if fixed rate should return true. * N.B. This is normally a private method but we make it available here as public. */ - void set_fixed_rate_public(bool fixed_rate) { - set_fixed_rate(fixed_rate); - } + void set_fixed_rate_public(bool fixed_rate) { set_fixed_rate(fixed_rate); } /*! * \brief Set the consume pattern. * * \param cons_type which consume pattern to use */ - void set_consume_type(consume_type_t cons_type) { - d_consume_type=cons_type; - } + void set_consume_type(consume_type_t cons_type) { d_consume_type = cons_type; } /*! * \brief Set the consume limit. @@ -165,8 +165,10 @@ namespace gr { * \param limit min or maximum items to consume (depending on * consume_type) */ - void set_consume_limit(unsigned int limit) { - d_min_consume=limit; d_max_consume=limit; + void set_consume_limit(unsigned int limit) + { + d_min_consume = limit; + d_max_consume = limit; } /*! @@ -174,9 +176,7 @@ namespace gr { * * \param prod_type which produce pattern to use */ - void set_produce_type(produce_type_t prod_type) { - d_produce_type=prod_type; - } + void set_produce_type(produce_type_t prod_type) { d_produce_type = prod_type; } /*! * \brief Set the produce limit. @@ -184,13 +184,15 @@ namespace gr { * \param limit min or maximum items to produce (depending on * produce_type) */ - void set_produce_limit(unsigned int limit) { - d_min_produce=limit; d_max_produce=limit; + void set_produce_limit(unsigned int limit) + { + d_min_produce = limit; + d_max_produce = limit; } // ---------------------------------------------------------------------------- - protected: +protected: unsigned int d_sizeof_input_item; unsigned int d_sizeof_output_item; bool d_check_topology; @@ -201,16 +203,26 @@ namespace gr { produce_type_t d_produce_type; int d_min_produce; int d_max_produce; - test(const std::string &name,int min_inputs, int max_inputs, + test(const std::string& name, + int min_inputs, + int max_inputs, unsigned int sizeof_input_item, - int min_outputs, int max_outputs, unsigned int sizeof_output_item, - unsigned int history, unsigned int output_multiple, double relative_rate, - bool fixed_rate, consume_type_t cons_type, produce_type_t prod_type); - - friend GR_RUNTIME_API test_sptr make_test(const std::string &name, - int min_inputs, int max_inputs, + int min_outputs, + int max_outputs, + unsigned int sizeof_output_item, + unsigned int history, + unsigned int output_multiple, + double relative_rate, + bool fixed_rate, + consume_type_t cons_type, + produce_type_t prod_type); + + friend GR_RUNTIME_API test_sptr make_test(const std::string& name, + int min_inputs, + int max_inputs, unsigned int sizeof_input_item, - int min_outputs, int max_outputs, + int min_outputs, + int max_outputs, unsigned int sizeof_output_item, unsigned int history, unsigned int output_multiple, @@ -218,7 +230,7 @@ namespace gr { bool fixed_rate, consume_type_t cons_type, produce_type_t prod_type); - }; +}; } /* namespace gr */ diff --git a/gnuradio-runtime/lib/test_types.h b/gnuradio-runtime/lib/test_types.h index 868a9e62a3..5b59fde8f3 100644 --- a/gnuradio-runtime/lib/test_types.h +++ b/gnuradio-runtime/lib/test_types.h @@ -25,26 +25,26 @@ namespace gr { - typedef enum { - CONSUME_NOUTPUT_ITEMS=0, - CONSUME_NOUTPUT_ITEMS_LIMIT_MAX=1, - CONSUME_NOUTPUT_ITEMS_LIMIT_MIN=2, - CONSUME_ALL_AVAILABLE=3, - CONSUME_ALL_AVAILABLE_LIMIT_MAX=4, +typedef enum { + CONSUME_NOUTPUT_ITEMS = 0, + CONSUME_NOUTPUT_ITEMS_LIMIT_MAX = 1, + CONSUME_NOUTPUT_ITEMS_LIMIT_MIN = 2, + CONSUME_ALL_AVAILABLE = 3, + CONSUME_ALL_AVAILABLE_LIMIT_MAX = 4, /*CONSUME_ALL_AVAILABLE_LIMIT_MIN=5,*/ - CONSUME_ZERO=6, - CONSUME_ONE=7, - CONSUME_MINUS_ONE=8 - } consume_type_t; + CONSUME_ZERO = 6, + CONSUME_ONE = 7, + CONSUME_MINUS_ONE = 8 +} consume_type_t; - typedef enum { - PRODUCE_NOUTPUT_ITEMS=0, - PRODUCE_NOUTPUT_ITEMS_LIMIT_MAX=1, +typedef enum { + PRODUCE_NOUTPUT_ITEMS = 0, + PRODUCE_NOUTPUT_ITEMS_LIMIT_MAX = 1, /*PRODUCE_NOUTPUT_ITEMS_LIMIT_MIN=2,*/ - PRODUCE_ZERO=6, - PRODUCE_ONE=7, - PRODUCE_MINUS_ONE=8 - } produce_type_t; + PRODUCE_ZERO = 6, + PRODUCE_ONE = 7, + PRODUCE_MINUS_ONE = 8 +} produce_type_t; } /* namespace gr */ diff --git a/gnuradio-runtime/lib/thread/thread.cc b/gnuradio-runtime/lib/thread/thread.cc index 2a5f3f7c02..85240cbee1 100644 --- a/gnuradio-runtime/lib/thread/thread.cc +++ b/gnuradio-runtime/lib/thread/thread.cc @@ -31,219 +31,189 @@ #include <windows.h> namespace gr { - namespace thread { - - gr_thread_t - get_current_thread_id() - { - return GetCurrentThread(); - } - - void - thread_bind_to_processor(int n) - { - std::vector<int> mask(1, n); - thread_bind_to_processor(get_current_thread_id(), mask); - } - - void - thread_bind_to_processor(const std::vector<int> &mask) - { - thread_bind_to_processor(get_current_thread_id(), mask); - } - - void - thread_bind_to_processor(gr_thread_t thread, int n) - { - std::vector<int> mask(1, n); - thread_bind_to_processor(thread, mask); - } - - void - thread_bind_to_processor(gr_thread_t thread, const std::vector<int> &mask) - { - //DWORD_PTR mask = (1 << n); - DWORD_PTR dword_mask = 0; - - std::vector<int> _mask = mask; - std::vector<int>::iterator itr; - for(itr = _mask.begin(); itr != _mask.end(); itr++) +namespace thread { + +gr_thread_t get_current_thread_id() { return GetCurrentThread(); } + +void thread_bind_to_processor(int n) +{ + std::vector<int> mask(1, n); + thread_bind_to_processor(get_current_thread_id(), mask); +} + +void thread_bind_to_processor(const std::vector<int>& mask) +{ + thread_bind_to_processor(get_current_thread_id(), mask); +} + +void thread_bind_to_processor(gr_thread_t thread, int n) +{ + std::vector<int> mask(1, n); + thread_bind_to_processor(thread, mask); +} + +void thread_bind_to_processor(gr_thread_t thread, const std::vector<int>& mask) +{ + // DWORD_PTR mask = (1 << n); + DWORD_PTR dword_mask = 0; + + std::vector<int> _mask = mask; + std::vector<int>::iterator itr; + for (itr = _mask.begin(); itr != _mask.end(); itr++) dword_mask |= (1 << (*itr)); - DWORD_PTR ret = SetThreadAffinityMask(thread, dword_mask); - if(ret == 0) { + DWORD_PTR ret = SetThreadAffinityMask(thread, dword_mask); + if (ret == 0) { std::stringstream s; - s << "thread_bind_to_processor failed with error: " - << GetLastError() << std::endl; + s << "thread_bind_to_processor failed with error: " << GetLastError() + << std::endl; throw std::runtime_error(s.str()); - } } +} - void - thread_unbind() - { - thread_unbind(get_current_thread_id()); - } +void thread_unbind() { thread_unbind(get_current_thread_id()); } - void - thread_unbind(gr_thread_t thread) - { - DWORD_PTR dword_mask = sizeof(DWORD_PTR) - 1; - DWORD_PTR ret = SetThreadAffinityMask(thread, dword_mask); - if(ret == 0) { +void thread_unbind(gr_thread_t thread) +{ + DWORD_PTR dword_mask = sizeof(DWORD_PTR) - 1; + DWORD_PTR ret = SetThreadAffinityMask(thread, dword_mask); + if (ret == 0) { std::stringstream s; - s << "thread_unbind failed with error: " - << GetLastError() << std::endl; + s << "thread_unbind failed with error: " << GetLastError() << std::endl; throw std::runtime_error(s.str()); - } } +} - int - thread_priority(gr_thread_t thread) - { - // Not implemented on Windows - return -1; - } +int thread_priority(gr_thread_t thread) +{ + // Not implemented on Windows + return -1; +} - int - set_thread_priority(gr_thread_t thread, int priority) - { - // Not implemented on Windows - return -1; - } +int set_thread_priority(gr_thread_t thread, int priority) +{ + // Not implemented on Windows + return -1; +} #ifndef __MINGW32__ -#pragma pack(push,8) - typedef struct tagTHREADNAME_INFO - { - DWORD dwType; // Must be 0x1000 - LPCSTR szName; // Pointer to name (in user addr space) - DWORD dwThreadID; // Thread ID (-1 = caller thread) - DWORD dwFlags; // Reserved for future use, must be zero - } THREADNAME_INFO; +#pragma pack(push, 8) +typedef struct tagTHREADNAME_INFO { + DWORD dwType; // Must be 0x1000 + LPCSTR szName; // Pointer to name (in user addr space) + DWORD dwThreadID; // Thread ID (-1 = caller thread) + DWORD dwFlags; // Reserved for future use, must be zero +} THREADNAME_INFO; #pragma pack(pop) - static void - _set_thread_name(gr_thread_t thread, const char* name, DWORD dwThreadId) - { - const DWORD SET_THREAD_NAME_EXCEPTION = 0x406D1388; - - THREADNAME_INFO info; - info.dwType = 0x1000; - info.szName = name; - info.dwThreadID = dwThreadId; - info.dwFlags = 0; - - __try - { - RaiseException(SET_THREAD_NAME_EXCEPTION, 0, sizeof(info)/sizeof(ULONG_PTR), (ULONG_PTR*)&info); - } - __except(EXCEPTION_EXECUTE_HANDLER) - { - } - } - - void - set_thread_name(gr_thread_t thread, std::string name) - { - DWORD dwThreadId = GetThreadId(thread); - if (dwThreadId == 0) +static void _set_thread_name(gr_thread_t thread, const char* name, DWORD dwThreadId) +{ + const DWORD SET_THREAD_NAME_EXCEPTION = 0x406D1388; + + THREADNAME_INFO info; + info.dwType = 0x1000; + info.szName = name; + info.dwThreadID = dwThreadId; + info.dwFlags = 0; + + __try { + RaiseException(SET_THREAD_NAME_EXCEPTION, + 0, + sizeof(info) / sizeof(ULONG_PTR), + (ULONG_PTR*)&info); + } __except (EXCEPTION_EXECUTE_HANDLER) { + } +} + +void set_thread_name(gr_thread_t thread, std::string name) +{ + DWORD dwThreadId = GetThreadId(thread); + if (dwThreadId == 0) return; - if (name.empty()) + if (name.empty()) name = boost::str(boost::format("thread %lu") % dwThreadId); - _set_thread_name(thread, name.c_str(), dwThreadId); - } + _set_thread_name(thread, name.c_str(), dwThreadId); +} #else - void - set_thread_name(gr_thread_t thread, std::string name) - { - /* Not implemented on mingw-w64 */ - } +void set_thread_name(gr_thread_t thread, std::string name) +{ + /* Not implemented on mingw-w64 */ +} #endif /* !__MINGW32__ */ - } /* namespace thread */ +} /* namespace thread */ } /* namespace gr */ -#elif defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__) || \ - defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__GNU__) || \ - defined(__NetBSD__) +#elif defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__) || \ + defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__GNU__) || \ + defined(__NetBSD__) namespace gr { - namespace thread { - - gr_thread_t - get_current_thread_id() - { - // Not implemented on OSX - return NULL; - } - - void - thread_bind_to_processor(int n) - { - // Not implemented on OSX - } - - void - thread_bind_to_processor(gr_thread_t thread, int n) - { - // Not implemented on OSX - } - - void - thread_bind_to_processor(const std::vector<int> &mask) - { - // Not implemented on OSX - } - - void - thread_bind_to_processor(gr_thread_t thread, const std::vector<int> &mask) - { - // Not implemented on OSX - } - - void - thread_unbind() - { - // Not implemented on OSX - } - - void - thread_unbind(gr_thread_t thread) - { - // Not implemented on OSX - } - - int - thread_priority(gr_thread_t thread) - { - sched_param param; - int priority; - int policy; - int ret; - ret = pthread_getschedparam (thread, &policy, ¶m); - priority = param.sched_priority; - return (ret==0)?priority:ret; - } - - int - set_thread_priority(gr_thread_t thread, int priority) - { - int policy; - struct sched_param param; - pthread_getschedparam (thread, &policy, ¶m); - param.sched_priority = priority; - return pthread_setschedparam(thread, policy, ¶m); - } - - void - set_thread_name(gr_thread_t thread, std::string name) - { - // Not implemented on OSX - } - - } /* namespace thread */ +namespace thread { + +gr_thread_t get_current_thread_id() +{ + // Not implemented on OSX + return NULL; +} + +void thread_bind_to_processor(int n) +{ + // Not implemented on OSX +} + +void thread_bind_to_processor(gr_thread_t thread, int n) +{ + // Not implemented on OSX +} + +void thread_bind_to_processor(const std::vector<int>& mask) +{ + // Not implemented on OSX +} + +void thread_bind_to_processor(gr_thread_t thread, const std::vector<int>& mask) +{ + // Not implemented on OSX +} + +void thread_unbind() +{ + // Not implemented on OSX +} + +void thread_unbind(gr_thread_t thread) +{ + // Not implemented on OSX +} + +int thread_priority(gr_thread_t thread) +{ + sched_param param; + int priority; + int policy; + int ret; + ret = pthread_getschedparam(thread, &policy, ¶m); + priority = param.sched_priority; + return (ret == 0) ? priority : ret; +} + +int set_thread_priority(gr_thread_t thread, int priority) +{ + int policy; + struct sched_param param; + pthread_getschedparam(thread, &policy, ¶m); + param.sched_priority = priority; + return pthread_setschedparam(thread, policy, ¶m); +} + +void set_thread_name(gr_thread_t thread, std::string name) +{ + // Not implemented on OSX +} + +} /* namespace thread */ } /* namespace gr */ #else @@ -254,131 +224,116 @@ namespace gr { #include <sys/prctl.h> namespace gr { - namespace thread { - - gr_thread_t - get_current_thread_id() - { - return pthread_self(); - } - - void - thread_bind_to_processor(int n) - { - std::vector<int> mask(1, n); - thread_bind_to_processor(get_current_thread_id(), mask); - } - - void - thread_bind_to_processor(const std::vector<int> &mask) - { - thread_bind_to_processor(get_current_thread_id(), mask); - } - - void - thread_bind_to_processor(gr_thread_t thread, int n) - { - std::vector<int> mask(1, n); - thread_bind_to_processor(thread, mask); - } - - void - thread_bind_to_processor(gr_thread_t thread, const std::vector<int> &mask) - { - cpu_set_t set; - size_t len = sizeof(cpu_set_t); - std::vector<int> _mask = mask; - std::vector<int>::iterator itr; - - CPU_ZERO(&set); - for(itr = _mask.begin(); itr != _mask.end(); itr++) +namespace thread { + +gr_thread_t get_current_thread_id() { return pthread_self(); } + +void thread_bind_to_processor(int n) +{ + std::vector<int> mask(1, n); + thread_bind_to_processor(get_current_thread_id(), mask); +} + +void thread_bind_to_processor(const std::vector<int>& mask) +{ + thread_bind_to_processor(get_current_thread_id(), mask); +} + +void thread_bind_to_processor(gr_thread_t thread, int n) +{ + std::vector<int> mask(1, n); + thread_bind_to_processor(thread, mask); +} + +void thread_bind_to_processor(gr_thread_t thread, const std::vector<int>& mask) +{ + cpu_set_t set; + size_t len = sizeof(cpu_set_t); + std::vector<int> _mask = mask; + std::vector<int>::iterator itr; + + CPU_ZERO(&set); + for (itr = _mask.begin(); itr != _mask.end(); itr++) CPU_SET(*itr, &set); - int ret = pthread_setaffinity_np(thread, len, &set); - if(ret != 0) { + int ret = pthread_setaffinity_np(thread, len, &set); + if (ret != 0) { std::stringstream s; s << "thread_bind_to_processor failed with error: " << ret << std::endl; throw std::runtime_error(s.str()); - } } +} - void - thread_unbind() - { - thread_unbind(get_current_thread_id()); - } +void thread_unbind() { thread_unbind(get_current_thread_id()); } - void - thread_unbind(gr_thread_t thread) - { - cpu_set_t set; - size_t len = sizeof(cpu_set_t); +void thread_unbind(gr_thread_t thread) +{ + cpu_set_t set; + size_t len = sizeof(cpu_set_t); - CPU_ZERO(&set); - long ncpus = sysconf(_SC_NPROCESSORS_ONLN); - for(long n = 0; n < ncpus; n++) { + CPU_ZERO(&set); + long ncpus = sysconf(_SC_NPROCESSORS_ONLN); + for (long n = 0; n < ncpus; n++) { CPU_SET(n, &set); - } + } - int ret = pthread_setaffinity_np(thread, len, &set); - if(ret != 0) { + int ret = pthread_setaffinity_np(thread, len, &set); + if (ret != 0) { std::stringstream s; s << "thread_unbind failed with error: " << ret << std::endl; throw std::runtime_error(s.str()); - } } - - int - thread_priority(gr_thread_t thread) - { - sched_param param; - int priority; - int policy; - int ret; - ret = pthread_getschedparam (thread, &policy, ¶m); - priority = param.sched_priority; - return (ret==0)?priority:ret; - } - - int - set_thread_priority(gr_thread_t thread, int priority) - { - int policy; - struct sched_param param; - pthread_getschedparam (thread, &policy, ¶m); - param.sched_priority = priority; - return pthread_setschedparam(thread, policy, ¶m); - } - - void - set_thread_name(gr_thread_t thread, std::string name) - { - if (thread != pthread_self()) // Naming another thread is not supported +} + +int thread_priority(gr_thread_t thread) +{ + sched_param param; + int priority; + int policy; + int ret; + ret = pthread_getschedparam(thread, &policy, ¶m); + priority = param.sched_priority; + return (ret == 0) ? priority : ret; +} + +int set_thread_priority(gr_thread_t thread, int priority) +{ + int policy; + struct sched_param param; + pthread_getschedparam(thread, &policy, ¶m); + param.sched_priority = priority; + return pthread_setschedparam(thread, policy, ¶m); +} + +void set_thread_name(gr_thread_t thread, std::string name) +{ + if (thread != pthread_self()) // Naming another thread is not supported return; - if (name.empty()) + if (name.empty()) name = boost::str(boost::format("thread %llu") % ((unsigned long long)thread)); - const int max_len = 16; // Maximum accepted by PR_SET_NAME + const int max_len = 16; // Maximum accepted by PR_SET_NAME - if ((int)name.size() > max_len) // Shorten the name if necessary by taking as many characters from the front - { // so that the unique_id can still fit on the end + if ((int)name.size() > max_len) // Shorten the name if necessary by taking as many + // characters from the front + { // so that the unique_id can still fit on the end int i = name.size() - 1; - for (; i >= 0; --i) - { - std::string s = name.substr(i, 1); - int n = atoi(s.c_str()); - if ((n == 0) && (s != "0")) - break; + for (; i >= 0; --i) { + std::string s = name.substr(i, 1); + int n = atoi(s.c_str()); + if ((n == 0) && (s != "0")) + break; } - name = name.substr(0, std::max(0, max_len - ((int)name.size() - (i + 1)))) + name.substr(i + 1); - } - - prctl(PR_SET_NAME, name.c_str(), 0, 0, 0); + name = name.substr(0, std::max(0, max_len - ((int)name.size() - (i + 1)))) + + name.substr(i + 1); } - } /* namespace thread */ + prctl(PR_SET_NAME, name.c_str(), 0, 0, 0); +} + +} /* namespace thread */ } /* namespace gr */ #endif diff --git a/gnuradio-runtime/lib/thread/thread_body_wrapper.cc b/gnuradio-runtime/lib/thread/thread_body_wrapper.cc index fffa7e4c44..c820414853 100644 --- a/gnuradio-runtime/lib/thread/thread_body_wrapper.cc +++ b/gnuradio-runtime/lib/thread/thread_body_wrapper.cc @@ -32,60 +32,57 @@ #include <stdio.h> namespace gr { - namespace thread { +namespace thread { #if defined(HAVE_PTHREAD_SIGMASK) && defined(HAVE_SIGNAL_H) && !defined(__MINGW32__) - void mask_signals() - { - sigset_t new_set; - int r; +void mask_signals() +{ + sigset_t new_set; + int r; - sigemptyset(&new_set); - sigaddset(&new_set, SIGHUP); // block these... - sigaddset(&new_set, SIGINT); - sigaddset(&new_set, SIGPIPE); - sigaddset(&new_set, SIGALRM); - sigaddset(&new_set, SIGTERM); - sigaddset(&new_set, SIGUSR1); - sigaddset(&new_set, SIGCHLD); + sigemptyset(&new_set); + sigaddset(&new_set, SIGHUP); // block these... + sigaddset(&new_set, SIGINT); + sigaddset(&new_set, SIGPIPE); + sigaddset(&new_set, SIGALRM); + sigaddset(&new_set, SIGTERM); + sigaddset(&new_set, SIGUSR1); + sigaddset(&new_set, SIGCHLD); #ifdef SIGPOLL - sigaddset(&new_set, SIGPOLL); + sigaddset(&new_set, SIGPOLL); #endif #ifdef SIGPROF - sigaddset(&new_set, SIGPROF); + sigaddset(&new_set, SIGPROF); #endif #ifdef SIGSYS - sigaddset(&new_set, SIGSYS); + sigaddset(&new_set, SIGSYS); #endif #ifdef SIGTRAP - sigaddset(&new_set, SIGTRAP); + sigaddset(&new_set, SIGTRAP); #endif #ifdef SIGURG - sigaddset(&new_set, SIGURG); + sigaddset(&new_set, SIGURG); #endif #ifdef SIGVTALRM - sigaddset(&new_set, SIGVTALRM); + sigaddset(&new_set, SIGVTALRM); #endif #ifdef SIGXCPU - sigaddset(&new_set, SIGXCPU); + sigaddset(&new_set, SIGXCPU); #endif #ifdef SIGXFSZ - sigaddset(&new_set, SIGXFSZ); + sigaddset(&new_set, SIGXFSZ); #endif - r = pthread_sigmask(SIG_BLOCK, &new_set, 0); - if(r != 0) + r = pthread_sigmask(SIG_BLOCK, &new_set, 0); + if (r != 0) perror("pthread_sigmask"); - } +} #else - void mask_signals() - { - } +void mask_signals() {} #endif - } /* namespace thread */ +} /* namespace thread */ } /* namespace gr */ - diff --git a/gnuradio-runtime/lib/thread/thread_group.cc b/gnuradio-runtime/lib/thread/thread_group.cc index 637525e19e..1d9b8c846c 100644 --- a/gnuradio-runtime/lib/thread/thread_group.cc +++ b/gnuradio-runtime/lib/thread/thread_group.cc @@ -15,84 +15,86 @@ #include <gnuradio/thread/thread_group.h> namespace gr { - namespace thread { +namespace thread { - thread_group::thread_group() - { - } +thread_group::thread_group() {} - thread_group::~thread_group() - { - // We shouldn't have to scoped_lock here, since referencing this - // object from another thread while we're deleting it in the - // current thread is going to lead to undefined behavior any - // way. - for(std::list<boost::thread*>::iterator it = m_threads.begin(); - it != m_threads.end(); ++it) { +thread_group::~thread_group() +{ + // We shouldn't have to scoped_lock here, since referencing this + // object from another thread while we're deleting it in the + // current thread is going to lead to undefined behavior any + // way. + for (std::list<boost::thread*>::iterator it = m_threads.begin(); + it != m_threads.end(); + ++it) { delete (*it); - } } +} - boost::thread* thread_group::create_thread(const boost::function0<void>& threadfunc) - { - // No scoped_lock required here since the only "shared data" that's - // modified here occurs inside add_thread which does scoped_lock. - std::unique_ptr<boost::thread> thrd(new boost::thread(threadfunc)); - add_thread(thrd.get()); - return thrd.release(); - } +boost::thread* thread_group::create_thread(const boost::function0<void>& threadfunc) +{ + // No scoped_lock required here since the only "shared data" that's + // modified here occurs inside add_thread which does scoped_lock. + std::unique_ptr<boost::thread> thrd(new boost::thread(threadfunc)); + add_thread(thrd.get()); + return thrd.release(); +} - void thread_group::add_thread(boost::thread* thrd) - { - boost::lock_guard<boost::shared_mutex> guard(m_mutex); +void thread_group::add_thread(boost::thread* thrd) +{ + boost::lock_guard<boost::shared_mutex> guard(m_mutex); - // For now we'll simply ignore requests to add a thread object - // multiple times. Should we consider this an error and either - // throw or return an error value? - std::list<boost::thread*>::iterator it = std::find(m_threads.begin(), - m_threads.end(), thrd); - BOOST_ASSERT(it == m_threads.end()); - if(it == m_threads.end()) + // For now we'll simply ignore requests to add a thread object + // multiple times. Should we consider this an error and either + // throw or return an error value? + std::list<boost::thread*>::iterator it = + std::find(m_threads.begin(), m_threads.end(), thrd); + BOOST_ASSERT(it == m_threads.end()); + if (it == m_threads.end()) m_threads.push_back(thrd); - } +} - void thread_group::remove_thread(boost::thread* thrd) - { - boost::lock_guard<boost::shared_mutex> guard(m_mutex); +void thread_group::remove_thread(boost::thread* thrd) +{ + boost::lock_guard<boost::shared_mutex> guard(m_mutex); - // For now we'll simply ignore requests to remove a thread - // object that's not in the group. Should we consider this an - // error and either throw or return an error value? - std::list<boost::thread*>::iterator it = std::find(m_threads.begin(), - m_threads.end(), thrd); - BOOST_ASSERT(it != m_threads.end()); - if(it != m_threads.end()) + // For now we'll simply ignore requests to remove a thread + // object that's not in the group. Should we consider this an + // error and either throw or return an error value? + std::list<boost::thread*>::iterator it = + std::find(m_threads.begin(), m_threads.end(), thrd); + BOOST_ASSERT(it != m_threads.end()); + if (it != m_threads.end()) m_threads.erase(it); - } +} - void thread_group::join_all() - { - boost::shared_lock<boost::shared_mutex> guard(m_mutex); - for(std::list<boost::thread*>::iterator it = m_threads.begin(); - it != m_threads.end(); ++it) { - (*it)->join(); - } +void thread_group::join_all() +{ + boost::shared_lock<boost::shared_mutex> guard(m_mutex); + for (std::list<boost::thread*>::iterator it = m_threads.begin(); + it != m_threads.end(); + ++it) { + (*it)->join(); } +} - void thread_group::interrupt_all() - { - boost::shared_lock<boost::shared_mutex> guard(m_mutex); - for(std::list<boost::thread*>::iterator it=m_threads.begin(),end=m_threads.end(); - it!=end; ++it) { - (*it)->interrupt(); - } +void thread_group::interrupt_all() +{ + boost::shared_lock<boost::shared_mutex> guard(m_mutex); + for (std::list<boost::thread*>::iterator it = m_threads.begin(), + end = m_threads.end(); + it != end; + ++it) { + (*it)->interrupt(); } +} - size_t thread_group::size() const - { - boost::shared_lock<boost::shared_mutex> guard(m_mutex); - return m_threads.size(); - } +size_t thread_group::size() const +{ + boost::shared_lock<boost::shared_mutex> guard(m_mutex); + return m_threads.size(); +} - } /* namespace thread */ +} /* namespace thread */ } /* namespace gr */ diff --git a/gnuradio-runtime/lib/top_block.cc b/gnuradio-runtime/lib/top_block.cc index 7d135083dd..fa3902c735 100644 --- a/gnuradio-runtime/lib/top_block.cc +++ b/gnuradio-runtime/lib/top_block.cc @@ -33,37 +33,33 @@ #include <iostream> namespace gr { - top_block_sptr - make_top_block(const std::string &name) - { - return gnuradio::get_initial_sptr - (new top_block(name)); - } - - top_block::top_block(const std::string &name) - : hier_block2(name, - io_signature::make(0,0,0), - io_signature::make(0,0,0)) - { +top_block_sptr make_top_block(const std::string& name) +{ + return gnuradio::get_initial_sptr(new top_block(name)); +} + +top_block::top_block(const std::string& name) + : hier_block2(name, io_signature::make(0, 0, 0), io_signature::make(0, 0, 0)) +{ d_impl = new top_block_impl(this); - } +} - top_block::~top_block() - { +top_block::~top_block() +{ stop(); wait(); delete d_impl; - } +} - void - top_block::start(int max_noutput_items) - { +void top_block::start(int max_noutput_items) +{ #ifdef GNURADIO_HRT_USE_CLOCK_GETTIME - std::string initial_clock = prefs::singleton()->get_string("PerfCounters", "clock", "thread"); - if(initial_clock.compare("thread") == 0){ + std::string initial_clock = + prefs::singleton()->get_string("PerfCounters", "clock", "thread"); + if (initial_clock.compare("thread") == 0) { gr::high_res_timer_source = CLOCK_THREAD_CPUTIME_ID; - } else if(initial_clock.compare("monotonic") == 0){ + } else if (initial_clock.compare("monotonic") == 0) { gr::high_res_timer_source = CLOCK_MONOTONIC; } else { throw std::runtime_error("bad argument for PerfCounters.clock!"); @@ -72,150 +68,125 @@ namespace gr { d_impl->start(max_noutput_items); - if(prefs::singleton()->get_bool("ControlPort", "on", false)) { - setup_rpc(); + if (prefs::singleton()->get_bool("ControlPort", "on", false)) { + setup_rpc(); } - } - - void - top_block::stop() - { - d_impl->stop(); - } - - void - top_block::wait() - { - d_impl->wait(); - } - - void - top_block::run(int max_noutput_items) - { +} + +void top_block::stop() { d_impl->stop(); } + +void top_block::wait() { d_impl->wait(); } + +void top_block::run(int max_noutput_items) +{ start(max_noutput_items); wait(); - } - - void - top_block::lock() - { - d_impl->lock(); - } - - void - top_block::unlock() - { - d_impl->unlock(); - } - - std::string - top_block::edge_list() - { - return d_impl->edge_list(); - } - - std::string - top_block::msg_edge_list() - { - return d_impl->msg_edge_list(); - } - - void - top_block::dump() - { - d_impl->dump(); - } - - int - top_block::max_noutput_items() - { - return d_impl->max_noutput_items(); - } - - void - top_block::set_max_noutput_items(int nmax) - { - d_impl->set_max_noutput_items(nmax); - } - - top_block_sptr - top_block::to_top_block() - { +} + +void top_block::lock() { d_impl->lock(); } + +void top_block::unlock() { d_impl->unlock(); } + +std::string top_block::edge_list() { return d_impl->edge_list(); } + +std::string top_block::msg_edge_list() { return d_impl->msg_edge_list(); } + +void top_block::dump() { d_impl->dump(); } + +int top_block::max_noutput_items() { return d_impl->max_noutput_items(); } + +void top_block::set_max_noutput_items(int nmax) { d_impl->set_max_noutput_items(nmax); } + +top_block_sptr top_block::to_top_block() +{ return cast_to_top_block_sptr(shared_from_this()); - } +} - void - top_block::setup_rpc() - { +void top_block::setup_rpc() +{ #ifdef GR_CTRLPORT - if(is_rpc_set()) - return; + if (is_rpc_set()) + return; // Triggers - d_rpc_vars.push_back( - rpcbasic_sptr(new rpcbasic_register_trigger<top_block>( - alias(), "stop", &top_block::stop, - "Stop the flowgraph", RPC_PRIVLVL_MIN))); + d_rpc_vars.push_back(rpcbasic_sptr(new rpcbasic_register_trigger<top_block>( + alias(), "stop", &top_block::stop, "Stop the flowgraph", RPC_PRIVLVL_MIN))); - d_rpc_vars.push_back( - rpcbasic_sptr(new rpcbasic_register_trigger<top_block>( - alias(), "lock", &top_block::lock, - "Lock the flowgraph", RPC_PRIVLVL_MIN))); + d_rpc_vars.push_back(rpcbasic_sptr(new rpcbasic_register_trigger<top_block>( + alias(), "lock", &top_block::lock, "Lock the flowgraph", RPC_PRIVLVL_MIN))); - d_rpc_vars.push_back( - rpcbasic_sptr(new rpcbasic_register_trigger<top_block>( - alias(), "unlock", &top_block::unlock, - "Unock the flowgraph", RPC_PRIVLVL_MIN))); + d_rpc_vars.push_back(rpcbasic_sptr(new rpcbasic_register_trigger<top_block>( + alias(), "unlock", &top_block::unlock, "Unock the flowgraph", RPC_PRIVLVL_MIN))); // Getters - add_rpc_variable( - rpcbasic_sptr(new rpcbasic_register_get<top_block, int>( - alias(), "max noutput_items", - &top_block::max_noutput_items, - pmt::mp(0), pmt::mp(8192), pmt::mp(8192), - "items", "Max number of output items", - RPC_PRIVLVL_MIN, DISPNULL))); - - if(prefs::singleton()->get_bool("ControlPort", "edges_list", false)) { - add_rpc_variable( - rpcbasic_sptr(new rpcbasic_register_get<top_block, std::string>( - alias(), "edge list", - &top_block::edge_list, - pmt::mp(""), pmt::mp(""), pmt::mp(""), - "edges", "List of edges in the graph", - RPC_PRIVLVL_MIN, DISPNULL))); + add_rpc_variable(rpcbasic_sptr( + new rpcbasic_register_get<top_block, int>(alias(), + "max noutput_items", + &top_block::max_noutput_items, + pmt::mp(0), + pmt::mp(8192), + pmt::mp(8192), + "items", + "Max number of output items", + RPC_PRIVLVL_MIN, + DISPNULL))); + + if (prefs::singleton()->get_bool("ControlPort", "edges_list", false)) { + add_rpc_variable(rpcbasic_sptr(new rpcbasic_register_get<top_block, std::string>( + alias(), + "edge list", + &top_block::edge_list, + pmt::mp(""), + pmt::mp(""), + pmt::mp(""), + "edges", + "List of edges in the graph", + RPC_PRIVLVL_MIN, + DISPNULL))); } - if(prefs::singleton()->get_bool("ControlPort", "edges_list", false)) { - add_rpc_variable( - rpcbasic_sptr(new rpcbasic_register_get<top_block, std::string>( - alias(), "msg edges list", - &top_block::msg_edge_list, - pmt::mp(""), pmt::mp(""), pmt::mp(""), - "msg_edges", "List of msg edges in the graph", - RPC_PRIVLVL_MIN, DISPNULL))); + if (prefs::singleton()->get_bool("ControlPort", "edges_list", false)) { + add_rpc_variable(rpcbasic_sptr(new rpcbasic_register_get<top_block, std::string>( + alias(), + "msg edges list", + &top_block::msg_edge_list, + pmt::mp(""), + pmt::mp(""), + pmt::mp(""), + "msg_edges", + "List of msg edges in the graph", + RPC_PRIVLVL_MIN, + DISPNULL))); } #ifdef GNURADIO_HRT_USE_CLOCK_GETTIME - add_rpc_variable( - rpcbasic_sptr(new rpcbasic_register_variable_rw<int>( - alias(), "perfcounter_clock", - (int*)&gr::high_res_timer_source, - pmt::mp(0), pmt::mp(2), pmt::mp(2), - "clock", "Performance Counters Realtime Clock Type", - RPC_PRIVLVL_MIN, DISPNULL))); + add_rpc_variable(rpcbasic_sptr( + new rpcbasic_register_variable_rw<int>(alias(), + "perfcounter_clock", + (int*)&gr::high_res_timer_source, + pmt::mp(0), + pmt::mp(2), + pmt::mp(2), + "clock", + "Performance Counters Realtime Clock Type", + RPC_PRIVLVL_MIN, + DISPNULL))); #endif // Setters - add_rpc_variable( - rpcbasic_sptr(new rpcbasic_register_set<top_block, int>( - alias(), "max noutput_items", - &top_block::set_max_noutput_items, - pmt::mp(0), pmt::mp(8192), pmt::mp(8192), - "items", "Max number of output items", - RPC_PRIVLVL_MIN, DISPNULL))); + add_rpc_variable(rpcbasic_sptr( + new rpcbasic_register_set<top_block, int>(alias(), + "max noutput_items", + &top_block::set_max_noutput_items, + pmt::mp(0), + pmt::mp(8192), + pmt::mp(8192), + "items", + "Max number of output items", + RPC_PRIVLVL_MIN, + DISPNULL))); rpc_set(); #endif /* GR_CTRLPORT */ - } +} } /* namespace gr */ diff --git a/gnuradio-runtime/lib/top_block_impl.cc b/gnuradio-runtime/lib/top_block_impl.cc index d2a07e89ef..70b1e3e87c 100644 --- a/gnuradio-runtime/lib/top_block_impl.cc +++ b/gnuradio-runtime/lib/top_block_impl.cc @@ -40,68 +40,66 @@ namespace gr { #define GR_TOP_BLOCK_IMPL_DEBUG 0 - typedef scheduler_sptr(*scheduler_maker)(flat_flowgraph_sptr ffg, - int max_noutput_items); +typedef scheduler_sptr (*scheduler_maker)(flat_flowgraph_sptr ffg, int max_noutput_items); - static struct scheduler_table { - const char *name; +static struct scheduler_table { + const char* name; scheduler_maker f; - } scheduler_table[] = { - { "TPB", scheduler_tpb::make } // first entry is default - }; +} scheduler_table[] = { + { "TPB", scheduler_tpb::make } // first entry is default +}; - static scheduler_sptr - make_scheduler(flat_flowgraph_sptr ffg, int max_noutput_items) - { +static scheduler_sptr make_scheduler(flat_flowgraph_sptr ffg, int max_noutput_items) +{ static scheduler_maker factory = 0; - if(factory == 0) { - char *v = getenv("GR_SCHEDULER"); - if(!v) - factory = scheduler_table[0].f; // use default - else { - for(size_t i = 0; i < sizeof(scheduler_table)/sizeof(scheduler_table[0]); i++) { - if(strcmp(v, scheduler_table[i].name) == 0) { - factory = scheduler_table[i].f; - break; - } + if (factory == 0) { + char* v = getenv("GR_SCHEDULER"); + if (!v) + factory = scheduler_table[0].f; // use default + else { + for (size_t i = 0; i < sizeof(scheduler_table) / sizeof(scheduler_table[0]); + i++) { + if (strcmp(v, scheduler_table[i].name) == 0) { + factory = scheduler_table[i].f; + break; + } + } + if (factory == 0) { + std::cerr << "warning: Invalid GR_SCHEDULER environment variable value \"" + << v << "\". Using \"" << scheduler_table[0].name << "\"\n"; + factory = scheduler_table[0].f; + } } - if(factory == 0) { - std::cerr << "warning: Invalid GR_SCHEDULER environment variable value \"" - << v << "\". Using \"" << scheduler_table[0].name << "\"\n"; - factory = scheduler_table[0].f; - } - } } return factory(ffg, max_noutput_items); - } +} - top_block_impl::top_block_impl(top_block *owner) - : d_owner(owner), d_ffg(), - d_state(IDLE), d_lock_count(0), d_retry_wait(false) - { - } +top_block_impl::top_block_impl(top_block* owner) + : d_owner(owner), d_ffg(), d_state(IDLE), d_lock_count(0), d_retry_wait(false) +{ +} - top_block_impl::~top_block_impl() - { +top_block_impl::~top_block_impl() +{ if (d_lock_count) { - std::cerr << "error: destroying locked block." << std::endl; + std::cerr << "error: destroying locked block." << std::endl; } d_owner = 0; - } +} - void - top_block_impl::start(int max_noutput_items) - { +void top_block_impl::start(int max_noutput_items) +{ gr::thread::scoped_lock l(d_mutex); d_max_noutput_items = max_noutput_items; - if(d_state != IDLE) - throw std::runtime_error("top_block::start: top block already running or wait() not called after previous stop()"); + if (d_state != IDLE) + throw std::runtime_error("top_block::start: top block already running or wait() " + "not called after previous stop()"); - if(d_lock_count > 0) - throw std::runtime_error("top_block::start: can't start with flow graph locked"); + if (d_lock_count > 0) + throw std::runtime_error("top_block::start: can't start with flow graph locked"); // Create new flat flow graph by flattening hierarchy d_ffg = d_owner->flatten(); @@ -112,135 +110,119 @@ namespace gr { // Only export perf. counters if ControlPort config param is // enabled and if the PerfCounter option 'export' is turned on. - prefs *p = prefs::singleton(); - if(p->get_bool("ControlPort", "on", false) && p->get_bool("PerfCounters", "export", false)) - d_ffg->enable_pc_rpc(); + prefs* p = prefs::singleton(); + if (p->get_bool("ControlPort", "on", false) && + p->get_bool("PerfCounters", "export", false)) + d_ffg->enable_pc_rpc(); d_scheduler = make_scheduler(d_ffg, d_max_noutput_items); d_state = RUNNING; - } +} - void - top_block_impl::stop() - { +void top_block_impl::stop() +{ gr::thread::scoped_lock lock(d_mutex); - if(d_scheduler) - d_scheduler->stop(); + if (d_scheduler) + d_scheduler->stop(); d_state = IDLE; - } +} - void - top_block_impl::wait() - { +void top_block_impl::wait() +{ do { - wait_for_jobs(); - { - gr::thread::scoped_lock lock(d_mutex); - if (!d_lock_count) { - if(d_retry_wait) { - d_retry_wait = false; - continue; - } - d_state = IDLE; - break; + wait_for_jobs(); + { + gr::thread::scoped_lock lock(d_mutex); + if (!d_lock_count) { + if (d_retry_wait) { + d_retry_wait = false; + continue; + } + d_state = IDLE; + break; + } + d_lock_cond.wait(lock); } - d_lock_cond.wait(lock); - } - } while(true); - } - - void - top_block_impl::wait_for_jobs() - { - if(d_scheduler) - d_scheduler->wait(); - } - - // N.B. lock() and unlock() cannot be called from a flow graph - // thread or deadlock will occur when reconfiguration happens - void - top_block_impl::lock() - { + } while (true); +} + +void top_block_impl::wait_for_jobs() +{ + if (d_scheduler) + d_scheduler->wait(); +} + +// N.B. lock() and unlock() cannot be called from a flow graph +// thread or deadlock will occur when reconfiguration happens +void top_block_impl::lock() +{ gr::thread::scoped_lock lock(d_mutex); - if(d_scheduler) - d_scheduler->stop(); + if (d_scheduler) + d_scheduler->stop(); d_lock_count++; - } +} - void - top_block_impl::unlock() - { +void top_block_impl::unlock() +{ gr::thread::scoped_lock lock(d_mutex); - if(d_lock_count <= 0) { - d_lock_count = 0; // fix it, then complain - throw std::runtime_error("unpaired unlock() call"); + if (d_lock_count <= 0) { + d_lock_count = 0; // fix it, then complain + throw std::runtime_error("unpaired unlock() call"); } d_lock_count--; - if(d_lock_count > 0 || d_state == IDLE) // nothing to do - return; + if (d_lock_count > 0 || d_state == IDLE) // nothing to do + return; restart(); d_lock_cond.notify_all(); - } - - /* - * restart is called with d_mutex held - */ - void - top_block_impl::restart() - { +} + +/* + * restart is called with d_mutex held + */ +void top_block_impl::restart() +{ wait_for_jobs(); // Create new simple flow graph flat_flowgraph_sptr new_ffg = d_owner->flatten(); - new_ffg->validate(); // check consistency, sanity, etc - new_ffg->merge_connections(d_ffg); // reuse buffers, etc + new_ffg->validate(); // check consistency, sanity, etc + new_ffg->merge_connections(d_ffg); // reuse buffers, etc d_ffg = new_ffg; // Create a new scheduler to execute it d_scheduler = make_scheduler(d_ffg, d_max_noutput_items); d_retry_wait = true; - } +} - std::string - top_block_impl::edge_list() - { - if(d_ffg) - return d_ffg->edge_list(); +std::string top_block_impl::edge_list() +{ + if (d_ffg) + return d_ffg->edge_list(); else - return ""; - } - - std::string - top_block_impl::msg_edge_list() - { - if(d_ffg) - return d_ffg->msg_edge_list(); + return ""; +} + +std::string top_block_impl::msg_edge_list() +{ + if (d_ffg) + return d_ffg->msg_edge_list(); else - return ""; - } - - void - top_block_impl::dump() - { - if(d_ffg) - d_ffg->dump(); - } - - int - top_block_impl::max_noutput_items() - { - return d_max_noutput_items; - } - - void - top_block_impl::set_max_noutput_items(int nmax) - { - d_max_noutput_items = nmax; - } + return ""; +} + +void top_block_impl::dump() +{ + if (d_ffg) + d_ffg->dump(); +} + +int top_block_impl::max_noutput_items() { return d_max_noutput_items; } + +void top_block_impl::set_max_noutput_items(int nmax) { d_max_noutput_items = nmax; } } /* namespace gr */ diff --git a/gnuradio-runtime/lib/top_block_impl.h b/gnuradio-runtime/lib/top_block_impl.h index de0a67b4c1..d31be2fac2 100644 --- a/gnuradio-runtime/lib/top_block_impl.h +++ b/gnuradio-runtime/lib/top_block_impl.h @@ -29,21 +29,21 @@ namespace gr { - /*! - *\brief Abstract implementation details of top_block - * \ingroup internal - * - * The actual implementation of top_block. Separate class allows - * decoupling of changes from dependent classes. - */ - class GR_RUNTIME_API top_block_impl - { - public: - top_block_impl(top_block *owner); +/*! + *\brief Abstract implementation details of top_block + * \ingroup internal + * + * The actual implementation of top_block. Separate class allows + * decoupling of changes from dependent classes. + */ +class GR_RUNTIME_API top_block_impl +{ +public: + top_block_impl(top_block* owner); ~top_block_impl(); // Create and start scheduler threads - void start(int max_noutput_items=100000000); + void start(int max_noutput_items = 100000000); // Signal scheduler threads to stop void stop(); @@ -72,24 +72,24 @@ namespace gr { // Set the maximum number of noutput_items in the flowgraph void set_max_noutput_items(int nmax); - protected: +protected: enum tb_state { IDLE, RUNNING }; - top_block *d_owner; + top_block* d_owner; flat_flowgraph_sptr d_ffg; scheduler_sptr d_scheduler; - gr::thread::mutex d_mutex; // protects d_state and d_lock_count + gr::thread::mutex d_mutex; // protects d_state and d_lock_count tb_state d_state; int d_lock_count; bool d_retry_wait; boost::condition_variable d_lock_cond; int d_max_noutput_items; - private: +private: void restart(); void wait_for_jobs(); - }; +}; } /* namespace gr */ diff --git a/gnuradio-runtime/lib/tpb_detail.cc b/gnuradio-runtime/lib/tpb_detail.cc index cf05c2b102..f5963fc491 100644 --- a/gnuradio-runtime/lib/tpb_detail.cc +++ b/gnuradio-runtime/lib/tpb_detail.cc @@ -30,42 +30,39 @@ namespace gr { - /* - * We assume that no worker threads are ever running when the graph - * structure is being manipulated, thus it's safe for us to poke - * around in our neighbors w/o holding any locks. - */ - void - tpb_detail::notify_upstream(block_detail *d) - { +/* + * We assume that no worker threads are ever running when the graph + * structure is being manipulated, thus it's safe for us to poke + * around in our neighbors w/o holding any locks. + */ +void tpb_detail::notify_upstream(block_detail* d) +{ // For each of our inputs, tell the guy upstream that we've // consumed some input, and that he most likely has more output // buffer space available. - for(size_t i = 0; i < d->d_input.size(); i++) { - // Can you say, "pointer chasing?" - d->d_input[i]->buffer()->link()->detail()->d_tpb.set_output_changed(); + for (size_t i = 0; i < d->d_input.size(); i++) { + // Can you say, "pointer chasing?" + d->d_input[i]->buffer()->link()->detail()->d_tpb.set_output_changed(); } - } +} - void - tpb_detail::notify_downstream(block_detail *d) - { +void tpb_detail::notify_downstream(block_detail* d) +{ // For each of our outputs, tell the guys downstream that they // have new input available. - for(size_t i = 0; i < d->d_output.size(); i++) { - buffer_sptr buf = d->d_output[i]; - for(size_t j = 0, k = buf->nreaders(); j < k; j++) - buf->reader(j)->link()->detail()->d_tpb.set_input_changed(); + for (size_t i = 0; i < d->d_output.size(); i++) { + buffer_sptr buf = d->d_output[i]; + for (size_t j = 0, k = buf->nreaders(); j < k; j++) + buf->reader(j)->link()->detail()->d_tpb.set_input_changed(); } - } +} - void - tpb_detail::notify_neighbors(block_detail *d) - { +void tpb_detail::notify_neighbors(block_detail* d) +{ notify_downstream(d); notify_upstream(d); - } +} } /* namespace gr */ diff --git a/gnuradio-runtime/lib/tpb_thread_body.cc b/gnuradio-runtime/lib/tpb_thread_body.cc index fa9de60ae3..e40c6df16b 100644 --- a/gnuradio-runtime/lib/tpb_thread_body.cc +++ b/gnuradio-runtime/lib/tpb_thread_body.cc @@ -32,150 +32,150 @@ namespace gr { - tpb_thread_body::tpb_thread_body(block_sptr block, gr::thread::barrier_sptr start_sync, int max_noutput_items) +tpb_thread_body::tpb_thread_body(block_sptr block, + gr::thread::barrier_sptr start_sync, + int max_noutput_items) : d_exec(block, max_noutput_items) - { - //std::cerr << "tpb_thread_body: " << block << std::endl; +{ + // std::cerr << "tpb_thread_body: " << block << std::endl; #if defined(_MSC_VER) || defined(__MINGW32__) - #include <windows.h> - thread::set_thread_name(GetCurrentThread(), boost::str(boost::format("%s%d") % block->name() % block->unique_id())); +#include <windows.h> + thread::set_thread_name( + GetCurrentThread(), + boost::str(boost::format("%s%d") % block->name() % block->unique_id())); #else - thread::set_thread_name(pthread_self(), boost::str(boost::format("%s%d") % block->name() % block->unique_id())); + thread::set_thread_name( + pthread_self(), + boost::str(boost::format("%s%d") % block->name() % block->unique_id())); #endif - block_detail *d = block->detail().get(); + block_detail* d = block->detail().get(); block_executor::state s; pmt::pmt_t msg; d->threaded = true; d->thread = gr::thread::get_current_thread_id(); - prefs *p = prefs::singleton(); + prefs* p = prefs::singleton(); size_t max_nmsgs = static_cast<size_t>(p->get_long("DEFAULT", "max_messages", 100)); - // Setup the logger for the scheduler - #undef LOG +// Setup the logger for the scheduler +#undef LOG std::string config_file = p->get_string("LOG", "log_config", ""); std::string log_level = p->get_string("LOG", "log_level", "off"); std::string log_file = p->get_string("LOG", "log_file", ""); GR_LOG_GETLOGGER(LOG, "gr_log.tpb_thread_body"); GR_LOG_SET_LEVEL(LOG, log_level); GR_CONFIG_LOGGER(config_file); - if(log_file.size() > 0) { - if(log_file == "stdout") { - GR_LOG_SET_CONSOLE_APPENDER(LOG, "stdout","gr::log :%p: %c{1} - %m%n"); - } - else if(log_file == "stderr") { - GR_LOG_SET_CONSOLE_APPENDER(LOG, "stderr","gr::log :%p: %c{1} - %m%n"); - } - else { - GR_LOG_SET_FILE_APPENDER(LOG, log_file , true,"%r :%p: %c{1} - %m%n"); - } + if (log_file.size() > 0) { + if (log_file == "stdout") { + GR_LOG_SET_CONSOLE_APPENDER(LOG, "stdout", "gr::log :%p: %c{1} - %m%n"); + } else if (log_file == "stderr") { + GR_LOG_SET_CONSOLE_APPENDER(LOG, "stderr", "gr::log :%p: %c{1} - %m%n"); + } else { + GR_LOG_SET_FILE_APPENDER(LOG, log_file, true, "%r :%p: %c{1} - %m%n"); + } } // Set thread affinity if it was set before fg was started. - if(block->processor_affinity().size() > 0) { - gr::thread::thread_bind_to_processor(d->thread, block->processor_affinity()); + if (block->processor_affinity().size() > 0) { + gr::thread::thread_bind_to_processor(d->thread, block->processor_affinity()); } // Set thread priority if it was set before fg was started - if(block->thread_priority() > 0) { - gr::thread::set_thread_priority(d->thread, block->thread_priority()); + if (block->thread_priority() > 0) { + gr::thread::set_thread_priority(d->thread, block->thread_priority()); } // make sure our block isnt finished block->clear_finished(); start_sync->wait(); - while(1) { - boost::this_thread::interruption_point(); - - d->d_tpb.clear_changed(); - - // handle any queued up messages - BOOST_FOREACH(basic_block::msg_queue_map_t::value_type &i, block->msg_queue) { - // Check if we have a message handler attached before getting - // any messages. This is mostly a protection for the unknown - // startup sequence of the threads. - if(block->has_msg_handler(i.first)) { - while((msg = block->delete_head_nowait(i.first))) { - block->dispatch_msg(i.first,msg); - } - } - else { - // If we don't have a handler but are building up messages, - // prune the queue from the front to keep memory in check. - if(block->nmsgs(i.first) > max_nmsgs){ - GR_LOG_WARN(LOG,"asynchronous message buffer overflowing, dropping message"); - msg = block->delete_head_nowait(i.first); - } + while (1) { + boost::this_thread::interruption_point(); + + d->d_tpb.clear_changed(); + + // handle any queued up messages + BOOST_FOREACH (basic_block::msg_queue_map_t::value_type& i, block->msg_queue) { + // Check if we have a message handler attached before getting + // any messages. This is mostly a protection for the unknown + // startup sequence of the threads. + if (block->has_msg_handler(i.first)) { + while ((msg = block->delete_head_nowait(i.first))) { + block->dispatch_msg(i.first, msg); + } + } else { + // If we don't have a handler but are building up messages, + // prune the queue from the front to keep memory in check. + if (block->nmsgs(i.first) > max_nmsgs) { + GR_LOG_WARN( + LOG, "asynchronous message buffer overflowing, dropping message"); + msg = block->delete_head_nowait(i.first); + } + } } - } - - // run one iteration if we are a connected stream block - if(d->noutputs() >0 || d->ninputs()>0){ - s = d_exec.run_one_iteration(); - } - else { - s = block_executor::BLKD_IN; - // a msg port only block wants to shutdown - if(block->finished()) { - s = block_executor::DONE; + + // run one iteration if we are a connected stream block + if (d->noutputs() > 0 || d->ninputs() > 0) { + s = d_exec.run_one_iteration(); + } else { + s = block_executor::BLKD_IN; + // a msg port only block wants to shutdown + if (block->finished()) { + s = block_executor::DONE; + } } - } - - if(block->finished() && s == block_executor::READY_NO_OUTPUT) { - s = block_executor::DONE; - d->set_done(true); - } - - if(!d->ninputs() && s == block_executor::READY_NO_OUTPUT) { - s = block_executor::BLKD_IN; - } - - switch(s){ - case block_executor::READY: // Tell neighbors we made progress. - d->d_tpb.notify_neighbors(d); - break; - - case block_executor::READY_NO_OUTPUT: // Notify upstream only - d->d_tpb.notify_upstream(d); - break; - - case block_executor::DONE: // Game over. - block->notify_msg_neighbors(); - d->d_tpb.notify_neighbors(d); - return; - - case block_executor::BLKD_IN: // Wait for input. - { - gr::thread::scoped_lock guard(d->d_tpb.mutex); - - if(!d->d_tpb.input_changed) { - boost::system_time const timeout=boost::get_system_time()+ boost::posix_time::milliseconds(250); - d->d_tpb.input_cond.timed_wait(guard, timeout); + + if (block->finished() && s == block_executor::READY_NO_OUTPUT) { + s = block_executor::DONE; + d->set_done(true); } - } - break; - - case block_executor::BLKD_OUT: // Wait for output buffer space. - { - gr::thread::scoped_lock guard(d->d_tpb.mutex); - while(!d->d_tpb.output_changed) { - d->d_tpb.output_cond.wait(guard); + + if (!d->ninputs() && s == block_executor::READY_NO_OUTPUT) { + s = block_executor::BLKD_IN; } - } - break; - default: - throw std::runtime_error("possible memory corruption in scheduler"); - } + switch (s) { + case block_executor::READY: // Tell neighbors we made progress. + d->d_tpb.notify_neighbors(d); + break; + + case block_executor::READY_NO_OUTPUT: // Notify upstream only + d->d_tpb.notify_upstream(d); + break; + + case block_executor::DONE: // Game over. + block->notify_msg_neighbors(); + d->d_tpb.notify_neighbors(d); + return; + + case block_executor::BLKD_IN: // Wait for input. + { + gr::thread::scoped_lock guard(d->d_tpb.mutex); + + if (!d->d_tpb.input_changed) { + boost::system_time const timeout = + boost::get_system_time() + boost::posix_time::milliseconds(250); + d->d_tpb.input_cond.timed_wait(guard, timeout); + } + } break; + + case block_executor::BLKD_OUT: // Wait for output buffer space. + { + gr::thread::scoped_lock guard(d->d_tpb.mutex); + while (!d->d_tpb.output_changed) { + d->d_tpb.output_cond.wait(guard); + } + } break; + + default: + throw std::runtime_error("possible memory corruption in scheduler"); + } } - } +} - tpb_thread_body::~tpb_thread_body() - { - } +tpb_thread_body::~tpb_thread_body() {} } /* namespace gr */ diff --git a/gnuradio-runtime/lib/tpb_thread_body.h b/gnuradio-runtime/lib/tpb_thread_body.h index c500582cf3..c919612281 100644 --- a/gnuradio-runtime/lib/tpb_thread_body.h +++ b/gnuradio-runtime/lib/tpb_thread_body.h @@ -29,21 +29,23 @@ namespace gr { - /*! - * \brief The body of each thread-per-block thread. - * - * One of these is instantiated in its own thread for each block. - * The constructor turns into the main loop which returns when the - * block is done or is interrupted. - */ - class GR_RUNTIME_API tpb_thread_body - { +/*! + * \brief The body of each thread-per-block thread. + * + * One of these is instantiated in its own thread for each block. + * The constructor turns into the main loop which returns when the + * block is done or is interrupted. + */ +class GR_RUNTIME_API tpb_thread_body +{ block_executor d_exec; - public: - tpb_thread_body(block_sptr block, thread::barrier_sptr start_sync, int max_noutput_items=100000); +public: + tpb_thread_body(block_sptr block, + thread::barrier_sptr start_sync, + int max_noutput_items = 100000); ~tpb_thread_body(); - }; +}; } /* namespace gr */ diff --git a/gnuradio-runtime/lib/vmcircbuf.cc b/gnuradio-runtime/lib/vmcircbuf.cc index 05f08ceed4..59e6187b27 100644 --- a/gnuradio-runtime/lib/vmcircbuf.cc +++ b/gnuradio-runtime/lib/vmcircbuf.cc @@ -44,64 +44,59 @@ gr::thread::mutex s_vm_mutex; namespace gr { - static const char *FACTORY_PREF_KEY = "vmcircbuf_default_factory"; +static const char* FACTORY_PREF_KEY = "vmcircbuf_default_factory"; - vmcircbuf::~vmcircbuf() - { - } +vmcircbuf::~vmcircbuf() {} - vmcircbuf_factory::~vmcircbuf_factory() - { - } +vmcircbuf_factory::~vmcircbuf_factory() {} - // ---------------------------------------------------------------- +// ---------------------------------------------------------------- - static vmcircbuf_factory *s_default_factory = 0; +static vmcircbuf_factory* s_default_factory = 0; - vmcircbuf_factory * - vmcircbuf_sysconfig::get_default_factory() - { - if(s_default_factory) - return s_default_factory; +vmcircbuf_factory* vmcircbuf_sysconfig::get_default_factory() +{ + if (s_default_factory) + return s_default_factory; bool verbose = false; - std::vector<gr::vmcircbuf_factory *> all = all_factories (); + std::vector<gr::vmcircbuf_factory*> all = all_factories(); char name[1024]; if (gr::vmcircbuf_prefs::get(FACTORY_PREF_KEY, name, sizeof(name)) >= 0) { - for(unsigned int i = 0; i < all.size (); i++) { - if(strncmp(name, all[i]->name(), strlen(all[i]->name())) == 0) { - s_default_factory = all[i]; - if(verbose) - fprintf(stderr, "gr::vmcircbuf_sysconfig: using %s\n", - s_default_factory->name()); - return s_default_factory; + for (unsigned int i = 0; i < all.size(); i++) { + if (strncmp(name, all[i]->name(), strlen(all[i]->name())) == 0) { + s_default_factory = all[i]; + if (verbose) + fprintf(stderr, + "gr::vmcircbuf_sysconfig: using %s\n", + s_default_factory->name()); + return s_default_factory; + } } - } } // either we don't have a default, or the default named is not in our // list of factories. Find the first factory that works. - if(verbose) - fprintf(stderr, "gr::vmcircbuf_sysconfig: finding a working factory...\n"); + if (verbose) + fprintf(stderr, "gr::vmcircbuf_sysconfig: finding a working factory...\n"); - for(unsigned int i = 0; i < all.size (); i++) { - if(test_factory(all[i], verbose)) { - set_default_factory(all[i]); - return s_default_factory; - } + for (unsigned int i = 0; i < all.size(); i++) { + if (test_factory(all[i], verbose)) { + set_default_factory(all[i]); + return s_default_factory; + } } // We're screwed! fprintf(stderr, "gr::vmcircbuf_sysconfig: unable to find a working factory!\n"); throw std::runtime_error("gr::vmcircbuf_sysconfig"); - } +} - std::vector<vmcircbuf_factory *> - vmcircbuf_sysconfig::all_factories() - { +std::vector<vmcircbuf_factory*> vmcircbuf_sysconfig::all_factories() +{ std::vector<vmcircbuf_factory*> result; result.push_back(gr::vmcircbuf_createfilemapping_factory::singleton()); @@ -109,192 +104,189 @@ namespace gr { result.push_back(gr::vmcircbuf_sysv_shm_factory::singleton()); result.push_back(gr::vmcircbuf_mmap_shm_open_factory::singleton()); #endif - result.push_back (gr::vmcircbuf_mmap_tmpfile_factory::singleton()); + result.push_back(gr::vmcircbuf_mmap_tmpfile_factory::singleton()); return result; - } +} - void - vmcircbuf_sysconfig::set_default_factory(vmcircbuf_factory *f) - { +void vmcircbuf_sysconfig::set_default_factory(vmcircbuf_factory* f) +{ gr::vmcircbuf_prefs::set(FACTORY_PREF_KEY, f->name()); s_default_factory = f; - } +} - // ------------------------------------------------------------------------ - // test code for vmcircbuf factories - // ------------------------------------------------------------------------ +// ------------------------------------------------------------------------ +// test code for vmcircbuf factories +// ------------------------------------------------------------------------ - static void - init_buffer(vmcircbuf *c, int counter, int size) - { - unsigned int *p = (unsigned int*)c->pointer_to_first_copy(); - for(unsigned int i = 0; i < size / sizeof(int); i++) - p[i] = counter + i; - } +static void init_buffer(vmcircbuf* c, int counter, int size) +{ + unsigned int* p = (unsigned int*)c->pointer_to_first_copy(); + for (unsigned int i = 0; i < size / sizeof(int); i++) + p[i] = counter + i; +} - static bool - check_mapping(vmcircbuf *c, int counter, int size, const char *msg, bool verbose) - { +static bool +check_mapping(vmcircbuf* c, int counter, int size, const char* msg, bool verbose) +{ bool ok = true; - if(verbose) - fprintf(stderr, "... %s", msg); + if (verbose) + fprintf(stderr, "... %s", msg); - unsigned int *p1 = (unsigned int *)c->pointer_to_first_copy(); - unsigned int *p2 = (unsigned int *)c->pointer_to_second_copy(); + unsigned int* p1 = (unsigned int*)c->pointer_to_first_copy(); + unsigned int* p2 = (unsigned int*)c->pointer_to_second_copy(); // fprintf(stderr, "p1 = %p, p2 = %p\n", p1, p2); - for(unsigned int i = 0; i < size / sizeof (int); i++) { - if(p1[i] != counter + i) { - ok = false; - if(verbose) - fprintf(stderr, " p1[%d] == %u, expected %u\n", i, p1[i], counter + i); - break; - } - if(p2[i] != counter + i) { - if(verbose) - fprintf(stderr, " p2[%d] == %u, expected %u\n", i, p2[i], counter + i); - ok = false; - break; - } + for (unsigned int i = 0; i < size / sizeof(int); i++) { + if (p1[i] != counter + i) { + ok = false; + if (verbose) + fprintf(stderr, " p1[%d] == %u, expected %u\n", i, p1[i], counter + i); + break; + } + if (p2[i] != counter + i) { + if (verbose) + fprintf(stderr, " p2[%d] == %u, expected %u\n", i, p2[i], counter + i); + ok = false; + break; + } } - if(ok && verbose) { - fprintf(stderr, " OK\n"); + if (ok && verbose) { + fprintf(stderr, " OK\n"); } return ok; - } +} - static const char * - memsize(int size) - { +static const char* memsize(int size) +{ static std::string buf; - if(size >= (1 << 20)) { - buf = str(boost::format("%dMB") % (size / (1 << 20))); - } - else if(size >= (1 << 10)){ - buf = str(boost::format("%dKB") % (size / (1 << 10))); - } - else { - buf = str(boost::format("%d") % size); + if (size >= (1 << 20)) { + buf = str(boost::format("%dMB") % (size / (1 << 20))); + } else if (size >= (1 << 10)) { + buf = str(boost::format("%dKB") % (size / (1 << 10))); + } else { + buf = str(boost::format("%d") % size); } return buf.c_str(); - } +} - static bool - test_a_bunch(vmcircbuf_factory *factory, int n, int size, int *start_ptr, bool verbose) - { +static bool +test_a_bunch(vmcircbuf_factory* factory, int n, int size, int* start_ptr, bool verbose) +{ bool ok = true; std::vector<int> counter(n); std::vector<vmcircbuf*> c(n); int cum_size = 0; - for(int i = 0; i < n; i++) { - counter[i] = *start_ptr; - *start_ptr += size; - if((c[i] = factory->make (size)) == 0) { - if(verbose) - fprintf(stderr, - "Failed to allocate gr::vmcircbuf number %d of size %d (cum = %s)\n", - i + 1, size, memsize(cum_size)); - return false; - } - init_buffer(c[i], counter[i], size); - cum_size += size; + for (int i = 0; i < n; i++) { + counter[i] = *start_ptr; + *start_ptr += size; + if ((c[i] = factory->make(size)) == 0) { + if (verbose) + fprintf( + stderr, + "Failed to allocate gr::vmcircbuf number %d of size %d (cum = %s)\n", + i + 1, + size, + memsize(cum_size)); + return false; + } + init_buffer(c[i], counter[i], size); + cum_size += size; } - for(int i = 0; i < n; i++) { - std::string msg = str(boost::format("test_a_bunch_%dx%s[%d]") % n % memsize(size) % i); - ok &= check_mapping(c[i], counter[i], size, msg.c_str(), verbose); + for (int i = 0; i < n; i++) { + std::string msg = + str(boost::format("test_a_bunch_%dx%s[%d]") % n % memsize(size) % i); + ok &= check_mapping(c[i], counter[i], size, msg.c_str(), verbose); } - for(int i = 0; i < n; i++) { - delete c[i]; - c[i] = 0; + for (int i = 0; i < n; i++) { + delete c[i]; + c[i] = 0; } return ok; - } +} - static bool - standard_tests(vmcircbuf_factory *f, int verbose) - { - if(verbose >= 1) - fprintf(stderr, "Testing %s...\n", f->name()); +static bool standard_tests(vmcircbuf_factory* f, int verbose) +{ + if (verbose >= 1) + fprintf(stderr, "Testing %s...\n", f->name()); bool v = verbose >= 2; int granularity = f->granularity(); int start = 0; bool ok = true; - ok &= test_a_bunch(f, 1, 1 * granularity, &start, v); // 1 x 4KB = 4KB + ok &= test_a_bunch(f, 1, 1 * granularity, &start, v); // 1 x 4KB = 4KB - if(ok) { - ok &= test_a_bunch(f, 64, 4 * granularity, &start, v); // 64 x 16KB = 1MB - ok &= test_a_bunch(f, 4, 4 * (1L << 20), &start, v); // 4 x 4MB = 16MB - // ok &= test_a_bunch(f, 256, 256 * (1L << 10), &start, v); // 256 x 256KB = 64MB + if (ok) { + ok &= test_a_bunch(f, 64, 4 * granularity, &start, v); // 64 x 16KB = 1MB + ok &= test_a_bunch(f, 4, 4 * (1L << 20), &start, v); // 4 x 4MB = 16MB + // ok &= test_a_bunch(f, 256, 256 * (1L << 10), &start, v); // 256 x 256KB = + // 64MB } - if(verbose >= 1) - fprintf(stderr, "....... %s: %s", f->name(), ok ? "OK\n" : "Doesn't work\n"); + if (verbose >= 1) + fprintf(stderr, "....... %s: %s", f->name(), ok ? "OK\n" : "Doesn't work\n"); return ok; - } +} - bool - vmcircbuf_sysconfig::test_factory(vmcircbuf_factory *f, int verbose) - { +bool vmcircbuf_sysconfig::test_factory(vmcircbuf_factory* f, int verbose) +{ // Install local signal handlers for SIGSEGV and SIGBUS. // If something goes wrong, these signals may be invoked. #ifdef SIGSEGV - gr::local_sighandler sigsegv (SIGSEGV, gr::local_sighandler::throw_signal); + gr::local_sighandler sigsegv(SIGSEGV, gr::local_sighandler::throw_signal); #endif #ifdef SIGBUS - gr::local_sighandler sigbus (SIGBUS, gr::local_sighandler::throw_signal); + gr::local_sighandler sigbus(SIGBUS, gr::local_sighandler::throw_signal); #endif #ifdef SIGSYS - gr::local_sighandler sigsys (SIGSYS, gr::local_sighandler::throw_signal); + gr::local_sighandler sigsys(SIGSYS, gr::local_sighandler::throw_signal); #endif try { - return standard_tests (f, verbose); - } - catch(gr::signal &sig) { - if(verbose) { - fprintf(stderr, "....... %s: %s", f->name(), "Doesn't work\n"); - fprintf(stderr, - "gr::vmcircbuf_factory::test_factory (%s): caught %s\n", - f->name(), sig.name().c_str()); + return standard_tests(f, verbose); + } catch (gr::signal& sig) { + if (verbose) { + fprintf(stderr, "....... %s: %s", f->name(), "Doesn't work\n"); + fprintf(stderr, + "gr::vmcircbuf_factory::test_factory (%s): caught %s\n", + f->name(), + sig.name().c_str()); + return false; + } + } catch (...) { + if (verbose) { + fprintf(stderr, "....... %s: %s", f->name(), "Doesn't work\n"); + fprintf(stderr, + "gr::vmcircbuf_factory::test_factory (%s): some kind of uncaught " + "exception\n", + f->name()); + } return false; - } - } - catch (...) { - if(verbose) { - fprintf(stderr, "....... %s: %s", f->name(), "Doesn't work\n"); - fprintf(stderr, - "gr::vmcircbuf_factory::test_factory (%s): some kind of uncaught exception\n", - f->name()); - } - return false; } - return false; // never gets here. shut compiler up. - } + return false; // never gets here. shut compiler up. +} - bool - vmcircbuf_sysconfig::test_all_factories(int verbose) - { +bool vmcircbuf_sysconfig::test_all_factories(int verbose) +{ bool ok = false; - std::vector<vmcircbuf_factory *> all = all_factories(); + std::vector<vmcircbuf_factory*> all = all_factories(); - for(unsigned int i = 0; i < all.size (); i++) - ok |= test_factory(all[i], verbose); + for (unsigned int i = 0; i < all.size(); i++) + ok |= test_factory(all[i], verbose); return ok; - } +} } /* namespace gr */ diff --git a/gnuradio-runtime/lib/vmcircbuf.h b/gnuradio-runtime/lib/vmcircbuf.h index f9ed045168..5f3aade585 100644 --- a/gnuradio-runtime/lib/vmcircbuf.h +++ b/gnuradio-runtime/lib/vmcircbuf.h @@ -31,42 +31,41 @@ extern gr::thread::mutex s_vm_mutex; namespace gr { - /*! - * \brief abstract class to implement doubly mapped virtual memory circular buffers - * \ingroup internal - */ - class GR_RUNTIME_API vmcircbuf - { - protected: +/*! + * \brief abstract class to implement doubly mapped virtual memory circular buffers + * \ingroup internal + */ +class GR_RUNTIME_API vmcircbuf +{ +protected: int d_size; - char *d_base; + char* d_base; // CREATORS - vmcircbuf(int size) : d_size(size), d_base(0) {}; + vmcircbuf(int size) : d_size(size), d_base(0){}; - public: +public: virtual ~vmcircbuf(); // ACCESSORS - void *pointer_to_first_copy() const{ return d_base; } - void *pointer_to_second_copy() const{ return d_base + d_size; } - }; - - /*! - * \brief abstract factory for creating circular buffers - */ - class GR_RUNTIME_API vmcircbuf_factory - { - protected: - vmcircbuf_factory() {}; - virtual ~vmcircbuf_factory(); + void* pointer_to_first_copy() const { return d_base; } + void* pointer_to_second_copy() const { return d_base + d_size; } +}; - public: +/*! + * \brief abstract factory for creating circular buffers + */ +class GR_RUNTIME_API vmcircbuf_factory +{ +protected: + vmcircbuf_factory(){}; + virtual ~vmcircbuf_factory(); +public: /*! * \brief return name of this factory */ - virtual const char *name() const = 0; + virtual const char* name() const = 0; /*! * \brief return granularity of mapping, typically equal to page size @@ -78,32 +77,32 @@ namespace gr { * * Call this to create a doubly mapped circular buffer. */ - virtual vmcircbuf *make(int size) = 0; - }; - - /* - * \brief pulls together all implementations of gr::vmcircbuf - */ - class GR_RUNTIME_API vmcircbuf_sysconfig - { - public: + virtual vmcircbuf* make(int size) = 0; +}; + +/* + * \brief pulls together all implementations of gr::vmcircbuf + */ +class GR_RUNTIME_API vmcircbuf_sysconfig +{ +public: /* * \brief return the single instance of the default factory. * * returns the default factory to use if it's already defined, * else find the first working factory and use it. */ - static vmcircbuf_factory *get_default_factory(); + static vmcircbuf_factory* get_default_factory(); - static int granularity() { return get_default_factory()->granularity(); } - static vmcircbuf *make(int size) { return get_default_factory()->make(size); } + static int granularity() { return get_default_factory()->granularity(); } + static vmcircbuf* make(int size) { return get_default_factory()->make(size); } // N.B. not all factories are guaranteed to work. // It's too hard to check everything at config time, so we check at runtime static std::vector<vmcircbuf_factory*> all_factories(); // make this factory the default - static void set_default_factory(vmcircbuf_factory *f); + static void set_default_factory(vmcircbuf_factory* f); /*! * \brief Does this factory really work? @@ -112,7 +111,7 @@ namespace gr { * verbose = 1: names of factories tested and results * verbose = 2: all intermediate results */ - static bool test_factory(vmcircbuf_factory *f, int verbose); + static bool test_factory(vmcircbuf_factory* f, int verbose); /*! * \brief Test all factories, return true if at least one of them works @@ -121,7 +120,7 @@ namespace gr { * verbose = 2: all intermediate results */ static bool test_all_factories(int verbose); - }; +}; } /* namespace gr */ diff --git a/gnuradio-runtime/lib/vmcircbuf_createfilemapping.cc b/gnuradio-runtime/lib/vmcircbuf_createfilemapping.cc index 8d4de28a13..b215fcfa6a 100644 --- a/gnuradio-runtime/lib/vmcircbuf_createfilemapping.cc +++ b/gnuradio-runtime/lib/vmcircbuf_createfilemapping.cc @@ -43,28 +43,26 @@ namespace gr { #ifdef HAVE_CREATEFILEMAPPING - // Print Windows error (could/should be global?) - static void - werror(char *where, DWORD last_error) - { +// Print Windows error (could/should be global?) +static void werror(char* where, DWORD last_error) +{ char buf[1024]; FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, last_error, - 0, // default language + 0, // default language buf, - sizeof(buf)/sizeof(TCHAR), // buffer size + sizeof(buf) / sizeof(TCHAR), // buffer size NULL); fprintf(stderr, "%s: Error %d: %s", where, last_error, buf); return; - } +} #endif - vmcircbuf_createfilemapping::vmcircbuf_createfilemapping(int size) - : gr::vmcircbuf(size) - { +vmcircbuf_createfilemapping::vmcircbuf_createfilemapping(int size) : gr::vmcircbuf(size) +{ #if !defined(HAVE_CREATEFILEMAPPING) fprintf(stderr, "%s: createfilemapping is not available\n", __FUNCTION__); throw std::runtime_error("gr::vmcircbuf_createfilemapping"); @@ -73,136 +71,144 @@ namespace gr { static int s_seg_counter = 0; - if(size <= 0 || (size % gr::pagesize ()) != 0) { - fprintf(stderr, "gr::vmcircbuf_createfilemapping: invalid size = %d\n", size); - throw std::runtime_error ("gr::vmcircbuf_createfilemapping"); + if (size <= 0 || (size % gr::pagesize()) != 0) { + fprintf(stderr, "gr::vmcircbuf_createfilemapping: invalid size = %d\n", size); + throw std::runtime_error("gr::vmcircbuf_createfilemapping"); } - std::string seg_name = str(boost::format("/gnuradio-%d-%d") % getpid() % s_seg_counter); + std::string seg_name = + str(boost::format("/gnuradio-%d-%d") % getpid() % s_seg_counter); - d_handle = CreateFileMapping(INVALID_HANDLE_VALUE, // use paging file - NULL, // default security - PAGE_READWRITE, // read/write access - 0, // max. object size - size, // buffer size - seg_name.c_str()); // name of mapping object + d_handle = CreateFileMapping(INVALID_HANDLE_VALUE, // use paging file + NULL, // default security + PAGE_READWRITE, // read/write access + 0, // max. object size + size, // buffer size + seg_name.c_str()); // name of mapping object s_seg_counter++; - if(d_handle == NULL || d_handle == INVALID_HANDLE_VALUE) { - std::string msg = str(boost::format( - "gr::vmcircbuf_mmap_createfilemapping: CreateFileMapping [%s]") % - seg_name); - werror((char*)msg.c_str(), GetLastError()); - throw std::runtime_error("gr::vmcircbuf_mmap_createfilemapping"); + if (d_handle == NULL || d_handle == INVALID_HANDLE_VALUE) { + std::string msg = + str(boost::format( + "gr::vmcircbuf_mmap_createfilemapping: CreateFileMapping [%s]") % + seg_name); + werror((char*)msg.c_str(), GetLastError()); + throw std::runtime_error("gr::vmcircbuf_mmap_createfilemapping"); } // Allocate virtual memory of the needed size, then free it so we can use it LPVOID first_tmp; - first_tmp = VirtualAlloc( NULL, 2*size, MEM_RESERVE, PAGE_NOACCESS ); - if(first_tmp == NULL) { - werror("gr::vmcircbuf_mmap_createfilemapping: VirtualAlloc", GetLastError()); - CloseHandle(d_handle); // cleanup - throw std::runtime_error("gr::vmcircbuf_mmap_createfilemapping"); + first_tmp = VirtualAlloc(NULL, 2 * size, MEM_RESERVE, PAGE_NOACCESS); + if (first_tmp == NULL) { + werror("gr::vmcircbuf_mmap_createfilemapping: VirtualAlloc", GetLastError()); + CloseHandle(d_handle); // cleanup + throw std::runtime_error("gr::vmcircbuf_mmap_createfilemapping"); } - if(VirtualFree(first_tmp, 0, MEM_RELEASE) == 0) { - werror("gr::vmcircbuf_mmap_createfilemapping: VirtualFree", GetLastError()); - CloseHandle(d_handle); // cleanup - throw std::runtime_error("gr::vmcircbuf_mmap_createfilemapping"); + if (VirtualFree(first_tmp, 0, MEM_RELEASE) == 0) { + werror("gr::vmcircbuf_mmap_createfilemapping: VirtualFree", GetLastError()); + CloseHandle(d_handle); // cleanup + throw std::runtime_error("gr::vmcircbuf_mmap_createfilemapping"); } - d_first_copy = MapViewOfFileEx((HANDLE)d_handle, // handle to map object - FILE_MAP_WRITE, // read/write permission + d_first_copy = MapViewOfFileEx((HANDLE)d_handle, // handle to map object + FILE_MAP_WRITE, // read/write permission + 0, + 0, + size, + first_tmp); + if (d_first_copy != first_tmp) { + werror("gr::vmcircbuf_mmap_createfilemapping: MapViewOfFileEx(1)", + GetLastError()); + CloseHandle(d_handle); // cleanup + throw std::runtime_error("gr::vmcircbuf_mmap_createfilemapping"); + } + + d_second_copy = MapViewOfFileEx((HANDLE)d_handle, // handle to map object + FILE_MAP_WRITE, // read/write permission 0, 0, size, - first_tmp); - if(d_first_copy != first_tmp) { - werror( "gr::vmcircbuf_mmap_createfilemapping: MapViewOfFileEx(1)", GetLastError()); - CloseHandle(d_handle); // cleanup - throw std::runtime_error ("gr::vmcircbuf_mmap_createfilemapping"); - } - - d_second_copy = MapViewOfFileEx((HANDLE)d_handle, // handle to map object - FILE_MAP_WRITE, // read/write permission - 0, - 0, - size, - (char*)first_tmp + size);//(LPVOID) ((char *)d_first_copy + size)); - - if(d_second_copy != (char *)first_tmp + size) { - werror( "gr::vmcircbuf_mmap_createfilemapping: MapViewOfFileEx(2)", GetLastError()); - UnmapViewOfFile(d_first_copy); - CloseHandle(d_handle); // cleanup - throw std::runtime_error ("gr::vmcircbuf_mmap_createfilemapping"); + (char*)first_tmp + + size); //(LPVOID) ((char *)d_first_copy + size)); + + if (d_second_copy != (char*)first_tmp + size) { + werror("gr::vmcircbuf_mmap_createfilemapping: MapViewOfFileEx(2)", + GetLastError()); + UnmapViewOfFile(d_first_copy); + CloseHandle(d_handle); // cleanup + throw std::runtime_error("gr::vmcircbuf_mmap_createfilemapping"); } #ifdef DEBUG - fprintf(stderr,"gr::vmcircbuf_mmap_createfilemapping: contiguous? mmap %p %p %p %p\n", - (char*)d_first_copy, (char*)d_second_copy, size, (char*)d_first_copy + size); + fprintf(stderr, + "gr::vmcircbuf_mmap_createfilemapping: contiguous? mmap %p %p %p %p\n", + (char*)d_first_copy, + (char*)d_second_copy, + size, + (char*)d_first_copy + size); #endif // Now remember the important stuff d_base = (char*)d_first_copy; d_size = size; #endif /*HAVE_CREATEFILEMAPPING*/ - } +} - vmcircbuf_createfilemapping::~vmcircbuf_createfilemapping() - { +vmcircbuf_createfilemapping::~vmcircbuf_createfilemapping() +{ #ifdef HAVE_CREATEFILEMAPPING gr::thread::scoped_lock guard(s_vm_mutex); - if(UnmapViewOfFile(d_first_copy) == 0) { - werror("gr::vmcircbuf_createfilemapping: UnmapViewOfFile(d_first_copy)", GetLastError()); + if (UnmapViewOfFile(d_first_copy) == 0) { + werror("gr::vmcircbuf_createfilemapping: UnmapViewOfFile(d_first_copy)", + GetLastError()); } - d_base=NULL; - if(UnmapViewOfFile(d_second_copy) == 0) { - werror("gr::vmcircbuf_createfilemapping: UnmapViewOfFile(d_second_copy)", GetLastError()); + d_base = NULL; + if (UnmapViewOfFile(d_second_copy) == 0) { + werror("gr::vmcircbuf_createfilemapping: UnmapViewOfFile(d_second_copy)", + GetLastError()); } - //d_second=NULL; + // d_second=NULL; CloseHandle(d_handle); #endif - } +} - // ---------------------------------------------------------------- - // The factory interface - // ---------------------------------------------------------------- +// ---------------------------------------------------------------- +// The factory interface +// ---------------------------------------------------------------- - gr::vmcircbuf_factory *vmcircbuf_createfilemapping_factory::s_the_factory = 0; +gr::vmcircbuf_factory* vmcircbuf_createfilemapping_factory::s_the_factory = 0; - gr::vmcircbuf_factory * - vmcircbuf_createfilemapping_factory::singleton() - { - if(s_the_factory) - return s_the_factory; +gr::vmcircbuf_factory* vmcircbuf_createfilemapping_factory::singleton() +{ + if (s_the_factory) + return s_the_factory; s_the_factory = new vmcircbuf_createfilemapping_factory(); return s_the_factory; - } +} - int - vmcircbuf_createfilemapping_factory::granularity() - { +int vmcircbuf_createfilemapping_factory::granularity() +{ #ifdef HAVE_CREATEFILEMAPPING // return 65536;//TODO, check, is this needed or can we just use gr::pagesize() SYSTEM_INFO system_info; GetSystemInfo(&system_info); - //fprintf(stderr,"win32 AllocationGranularity %p\n",(int)system_info.dwAllocationGranularity); + // fprintf(stderr,"win32 AllocationGranularity + // %p\n",(int)system_info.dwAllocationGranularity); return (int)system_info.dwAllocationGranularity; #else return gr::pagesize(); #endif - } +} - gr::vmcircbuf * - vmcircbuf_createfilemapping_factory::make(int size) - { +gr::vmcircbuf* vmcircbuf_createfilemapping_factory::make(int size) +{ try { - return new vmcircbuf_createfilemapping(size); - } - catch(...) { - return 0; + return new vmcircbuf_createfilemapping(size); + } catch (...) { + return 0; } - } +} } /* namespace gr */ diff --git a/gnuradio-runtime/lib/vmcircbuf_createfilemapping.h b/gnuradio-runtime/lib/vmcircbuf_createfilemapping.h index 0513112f23..f289abcd96 100644 --- a/gnuradio-runtime/lib/vmcircbuf_createfilemapping.h +++ b/gnuradio-runtime/lib/vmcircbuf_createfilemapping.h @@ -32,36 +32,36 @@ namespace gr { - /*! - * \brief concrete class to implement circular buffers with mmap and shm_open - * \ingroup internal - */ - class GR_RUNTIME_API vmcircbuf_createfilemapping : public gr::vmcircbuf - { - public: +/*! + * \brief concrete class to implement circular buffers with mmap and shm_open + * \ingroup internal + */ +class GR_RUNTIME_API vmcircbuf_createfilemapping : public gr::vmcircbuf +{ +public: // CREATORS vmcircbuf_createfilemapping(int size); virtual ~vmcircbuf_createfilemapping(); #ifdef HAVE_CREATEFILEMAPPING - private: +private: HANDLE d_handle; LPVOID d_first_copy; LPVOID d_second_copy; #endif - }; +}; - /*! - * \brief concrete factory for circular buffers built using mmap and shm_open - */ - class GR_RUNTIME_API vmcircbuf_createfilemapping_factory : public gr::vmcircbuf_factory - { - private: - static gr::vmcircbuf_factory *s_the_factory; +/*! + * \brief concrete factory for circular buffers built using mmap and shm_open + */ +class GR_RUNTIME_API vmcircbuf_createfilemapping_factory : public gr::vmcircbuf_factory +{ +private: + static gr::vmcircbuf_factory* s_the_factory; - public: - static gr::vmcircbuf_factory *singleton(); +public: + static gr::vmcircbuf_factory* singleton(); - virtual const char *name() const { return "gr::vmcircbuf_createfilemapping_factory"; } + virtual const char* name() const { return "gr::vmcircbuf_createfilemapping_factory"; } /*! * \brief return granularity of mapping, typically equal to page size @@ -73,8 +73,8 @@ namespace gr { * * Call this to create a doubly mapped circular buffer. */ - virtual gr::vmcircbuf *make(int size); - }; + virtual gr::vmcircbuf* make(int size); +}; } /* namespace gr */ diff --git a/gnuradio-runtime/lib/vmcircbuf_mmap_shm_open.cc b/gnuradio-runtime/lib/vmcircbuf_mmap_shm_open.cc index 919986c608..3eef159d73 100644 --- a/gnuradio-runtime/lib/vmcircbuf_mmap_shm_open.cc +++ b/gnuradio-runtime/lib/vmcircbuf_mmap_shm_open.cc @@ -42,9 +42,8 @@ namespace gr { - vmcircbuf_mmap_shm_open::vmcircbuf_mmap_shm_open(int size) - : gr::vmcircbuf(size) - { +vmcircbuf_mmap_shm_open::vmcircbuf_mmap_shm_open(int size) : gr::vmcircbuf(size) +{ #if !defined(HAVE_MMAP) || !defined(HAVE_SHM_OPEN) fprintf(stderr, "gr::vmcircbuf_mmap_shm_open: mmap or shm_open is not available\n"); throw std::runtime_error("gr::vmcircbuf_mmap_shm_open"); @@ -53,9 +52,9 @@ namespace gr { static int s_seg_counter = 0; - if(size <= 0 || (size % gr::pagesize ()) != 0) { - fprintf(stderr, "gr::vmcircbuf_mmap_shm_open: invalid size = %d\n", size); - throw std::runtime_error("gr::vmcircbuf_mmap_shm_open"); + if (size <= 0 || (size % gr::pagesize()) != 0) { + fprintf(stderr, "gr::vmcircbuf_mmap_shm_open: invalid size = %d\n", size); + throw std::runtime_error("gr::vmcircbuf_mmap_shm_open"); } int shm_fd = -1; @@ -63,82 +62,89 @@ namespace gr { static bool portable_format = true; // open a new named shared memory segment - while(1) { - if(portable_format) { - - // This is the POSIX recommended "portable format". - // Of course the "portable format" doesn't work on some systems... - - snprintf(seg_name, sizeof(seg_name), - "/gnuradio-%d-%d", getpid(), s_seg_counter); - } - else { - - // Where the "portable format" doesn't work, we try building - // a full filesystem pathname pointing into a suitable temporary directory. - - snprintf(seg_name, sizeof(seg_name), - "%s/gnuradio-%d-%d", gr::tmp_path(), getpid(), s_seg_counter); - } - - shm_fd = shm_open(seg_name, O_RDWR | O_CREAT | O_EXCL, 0600); - if(shm_fd == -1 && errno == EACCES && portable_format) { - portable_format = false; - continue; // try again using "non-portable format" - } - - s_seg_counter++; - - if(shm_fd == -1) { - if(errno == EEXIST) // Named segment already exists (shouldn't happen). Try again - continue; - - char msg[1024]; - snprintf(msg, sizeof(msg), "gr::vmcircbuf_mmap_shm_open: shm_open [%s]", seg_name); - perror(msg); - throw std::runtime_error("gr::vmcircbuf_mmap_shm_open"); - } - break; + while (1) { + if (portable_format) { + + // This is the POSIX recommended "portable format". + // Of course the "portable format" doesn't work on some systems... + + snprintf( + seg_name, sizeof(seg_name), "/gnuradio-%d-%d", getpid(), s_seg_counter); + } else { + + // Where the "portable format" doesn't work, we try building + // a full filesystem pathname pointing into a suitable temporary directory. + + snprintf(seg_name, + sizeof(seg_name), + "%s/gnuradio-%d-%d", + gr::tmp_path(), + getpid(), + s_seg_counter); + } + + shm_fd = shm_open(seg_name, O_RDWR | O_CREAT | O_EXCL, 0600); + if (shm_fd == -1 && errno == EACCES && portable_format) { + portable_format = false; + continue; // try again using "non-portable format" + } + + s_seg_counter++; + + if (shm_fd == -1) { + if (errno == + EEXIST) // Named segment already exists (shouldn't happen). Try again + continue; + + char msg[1024]; + snprintf( + msg, sizeof(msg), "gr::vmcircbuf_mmap_shm_open: shm_open [%s]", seg_name); + perror(msg); + throw std::runtime_error("gr::vmcircbuf_mmap_shm_open"); + } + break; } // We've got a new shared memory segment fd open. // Now set it's length to 2x what we really want and mmap it in. - if(ftruncate(shm_fd, (off_t)2 * size) == -1) { - close(shm_fd); // cleanup - perror("gr::vmcircbuf_mmap_shm_open: ftruncate (1)"); - throw std::runtime_error("gr::vmcircbuf_mmap_shm_open"); + if (ftruncate(shm_fd, (off_t)2 * size) == -1) { + close(shm_fd); // cleanup + perror("gr::vmcircbuf_mmap_shm_open: ftruncate (1)"); + throw std::runtime_error("gr::vmcircbuf_mmap_shm_open"); } - void *first_copy = mmap(0, 2 * size, - PROT_READ | PROT_WRITE, MAP_SHARED, - shm_fd, (off_t) 0); + void* first_copy = + mmap(0, 2 * size, PROT_READ | PROT_WRITE, MAP_SHARED, shm_fd, (off_t)0); - if(first_copy == MAP_FAILED) { - close(shm_fd); // cleanup - perror("gr::vmcircbuf_mmap_shm_open: mmap (1)"); - throw std::runtime_error("gr::vmcircbuf_mmap_shm_open"); + if (first_copy == MAP_FAILED) { + close(shm_fd); // cleanup + perror("gr::vmcircbuf_mmap_shm_open: mmap (1)"); + throw std::runtime_error("gr::vmcircbuf_mmap_shm_open"); } // unmap the 2nd half - if(munmap ((char *) first_copy + size, size) == -1) { - close(shm_fd); // cleanup - perror("gr::vmcircbuf_mmap_shm_open: munmap (1)"); - throw std::runtime_error("gr::vmcircbuf_mmap_shm_open"); + if (munmap((char*)first_copy + size, size) == -1) { + close(shm_fd); // cleanup + perror("gr::vmcircbuf_mmap_shm_open: munmap (1)"); + throw std::runtime_error("gr::vmcircbuf_mmap_shm_open"); } // map the first half into the now available hole where the // second half used to be. - void *second_copy = mmap((char*)first_copy + size, size, - PROT_READ | PROT_WRITE, MAP_SHARED, - shm_fd, (off_t)0); - - if(second_copy == MAP_FAILED) { - close(shm_fd); // cleanup - perror("gr::vmcircbuf_mmap_shm_open: mmap (2)"); - throw std::runtime_error("gr::vmcircbuf_mmap_shm_open"); + void* second_copy = mmap((char*)first_copy + size, + size, + PROT_READ | PROT_WRITE, + MAP_SHARED, + shm_fd, + (off_t)0); + + if (second_copy == MAP_FAILED) { + close(shm_fd); // cleanup + perror("gr::vmcircbuf_mmap_shm_open: mmap (2)"); + throw std::runtime_error("gr::vmcircbuf_mmap_shm_open"); } -#if 0 // OS/X doesn't allow you to resize the segment +#if 0 // OS/X doesn't allow you to resize the segment // cut the shared memory segment down to size if(ftruncate(shm_fd, (off_t)size) == -1) { @@ -148,61 +154,54 @@ namespace gr { } #endif - close(shm_fd); // fd no longer needed. The mapping is retained. + close(shm_fd); // fd no longer needed. The mapping is retained. - if(shm_unlink(seg_name) == -1) { // unlink the seg_name. - perror("gr::vmcircbuf_mmap_shm_open: shm_unlink"); - throw std::runtime_error("gr::vmcircbuf_mmap_shm_open"); + if (shm_unlink(seg_name) == -1) { // unlink the seg_name. + perror("gr::vmcircbuf_mmap_shm_open: shm_unlink"); + throw std::runtime_error("gr::vmcircbuf_mmap_shm_open"); } // Now remember the important stuff d_base = (char*)first_copy; d_size = size; #endif - } +} - vmcircbuf_mmap_shm_open::~vmcircbuf_mmap_shm_open() - { +vmcircbuf_mmap_shm_open::~vmcircbuf_mmap_shm_open() +{ #if defined(HAVE_MMAP) gr::thread::scoped_lock guard(s_vm_mutex); - if(munmap (d_base, 2 * d_size) == -1) { - perror("gr::vmcircbuf_mmap_shm_open: munmap (2)"); + if (munmap(d_base, 2 * d_size) == -1) { + perror("gr::vmcircbuf_mmap_shm_open: munmap (2)"); } #endif - } +} - // ---------------------------------------------------------------- - // The factory interface - // ---------------------------------------------------------------- +// ---------------------------------------------------------------- +// The factory interface +// ---------------------------------------------------------------- - gr::vmcircbuf_factory *vmcircbuf_mmap_shm_open_factory::s_the_factory = 0; +gr::vmcircbuf_factory* vmcircbuf_mmap_shm_open_factory::s_the_factory = 0; - gr::vmcircbuf_factory * - vmcircbuf_mmap_shm_open_factory::singleton() - { - if(s_the_factory) - return s_the_factory; +gr::vmcircbuf_factory* vmcircbuf_mmap_shm_open_factory::singleton() +{ + if (s_the_factory) + return s_the_factory; s_the_factory = new gr::vmcircbuf_mmap_shm_open_factory(); return s_the_factory; - } +} - int - vmcircbuf_mmap_shm_open_factory::granularity() - { - return gr::pagesize(); - } +int vmcircbuf_mmap_shm_open_factory::granularity() { return gr::pagesize(); } - gr::vmcircbuf * - vmcircbuf_mmap_shm_open_factory::make(int size) - { +gr::vmcircbuf* vmcircbuf_mmap_shm_open_factory::make(int size) +{ try { - return new vmcircbuf_mmap_shm_open(size); - } - catch (...) { - return 0; + return new vmcircbuf_mmap_shm_open(size); + } catch (...) { + return 0; } - } +} } /* namespace gr */ diff --git a/gnuradio-runtime/lib/vmcircbuf_mmap_shm_open.h b/gnuradio-runtime/lib/vmcircbuf_mmap_shm_open.h index 60654ee46e..d0171e6c83 100644 --- a/gnuradio-runtime/lib/vmcircbuf_mmap_shm_open.h +++ b/gnuradio-runtime/lib/vmcircbuf_mmap_shm_open.h @@ -28,29 +28,29 @@ namespace gr { - /*! - * \brief concrete class to implement circular buffers with mmap and shm_open - * \ingroup internal - */ - class GR_RUNTIME_API vmcircbuf_mmap_shm_open : public gr::vmcircbuf - { - public: +/*! + * \brief concrete class to implement circular buffers with mmap and shm_open + * \ingroup internal + */ +class GR_RUNTIME_API vmcircbuf_mmap_shm_open : public gr::vmcircbuf +{ +public: vmcircbuf_mmap_shm_open(int size); virtual ~vmcircbuf_mmap_shm_open(); - }; +}; - /*! - * \brief concrete factory for circular buffers built using mmap and shm_open - */ - class GR_RUNTIME_API vmcircbuf_mmap_shm_open_factory : public gr::vmcircbuf_factory - { - private: - static gr::vmcircbuf_factory *s_the_factory; +/*! + * \brief concrete factory for circular buffers built using mmap and shm_open + */ +class GR_RUNTIME_API vmcircbuf_mmap_shm_open_factory : public gr::vmcircbuf_factory +{ +private: + static gr::vmcircbuf_factory* s_the_factory; - public: - static gr::vmcircbuf_factory *singleton(); +public: + static gr::vmcircbuf_factory* singleton(); - virtual const char *name() const { return "gr::vmcircbuf_mmap_shm_open_factory"; } + virtual const char* name() const { return "gr::vmcircbuf_mmap_shm_open_factory"; } /*! * \brief return granularity of mapping, typically equal to page size @@ -62,8 +62,8 @@ namespace gr { * * Call this to create a doubly mapped circular buffer. */ - virtual gr::vmcircbuf *make(int size); - }; + virtual gr::vmcircbuf* make(int size); +}; } /* namespace gr */ diff --git a/gnuradio-runtime/lib/vmcircbuf_mmap_tmpfile.cc b/gnuradio-runtime/lib/vmcircbuf_mmap_tmpfile.cc index 7a02fe2de8..d9eec36df4 100644 --- a/gnuradio-runtime/lib/vmcircbuf_mmap_tmpfile.cc +++ b/gnuradio-runtime/lib/vmcircbuf_mmap_tmpfile.cc @@ -44,18 +44,17 @@ namespace gr { - vmcircbuf_mmap_tmpfile::vmcircbuf_mmap_tmpfile (int size) - : gr::vmcircbuf (size) - { +vmcircbuf_mmap_tmpfile::vmcircbuf_mmap_tmpfile(int size) : gr::vmcircbuf(size) +{ #if !defined(HAVE_MMAP) fprintf(stderr, "gr::vmcircbuf_mmap_tmpfile: mmap or mkstemp is not available\n"); throw std::runtime_error("gr::vmcircbuf_mmap_tmpfile"); #else gr::thread::scoped_lock guard(s_vm_mutex); - if(size <= 0 || (size % gr::pagesize ()) != 0) { - fprintf(stderr, "gr::vmcircbuf_mmap_tmpfile: invalid size = %d\n", size); - throw std::runtime_error("gr::vmcircbuf_mmap_tmpfile"); + if (size <= 0 || (size % gr::pagesize()) != 0) { + fprintf(stderr, "gr::vmcircbuf_mmap_tmpfile: invalid size = %d\n", size); + throw std::runtime_error("gr::vmcircbuf_mmap_tmpfile"); } int seg_fd = -1; @@ -64,137 +63,135 @@ namespace gr { static int s_seg_counter = 0; // open a temporary file that we'll map in a bit later - while(1) { - snprintf(seg_name, sizeof(seg_name), - "%s/gnuradio-%d-%d-XXXXXX", gr::tmp_path(), getpid(), s_seg_counter); - s_seg_counter++; - - seg_fd = open(seg_name, O_RDWR | O_CREAT | O_EXCL, 0600); - if(seg_fd == -1) { - if(errno == EEXIST) // File already exists (shouldn't happen). Try again - continue; - - char msg[1024]; - snprintf(msg, sizeof (msg), - "gr::vmcircbuf_mmap_tmpfile: open [%s]", seg_name); - perror(msg); - throw std::runtime_error("gr::vmcircbuf_mmap_tmpfile"); - } - break; + while (1) { + snprintf(seg_name, + sizeof(seg_name), + "%s/gnuradio-%d-%d-XXXXXX", + gr::tmp_path(), + getpid(), + s_seg_counter); + s_seg_counter++; + + seg_fd = open(seg_name, O_RDWR | O_CREAT | O_EXCL, 0600); + if (seg_fd == -1) { + if (errno == EEXIST) // File already exists (shouldn't happen). Try again + continue; + + char msg[1024]; + snprintf(msg, sizeof(msg), "gr::vmcircbuf_mmap_tmpfile: open [%s]", seg_name); + perror(msg); + throw std::runtime_error("gr::vmcircbuf_mmap_tmpfile"); + } + break; } - if(unlink (seg_name) == -1) { - perror("gr::vmcircbuf_mmap_tmpfile: unlink"); - throw std::runtime_error ("gr::vmcircbuf_mmap_tmpfile"); + if (unlink(seg_name) == -1) { + perror("gr::vmcircbuf_mmap_tmpfile: unlink"); + throw std::runtime_error("gr::vmcircbuf_mmap_tmpfile"); } // We've got a valid file descriptor to a tmp file. // Now set it's length to 2x what we really want and mmap it in. - if(ftruncate (seg_fd, (off_t) 2 * size) == -1) { - close(seg_fd); // cleanup - perror("gr::vmcircbuf_mmap_tmpfile: ftruncate (1)"); - throw std::runtime_error("gr::vmcircbuf_mmap_tmpfile"); + if (ftruncate(seg_fd, (off_t)2 * size) == -1) { + close(seg_fd); // cleanup + perror("gr::vmcircbuf_mmap_tmpfile: ftruncate (1)"); + throw std::runtime_error("gr::vmcircbuf_mmap_tmpfile"); } - void *first_copy = mmap(0, 2 * size, - PROT_READ | PROT_WRITE, MAP_SHARED, - seg_fd, (off_t)0); + void* first_copy = + mmap(0, 2 * size, PROT_READ | PROT_WRITE, MAP_SHARED, seg_fd, (off_t)0); - if(first_copy == MAP_FAILED) { - close(seg_fd); // cleanup - perror("gr::vmcircbuf_mmap_tmpfile: mmap (1)"); - throw std::runtime_error ("gr::vmcircbuf_mmap_tmpfile"); + if (first_copy == MAP_FAILED) { + close(seg_fd); // cleanup + perror("gr::vmcircbuf_mmap_tmpfile: mmap (1)"); + throw std::runtime_error("gr::vmcircbuf_mmap_tmpfile"); } // unmap the 2nd half - if(munmap ((char *) first_copy + size, size) == -1) { - close(seg_fd); // cleanup - perror("gr::vmcircbuf_mmap_tmpfile: munmap (1)"); - throw std::runtime_error("gr::vmcircbuf_mmap_tmpfile"); + if (munmap((char*)first_copy + size, size) == -1) { + close(seg_fd); // cleanup + perror("gr::vmcircbuf_mmap_tmpfile: munmap (1)"); + throw std::runtime_error("gr::vmcircbuf_mmap_tmpfile"); } // map the first half into the now available hole where the // second half used to be. - void *second_copy = mmap((char*)first_copy + size, size, - PROT_READ | PROT_WRITE, MAP_SHARED, - seg_fd, (off_t)0); - - if(second_copy == MAP_FAILED) { - munmap(first_copy, size); // cleanup - close(seg_fd); - perror("gr::vmcircbuf_mmap_tmpfile: mmap(2)"); - throw std::runtime_error("gr::vmcircbuf_mmap_tmpfile"); + void* second_copy = mmap((char*)first_copy + size, + size, + PROT_READ | PROT_WRITE, + MAP_SHARED, + seg_fd, + (off_t)0); + + if (second_copy == MAP_FAILED) { + munmap(first_copy, size); // cleanup + close(seg_fd); + perror("gr::vmcircbuf_mmap_tmpfile: mmap(2)"); + throw std::runtime_error("gr::vmcircbuf_mmap_tmpfile"); } // check for contiguity - if((char*)second_copy != (char*)first_copy + size) { - munmap(first_copy, size); // cleanup - munmap(second_copy, size); - close(seg_fd); - perror("gr::vmcircbuf_mmap_tmpfile: non-contiguous second copy"); - throw std::runtime_error("gr::vmcircbuf_mmap_tmpfile"); + if ((char*)second_copy != (char*)first_copy + size) { + munmap(first_copy, size); // cleanup + munmap(second_copy, size); + close(seg_fd); + perror("gr::vmcircbuf_mmap_tmpfile: non-contiguous second copy"); + throw std::runtime_error("gr::vmcircbuf_mmap_tmpfile"); } // cut the tmp file down to size - if(ftruncate (seg_fd, (off_t) size) == -1) { - munmap(first_copy, size); // cleanup - munmap(second_copy, size); - close(seg_fd); - perror("gr::vmcircbuf_mmap_tmpfile: ftruncate (2)"); - throw std::runtime_error("gr::vmcircbuf_mmap_tmpfile"); + if (ftruncate(seg_fd, (off_t)size) == -1) { + munmap(first_copy, size); // cleanup + munmap(second_copy, size); + close(seg_fd); + perror("gr::vmcircbuf_mmap_tmpfile: ftruncate (2)"); + throw std::runtime_error("gr::vmcircbuf_mmap_tmpfile"); } - close(seg_fd); // fd no longer needed. The mapping is retained. + close(seg_fd); // fd no longer needed. The mapping is retained. // Now remember the important stuff d_base = (char*)first_copy; d_size = size; #endif - } +} - vmcircbuf_mmap_tmpfile::~vmcircbuf_mmap_tmpfile() - { +vmcircbuf_mmap_tmpfile::~vmcircbuf_mmap_tmpfile() +{ #if defined(HAVE_MMAP) gr::thread::scoped_lock guard(s_vm_mutex); - if(munmap(d_base, 2 * d_size) == -1) { - perror("gr::vmcircbuf_mmap_tmpfile: munmap(2)"); + if (munmap(d_base, 2 * d_size) == -1) { + perror("gr::vmcircbuf_mmap_tmpfile: munmap(2)"); } #endif - } +} - // ---------------------------------------------------------------- - // The factory interface - // ---------------------------------------------------------------- +// ---------------------------------------------------------------- +// The factory interface +// ---------------------------------------------------------------- - gr::vmcircbuf_factory *vmcircbuf_mmap_tmpfile_factory::s_the_factory = 0; +gr::vmcircbuf_factory* vmcircbuf_mmap_tmpfile_factory::s_the_factory = 0; - gr::vmcircbuf_factory * - vmcircbuf_mmap_tmpfile_factory::singleton() - { - if(s_the_factory) - return s_the_factory; +gr::vmcircbuf_factory* vmcircbuf_mmap_tmpfile_factory::singleton() +{ + if (s_the_factory) + return s_the_factory; s_the_factory = new gr::vmcircbuf_mmap_tmpfile_factory(); return s_the_factory; - } +} - int - vmcircbuf_mmap_tmpfile_factory::granularity() - { - return gr::pagesize(); - } +int vmcircbuf_mmap_tmpfile_factory::granularity() { return gr::pagesize(); } - gr::vmcircbuf * - vmcircbuf_mmap_tmpfile_factory::make(int size) - { +gr::vmcircbuf* vmcircbuf_mmap_tmpfile_factory::make(int size) +{ try { - return new vmcircbuf_mmap_tmpfile(size); - } - catch (...) { - return 0; + return new vmcircbuf_mmap_tmpfile(size); + } catch (...) { + return 0; } - } +} } /* namespace gr */ diff --git a/gnuradio-runtime/lib/vmcircbuf_mmap_tmpfile.h b/gnuradio-runtime/lib/vmcircbuf_mmap_tmpfile.h index f8959c5736..4f4ae64090 100644 --- a/gnuradio-runtime/lib/vmcircbuf_mmap_tmpfile.h +++ b/gnuradio-runtime/lib/vmcircbuf_mmap_tmpfile.h @@ -28,29 +28,29 @@ namespace gr { - /*! - * \brief concrete class to implement circular buffers with mmap and shm_open - * \ingroup internal - */ - class GR_RUNTIME_API vmcircbuf_mmap_tmpfile : public gr::vmcircbuf - { - public: +/*! + * \brief concrete class to implement circular buffers with mmap and shm_open + * \ingroup internal + */ +class GR_RUNTIME_API vmcircbuf_mmap_tmpfile : public gr::vmcircbuf +{ +public: vmcircbuf_mmap_tmpfile(int size); virtual ~vmcircbuf_mmap_tmpfile(); - }; +}; - /*! - * \brief concrete factory for circular buffers built using mmap and shm_open - */ - class GR_RUNTIME_API vmcircbuf_mmap_tmpfile_factory : public gr::vmcircbuf_factory - { - private: - static gr::vmcircbuf_factory *s_the_factory; +/*! + * \brief concrete factory for circular buffers built using mmap and shm_open + */ +class GR_RUNTIME_API vmcircbuf_mmap_tmpfile_factory : public gr::vmcircbuf_factory +{ +private: + static gr::vmcircbuf_factory* s_the_factory; - public: - static gr::vmcircbuf_factory *singleton(); +public: + static gr::vmcircbuf_factory* singleton(); - virtual const char *name() const { return "gr::vmcircbuf_mmap_tmpfile_factory"; } + virtual const char* name() const { return "gr::vmcircbuf_mmap_tmpfile_factory"; } /*! * \brief return granularity of mapping, typically equal to page size @@ -62,8 +62,8 @@ namespace gr { * * Call this to create a doubly mapped circular buffer. */ - virtual gr::vmcircbuf *make(int size); - }; + virtual gr::vmcircbuf* make(int size); +}; } /* namespace gr */ diff --git a/gnuradio-runtime/lib/vmcircbuf_prefs.cc b/gnuradio-runtime/lib/vmcircbuf_prefs.cc index 4cb09f69f8..80c36f189f 100644 --- a/gnuradio-runtime/lib/vmcircbuf_prefs.cc +++ b/gnuradio-runtime/lib/vmcircbuf_prefs.cc @@ -41,77 +41,73 @@ namespace fs = boost::filesystem; namespace gr { - /* - * The simplest thing that could possibly work: - * the key is the filename; the value is the file contents. - */ - - static std::string - pathname(const char *key) - { +/* + * The simplest thing that could possibly work: + * the key is the filename; the value is the file contents. + */ + +static std::string pathname(const char* key) +{ static fs::path path; - path = fs::path(gr::appdata_path()) / ".gnuradio" / "prefs" / key; + path = fs::path(gr::appdata_path()) / ".gnuradio" / "prefs" / key; return path.string(); - } +} - static void - ensure_dir_path() - { +static void ensure_dir_path() +{ fs::path path = fs::path(gr::appdata_path()) / ".gnuradio"; - if(!fs::is_directory(path)) - fs::create_directory(path); + if (!fs::is_directory(path)) + fs::create_directory(path); path = path / "prefs"; - if(!fs::is_directory(path)) - fs::create_directory(path); - } + if (!fs::is_directory(path)) + fs::create_directory(path); +} - int - vmcircbuf_prefs::get(const char *key, char *value, int value_size) - { +int vmcircbuf_prefs::get(const char* key, char* value, int value_size) +{ gr::thread::scoped_lock guard(s_vm_mutex); - FILE *fp = fopen(pathname (key).c_str(), "r"); - if(fp == 0) { - perror(pathname (key).c_str()); - return 0; + FILE* fp = fopen(pathname(key).c_str(), "r"); + if (fp == 0) { + perror(pathname(key).c_str()); + return 0; } const size_t ret = fread(value, 1, value_size - 1, fp); value[ret] = '\0'; - if(ret == 0 && !feof(fp)) { - if(ferror(fp) != 0) { - perror(pathname (key).c_str()); - fclose(fp); - return -1; - } + if (ret == 0 && !feof(fp)) { + if (ferror(fp) != 0) { + perror(pathname(key).c_str()); + fclose(fp); + return -1; + } } fclose(fp); return ret; - } +} - void - vmcircbuf_prefs::set(const char *key, const char *value) - { +void vmcircbuf_prefs::set(const char* key, const char* value) +{ gr::thread::scoped_lock guard(s_vm_mutex); ensure_dir_path(); - FILE *fp = fopen(pathname(key).c_str(), "w"); - if(fp == 0) { - perror(pathname (key).c_str()); - return; + FILE* fp = fopen(pathname(key).c_str(), "w"); + if (fp == 0) { + perror(pathname(key).c_str()); + return; } size_t ret = fwrite(value, 1, strlen(value), fp); - if(ret == 0) { - if(ferror(fp) != 0) { - perror(pathname (key).c_str()); - fclose(fp); - return; - } + if (ret == 0) { + if (ferror(fp) != 0) { + perror(pathname(key).c_str()); + fclose(fp); + return; + } } fclose(fp); - }; +}; } /* namespace gr */ diff --git a/gnuradio-runtime/lib/vmcircbuf_prefs.h b/gnuradio-runtime/lib/vmcircbuf_prefs.h index ec7b6991d7..d267393298 100644 --- a/gnuradio-runtime/lib/vmcircbuf_prefs.h +++ b/gnuradio-runtime/lib/vmcircbuf_prefs.h @@ -27,12 +27,12 @@ namespace gr { - class GR_RUNTIME_API vmcircbuf_prefs - { - public: - static int get(const char *key, char *value, int value_size); - static void set(const char *key, const char *value); - }; +class GR_RUNTIME_API vmcircbuf_prefs +{ +public: + static int get(const char* key, char* value, int value_size); + static void set(const char* key, const char* value); +}; } /* namespace gr */ diff --git a/gnuradio-runtime/lib/vmcircbuf_sysv_shm.cc b/gnuradio-runtime/lib/vmcircbuf_sysv_shm.cc index c3681280d6..7f1ccd2d7b 100644 --- a/gnuradio-runtime/lib/vmcircbuf_sysv_shm.cc +++ b/gnuradio-runtime/lib/vmcircbuf_sysv_shm.cc @@ -44,9 +44,8 @@ namespace gr { - vmcircbuf_sysv_shm::vmcircbuf_sysv_shm(int size) - : gr::vmcircbuf(size) - { +vmcircbuf_sysv_shm::vmcircbuf_sysv_shm(int size) : gr::vmcircbuf(size) +{ #if !defined(HAVE_SYS_SHM_H) fprintf(stderr, "gr::vmcircbuf_sysv_shm: sysv shared memory is not available\n"); throw std::runtime_error("gr::vmcircbuf_sysv_shm"); @@ -56,46 +55,48 @@ namespace gr { int pagesize = gr::pagesize(); - if(size <= 0 || (size % pagesize) != 0) { - fprintf(stderr, "gr::vmcircbuf_sysv_shm: invalid size = %d\n", size); - throw std::runtime_error("gr::vmcircbuf_sysv_shm"); + if (size <= 0 || (size % pagesize) != 0) { + fprintf(stderr, "gr::vmcircbuf_sysv_shm: invalid size = %d\n", size); + throw std::runtime_error("gr::vmcircbuf_sysv_shm"); } // Attempt to allocate buffers (handle bad_alloc errors) int attempts_remain(MAX_SYSV_SHM_ATTEMPTS); - while(attempts_remain-- > 0){ + while (attempts_remain-- > 0) { int shmid_guard = -1; int shmid1 = -1; int shmid2 = -1; - // We use this as a guard page. We'll map it read-only on both ends of the buffer. - // Ideally we'd map it no access, but I don't think that's possible with SysV - if((shmid_guard = shmget(IPC_PRIVATE, pagesize, IPC_CREAT | 0400)) == -1) { - perror("gr::vmcircbuf_sysv_shm: shmget (0)"); - continue; + // We use this as a guard page. We'll map it read-only on both ends of the + // buffer. Ideally we'd map it no access, but I don't think that's possible with + // SysV + if ((shmid_guard = shmget(IPC_PRIVATE, pagesize, IPC_CREAT | 0400)) == -1) { + perror("gr::vmcircbuf_sysv_shm: shmget (0)"); + continue; } - if((shmid2 = shmget(IPC_PRIVATE, 2 * size + 2 * pagesize, IPC_CREAT | 0700)) == -1) { - perror("gr::vmcircbuf_sysv_shm: shmget (1)"); - shmctl(shmid_guard, IPC_RMID, 0); - continue; + if ((shmid2 = shmget(IPC_PRIVATE, 2 * size + 2 * pagesize, IPC_CREAT | 0700)) == + -1) { + perror("gr::vmcircbuf_sysv_shm: shmget (1)"); + shmctl(shmid_guard, IPC_RMID, 0); + continue; } - if((shmid1 = shmget(IPC_PRIVATE, size, IPC_CREAT | 0700)) == -1) { - perror("gr::vmcircbuf_sysv_shm: shmget (2)"); - shmctl(shmid_guard, IPC_RMID, 0); - shmctl(shmid2, IPC_RMID, 0); - continue; + if ((shmid1 = shmget(IPC_PRIVATE, size, IPC_CREAT | 0700)) == -1) { + perror("gr::vmcircbuf_sysv_shm: shmget (2)"); + shmctl(shmid_guard, IPC_RMID, 0); + shmctl(shmid2, IPC_RMID, 0); + continue; } - void *first_copy = shmat (shmid2, 0, 0); - if(first_copy == (void *) -1) { - perror("gr::vmcircbuf_sysv_shm: shmat (1)"); - shmctl(shmid_guard, IPC_RMID, 0); - shmctl(shmid2, IPC_RMID, 0); - shmctl(shmid1, IPC_RMID, 0); - continue; + void* first_copy = shmat(shmid2, 0, 0); + if (first_copy == (void*)-1) { + perror("gr::vmcircbuf_sysv_shm: shmat (1)"); + shmctl(shmid_guard, IPC_RMID, 0); + shmctl(shmid2, IPC_RMID, 0); + shmctl(shmid1, IPC_RMID, 0); + continue; } shmctl(shmid2, IPC_RMID, 0); @@ -110,40 +111,41 @@ namespace gr { shmdt(first_copy); // first read-only guard page - if(shmat(shmid_guard, first_copy, SHM_RDONLY) == (void *) -1) { - perror("gr::vmcircbuf_sysv_shm: shmat (2)"); - shmctl(shmid_guard, IPC_RMID, 0); - shmctl(shmid1, IPC_RMID, 0); - continue; + if (shmat(shmid_guard, first_copy, SHM_RDONLY) == (void*)-1) { + perror("gr::vmcircbuf_sysv_shm: shmat (2)"); + shmctl(shmid_guard, IPC_RMID, 0); + shmctl(shmid1, IPC_RMID, 0); + continue; } // first copy - if(shmat (shmid1, (char*)first_copy + pagesize, 0) == (void *) -1) { - perror("gr::vmcircbuf_sysv_shm: shmat (3)"); - shmctl(shmid_guard, IPC_RMID, 0); - shmctl(shmid1, IPC_RMID, 0); - shmdt(first_copy); - continue; + if (shmat(shmid1, (char*)first_copy + pagesize, 0) == (void*)-1) { + perror("gr::vmcircbuf_sysv_shm: shmat (3)"); + shmctl(shmid_guard, IPC_RMID, 0); + shmctl(shmid1, IPC_RMID, 0); + shmdt(first_copy); + continue; } // second copy - if(shmat (shmid1, (char*)first_copy + pagesize + size, 0) == (void *) -1) { - perror("gr::vmcircbuf_sysv_shm: shmat (4)"); - shmctl(shmid_guard, IPC_RMID, 0); - shmctl(shmid1, IPC_RMID, 0); - shmdt((char *)first_copy + pagesize); - continue; + if (shmat(shmid1, (char*)first_copy + pagesize + size, 0) == (void*)-1) { + perror("gr::vmcircbuf_sysv_shm: shmat (4)"); + shmctl(shmid_guard, IPC_RMID, 0); + shmctl(shmid1, IPC_RMID, 0); + shmdt((char*)first_copy + pagesize); + continue; } // second read-only guard page - if(shmat(shmid_guard, (char*)first_copy + pagesize + 2 * size, SHM_RDONLY) == (void *) -1) { - perror("gr::vmcircbuf_sysv_shm: shmat (5)"); - shmctl(shmid_guard, IPC_RMID, 0); - shmctl(shmid1, IPC_RMID, 0); - shmdt(first_copy); - shmdt((char *)first_copy + pagesize); - shmdt((char *)first_copy + pagesize + size); - continue; + if (shmat(shmid_guard, (char*)first_copy + pagesize + 2 * size, SHM_RDONLY) == + (void*)-1) { + perror("gr::vmcircbuf_sysv_shm: shmat (5)"); + shmctl(shmid_guard, IPC_RMID, 0); + shmctl(shmid1, IPC_RMID, 0); + shmdt(first_copy); + shmdt((char*)first_copy + pagesize); + shmdt((char*)first_copy + pagesize + size); + continue; } shmctl(shmid1, IPC_RMID, 0); @@ -154,57 +156,48 @@ namespace gr { d_size = size; break; } - if(attempts_remain<0){ + if (attempts_remain < 0) { throw std::runtime_error("gr::vmcircbuf_sysv_shm"); } #endif - } +} - vmcircbuf_sysv_shm::~vmcircbuf_sysv_shm() - { +vmcircbuf_sysv_shm::~vmcircbuf_sysv_shm() +{ #if defined(HAVE_SYS_SHM_H) gr::thread::scoped_lock guard(s_vm_mutex); - if(shmdt(d_base - gr::pagesize()) == -1 - || shmdt(d_base) == -1 - || shmdt(d_base + d_size) == -1 - || shmdt(d_base + 2 * d_size) == -1){ - perror("gr::vmcircbuf_sysv_shm: shmdt (2)"); + if (shmdt(d_base - gr::pagesize()) == -1 || shmdt(d_base) == -1 || + shmdt(d_base + d_size) == -1 || shmdt(d_base + 2 * d_size) == -1) { + perror("gr::vmcircbuf_sysv_shm: shmdt (2)"); } #endif - } +} - // ---------------------------------------------------------------- - // The factory interface - // ---------------------------------------------------------------- +// ---------------------------------------------------------------- +// The factory interface +// ---------------------------------------------------------------- - gr::vmcircbuf_factory *vmcircbuf_sysv_shm_factory::s_the_factory = 0; +gr::vmcircbuf_factory* vmcircbuf_sysv_shm_factory::s_the_factory = 0; - gr::vmcircbuf_factory * - vmcircbuf_sysv_shm_factory::singleton() - { - if(s_the_factory) - return s_the_factory; +gr::vmcircbuf_factory* vmcircbuf_sysv_shm_factory::singleton() +{ + if (s_the_factory) + return s_the_factory; s_the_factory = new gr::vmcircbuf_sysv_shm_factory(); return s_the_factory; - } +} - int - vmcircbuf_sysv_shm_factory::granularity() - { - return gr::pagesize(); - } +int vmcircbuf_sysv_shm_factory::granularity() { return gr::pagesize(); } - gr::vmcircbuf * - vmcircbuf_sysv_shm_factory::make(int size) - { +gr::vmcircbuf* vmcircbuf_sysv_shm_factory::make(int size) +{ try { - return new vmcircbuf_sysv_shm(size); - } - catch (...) { - return 0; + return new vmcircbuf_sysv_shm(size); + } catch (...) { + return 0; } - } +} } /* namespace gr */ diff --git a/gnuradio-runtime/lib/vmcircbuf_sysv_shm.h b/gnuradio-runtime/lib/vmcircbuf_sysv_shm.h index 08e0040bf1..461d60544e 100644 --- a/gnuradio-runtime/lib/vmcircbuf_sysv_shm.h +++ b/gnuradio-runtime/lib/vmcircbuf_sysv_shm.h @@ -28,29 +28,29 @@ namespace gr { - /*! - * \brief concrete class to implement circular buffers with mmap and shm_open - * \ingroup internal - */ - class GR_RUNTIME_API vmcircbuf_sysv_shm : public gr::vmcircbuf - { - public: +/*! + * \brief concrete class to implement circular buffers with mmap and shm_open + * \ingroup internal + */ +class GR_RUNTIME_API vmcircbuf_sysv_shm : public gr::vmcircbuf +{ +public: vmcircbuf_sysv_shm(int size); - virtual ~vmcircbuf_sysv_shm(); - }; + virtual ~vmcircbuf_sysv_shm(); +}; - /*! - * \brief concrete factory for circular buffers built using mmap and shm_open - */ - class GR_RUNTIME_API vmcircbuf_sysv_shm_factory : public gr::vmcircbuf_factory - { - private: - static gr::vmcircbuf_factory *s_the_factory; +/*! + * \brief concrete factory for circular buffers built using mmap and shm_open + */ +class GR_RUNTIME_API vmcircbuf_sysv_shm_factory : public gr::vmcircbuf_factory +{ +private: + static gr::vmcircbuf_factory* s_the_factory; - public: - static gr::vmcircbuf_factory *singleton(); +public: + static gr::vmcircbuf_factory* singleton(); - virtual const char *name() const { return "gr::vmcircbuf_sysv_shm_factory"; } + virtual const char* name() const { return "gr::vmcircbuf_sysv_shm_factory"; } /*! * \brief return granularity of mapping, typically equal to page size @@ -62,8 +62,8 @@ namespace gr { * * Call this to create a doubly mapped circular buffer. */ - virtual gr::vmcircbuf *make(int size); - }; + virtual gr::vmcircbuf* make(int size); +}; } /* namespace gr */ |