From 26dceecc80390f10cedb94bd9e4fd655827d7f17 Mon Sep 17 00:00:00 2001
From: Johnathan Corgan <johnathan@corganlabs.com>
Date: Tue, 26 Mar 2013 20:18:53 -0700
Subject: runtime: migrate remaining gnuradio-core contents into
gnuradio-runtime
---
gnuradio-core/src/lib/runtime/gr_buffer.cc | 347 -----------------------------
1 file changed, 347 deletions(-)
delete mode 100644 gnuradio-core/src/lib/runtime/gr_buffer.cc
(limited to 'gnuradio-core/src/lib/runtime/gr_buffer.cc')
diff --git a/gnuradio-core/src/lib/runtime/gr_buffer.cc b/gnuradio-core/src/lib/runtime/gr_buffer.cc
deleted file mode 100644
index 369959d65f..0000000000
--- a/gnuradio-core/src/lib/runtime/gr_buffer.cc
+++ /dev/null
@@ -1,347 +0,0 @@
-/* -*- c++ -*- */
-/*
- * Copyright 2004,2009,2010 Free Software Foundation, Inc.
- *
- * This file is part of GNU Radio
- *
- * GNU Radio is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 3, or (at your option)
- * any later version.
- *
- * GNU Radio is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with GNU Radio; see the file COPYING. If not, write to
- * the Free Software Foundation, Inc., 51 Franklin Street,
- * Boston, MA 02110-1301, USA.
- */
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#include <gr_buffer.h>
-#include <gr_vmcircbuf.h>
-#include <gr_math.h>
-#include <stdexcept>
-#include <iostream>
-#include <assert.h>
-#include <algorithm>
-#include <boost/math/common_factor_rt.hpp>
-
-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
- * contraint for integer buffer_size and k:
- *
- * type_size * nitems == k * page_size
- */
-static long
-minimum_buffer_items (long type_size, long page_size)
-{
- return page_size / boost::math::gcd (type_size, page_size);
-}
-
-
-gr_buffer::gr_buffer (int nitems, size_t sizeof_item, gr_block_sptr link)
- : d_base (0), d_bufsize (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 ();
-
- s_buffer_count++;
-}
-
-gr_buffer_sptr
-gr_make_buffer (int nitems, size_t sizeof_item, gr_block_sptr link)
-{
- return gr_buffer_sptr (new gr_buffer (nitems, sizeof_item, link));
-}
-
-gr_buffer::~gr_buffer ()
-{
- delete d_vmcircbuf;
- assert (d_readers.size() == 0);
- s_buffer_count--;
-}
-
-/*!
- * sets d_vmcircbuf, d_base, d_bufsize.
- * returns true iff successful.
- */
-bool
-gr_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);
-
- // Round-up nitems to a multiple of 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";
- }
-
- 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;
- }
-
- d_base = (char *) d_vmcircbuf->pointer_to_first_copy ();
- return true;
-}
-
-
-int
-gr_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;
- }
-}
-
-void *
-gr_buffer::write_pointer ()
-{
- return &d_base[d_write_index * d_sizeof_item];
-}
-
-void
-gr_buffer::update_write_pointer (int nitems)
-{
- gruel::scoped_lock guard(*mutex());
- d_write_index = index_add (d_write_index, nitems);
- d_abs_write_offset += nitems;
-}
-
-void
-gr_buffer::set_done (bool done)
-{
- gruel::scoped_lock guard(*mutex());
- d_done = done;
-}
-
-gr_buffer_reader_sptr
-gr_buffer_add_reader (gr_buffer_sptr buf, int nzero_preload, gr_block_sptr link)
-{
- if (nzero_preload < 0)
- throw std::invalid_argument("gr_buffer_add_reader: nzero_preload must be >= 0");
-
- gr_buffer_reader_sptr r (new gr_buffer_reader (buf,
- buf->index_sub(buf->d_write_index,
- nzero_preload),
- link));
- buf->d_readers.push_back (r.get ());
-
- return r;
-}
-
-void
-gr_buffer::drop_reader (gr_buffer_reader *reader)
-{
- // isn't C++ beautiful... GAG!
-
- std::vector<gr_buffer_reader *>::iterator result =
- std::find (d_readers.begin (), d_readers.end (), reader);
-
- if (result == d_readers.end ())
- throw std::invalid_argument ("gr_buffer::drop_reader"); // we didn't find it...
-
- d_readers.erase (result);
-}
-
-void
-gr_buffer::add_item_tag(const gr_tag_t &tag)
-{
- gruel::scoped_lock guard(*mutex());
- d_item_tags.push_back(tag);
-}
-
-void
-gr_buffer::remove_item_tag(const gr_tag_t &tag)
-{
- gruel::scoped_lock guard(*mutex());
- for (std::deque<gr_tag_t>::iterator it = d_item_tags.begin(); it != d_item_tags.end(); ++it) {
- if (*it == tag) {
- d_item_tags.erase(it);
- break;
- }
- }
-}
-
-void
-gr_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 gr_block_executor.cc,
- which locks the mutex itself.
-
- If this function is used elsewhere, remember to lock the
- buffer's mutex al la the scoped_lock line below.
- */
- //gruel::scoped_lock guard(*mutex());
- std::deque<gr_tag_t>::iterator itr = d_item_tags.begin();
-
- uint64_t item_time;
-
- // Since tags are not guarenteed to be in any particular order,
- // we need to erase here instead of pop_front. An erase in the
- // middle invalidates all iterators; so this resets the iterator
- // to find more. Mostly, we wil be erasing from the front and
- // therefore lose little time this way.
- while(itr != d_item_tags.end()) {
- item_time = (*itr).offset;
- if(item_time < max_time) {
- d_item_tags.erase(itr);
- itr = d_item_tags.begin();
- }
- else
- itr++;
- }
-}
-
-long
-gr_buffer_ncurrently_allocated ()
-{
- return s_buffer_count;
-}
-
-// ----------------------------------------------------------------------------
-
-gr_buffer_reader::gr_buffer_reader(gr_buffer_sptr buffer, unsigned int read_index,
- gr_block_sptr link)
- : d_buffer(buffer), d_read_index(read_index), d_abs_read_offset(0), d_link(link)
-{
- s_buffer_reader_count++;
-}
-
-gr_buffer_reader::~gr_buffer_reader ()
-{
- d_buffer->drop_reader(this);
- s_buffer_reader_count--;
-}
-
-int
-gr_buffer_reader::items_available () const
-{
- return d_buffer->index_sub (d_buffer->d_write_index, d_read_index);
-}
-
-const void *
-gr_buffer_reader::read_pointer ()
-{
- return &d_buffer->d_base[d_read_index * d_buffer->d_sizeof_item];
-}
-
-void
-gr_buffer_reader::update_read_pointer (int nitems)
-{
- gruel::scoped_lock guard(*mutex());
- d_read_index = d_buffer->index_add (d_read_index, nitems);
- d_abs_read_offset += nitems;
-}
-
-void
-gr_buffer_reader::get_tags_in_range(std::vector<gr_tag_t> &v,
- uint64_t abs_start,
- uint64_t abs_end)
-{
- gruel::scoped_lock guard(*mutex());
-
- v.resize(0);
- std::deque<gr_tag_t>::iterator itr = d_buffer->get_tags_begin();
-
- uint64_t item_time;
- while(itr != d_buffer->get_tags_end()) {
- item_time = (*itr).offset;
-
- if((item_time >= abs_start) && (item_time < abs_end)) {
- v.push_back(*itr);
- }
-
- itr++;
- }
-}
-
-long
-gr_buffer_reader_ncurrently_allocated ()
-{
- return s_buffer_reader_count;
-}
--
cgit v1.2.3