+# Copyright 2013 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.

+

+include(GrMiscUtils)

+GR_CHECK_HDR_N_DEF(sys/resource.h HAVE_SYS_RESOURCE_H)

+

+########################################################################

+# Handle the generated constants

+########################################################################

+execute_process(COMMAND ${PYTHON_EXECUTABLE} -c

+ "import time;print time.strftime('%a, %d %b %Y %H:%M:%S', time.gmtime())"

+ OUTPUT_VARIABLE BUILD_DATE OUTPUT_STRIP_TRAILING_WHITESPACE

+)

+message(STATUS "Loading build date ${BUILD_DATE} into gr_constants...")

+message(STATUS "Loading version ${VERSION} into gr_constants...")

+

+#double escape for windows backslash path separators

+string(REPLACE "\\" "\\\\" prefix ${prefix})

+string(REPLACE "\\" "\\\\" SYSCONFDIR ${SYSCONFDIR})

+string(REPLACE "\\" "\\\\" GR_PREFSDIR ${GR_PREFSDIR})

+

+configure_file(

+ ${CMAKE_CURRENT_SOURCE_DIR}/gr_constants.cc.in

+ ${CMAKE_CURRENT_BINARY_DIR}/gr_constants.cc

+@ONLY)

+

+list(APPEND gnuradio_runtime_sources ${CMAKE_CURRENT_BINARY_DIR}/gr_constants.cc)

+

+########################################################################

+# Include subdirs rather to populate to the sources lists.

+########################################################################

+#GR_INCLUDE_SUBDIRECTORY(foo)

+

+########################################################################

+# Setup the include and linker paths

+########################################################################

+include_directories(${GNURADIO_RUNTIME_INCLUDE_DIRS}

+ ${CMAKE_CURRENT_SOURCE_DIR}

+ ${CMAKE_CURRENT_BINARY_DIR}/../include/

+ ${Boost_INCLUDE_DIRS}

+ ${GRUEL_INCLUDE_DIRS}

+ ${VOLK_INCLUDE_DIRS}

+)

+

+########################################################################

+# Setup library

+########################################################################

+list(APPEND gnuradio_runtime_sources

+ complex_vec_test.cc

+ gr_basic_block.cc

+ gr_block.cc

+ gr_block_detail.cc

+ gr_block_executor.cc

+ gr_block_gateway.cc

+ gr_block_registry.cc

+ gr_buffer.cc

+ gr_circular_file.cc

+ gr_dispatcher.cc

+ gr_error_handler.cc

+ gr_fast_atan2f.cc

+ gr_feval.cc

+ gr_flat_flowgraph.cc

+ gr_flowgraph.cc

+ gr_fxpt.cc

+ gr_hier_block2.cc

+ gr_hier_block2_detail.cc

+ gri_debugger_hook.cc

+ gr_io_signature.cc

+ gr_local_sighandler.cc

+ gr_logger.cc

+ gr_message.cc

+ gr_misc.cc

+ gr_msg_accepter.cc

+ gr_msg_handler.cc

+ gr_msg_queue.cc

+ gr_pagesize.cc

+ gr_preferences.cc

+ gr_prefs.cc

+ gr_random.cc

+ gr_realtime.cc

+ gr_reverse.cc

+ gr_scheduler.cc

+ gr_scheduler_sts.cc

+ gr_scheduler_tpb.cc

+ gr_select_handler.cc

+ gr_sincos.c

+ gr_single_threaded_scheduler.cc

+ gr_sptr_magic.cc

+ gr_sync_block.cc

+ gr_sync_decimator.cc

+ gr_sync_interpolator.cc

+ gr_sys_paths.cc

+ gr_tagged_stream_block.cc

+ gr_test.cc

+ gr_top_block.cc

+ gr_top_block_impl.cc

+ gr_tpb_detail.cc

+ gr_tpb_thread_body.cc

+ gr_vmcircbuf.cc

+ gr_vmcircbuf_createfilemapping.cc

+ gr_vmcircbuf_mmap_shm_open.cc

+ gr_vmcircbuf_mmap_tmpfile.cc

+ gr_vmcircbuf_sysv_shm.cc

+ malloc16.c

+)

+

+# PowerPC workaround for posix_memalign

+# Might not be needed, but we'll keep it for now.

+if(CMAKE_SYSTEM_PROCESSOR MATCHES "^(powerpc|ppc)")

+ list(APPEND gnuradio_core_sources

+ ${CMAKE_CURRENT_SOURCE_DIR}/posix_memalign.cc

+ )

+endif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(powerpc|ppc)")

+

+list(APPEND gnuradio_runtime_libs

+ gruel

+ volk

+ ${Boost_LIBRARIES}

+)

+

+#need to link with librt on ubuntu 11.10 for shm_*

+if(LINUX)

+ list(APPEND gnuradio_runtime_libs rt)

+endif()

+

+if(ENABLE_GR_CTRLPORT)

+

+# Add definition so we can compile in ControlPort to the blocks.

+ADD_DEFINITIONS(-DGR_CTRLPORT)

+

+########################################################################

+# Run ICE To compile Slice files

+########################################################################

+EXECUTE_PROCESS(

+ COMMAND "${ICE_SLICE2CPP}" "-I${CMAKE_CURRENT_SOURCE_DIR}"

+ "--output-dir=${CMAKE_CURRENT_BINARY_DIR}"

+ "${CMAKE_CURRENT_SOURCE_DIR}/gnuradio.ice"

+ )

+

+list(APPEND gnuradio_runtime_sources

+ ice_application_base.cc

+ rpcmanager.cc

+ rpcpmtconverters_ice.cc

+ rpcserver_aggregator.cc

+ rpcserver_booter_aggregator.cc

+ rpcserver_booter_ice.cc

+ rpcserver_ice.cc

+ rpcserver_selector.cc

+ rpcpmtconverters_ice.cc

+)

+

+# Append generated file in build directory

+list(APPEND gnuradio_runtime_sources

+ ${CMAKE_CURRENT_BINARY_DIR}/gnuradio.cpp

+)

+

+########################################################################

+# Add controlport stuff to gnuradio-runtime

+########################################################################

+

+include_directories(${CMAKE_CURRENT_BINARY_DIR})

+

+list(APPEND gnuradio_runtime_libs

+ ${ICE_LIBRARIES}

+)

+

+endif(ENABLE_GR_CTRLPORT)

+

+########################################################################

+# Control availability of vmcircbuf methods.

+# For now, only allows disabling of shm methods, which cause uncatchable

+# segmentation faults on Cygwin with gcc 4.x (x <= 5)

+# Usage:

+# GR_VMCIRCBUF()

+#

+# Will set TRY_SHM_VMCIRCBUF to 1 by default except on Windows machines.

+# Can manually set with -DTRY_SHM_VMCIRCBUF=0|1

+########################################################################

+

+if(WIN32)

+ OPTION(TRY_SHM_VMCIRCBUF "Try SHM VMCIRCBUF" OFF)

+else(WIN32)

+ OPTION(TRY_SHM_VMCIRCBUF "Try SHM VMCIRCBUF" ON)

+endif(WIN32)

+

+message(STATUS "TRY_SHM_VMCIRCBUF set to ${TRY_SHM_VMCIRCBUF}.")

+

+if(TRY_SHM_VMCIRCBUF)

+ add_definitions( -DTRY_SHM_VMCIRCBUF )

+endif(TRY_SHM_VMCIRCBUF)

+

+add_library(gnuradio-runtime SHARED ${gnuradio_runtime_sources})

+target_link_libraries(gnuradio-runtime ${gnuradio_runtime_libs})

+GR_LIBRARY_FOO(gnuradio-runtime RUNTIME_COMPONENT "runtime" DEVEL_COMPONENT "runtime_devel")

+set_target_properties(gnuradio-runtime PROPERTIES LINK_INTERFACE_LIBRARIES "gruel")

+

+add_dependencies(gnuradio-runtime

+ runtime_generated_includes

+)

+

+########################################################################

+# Setup tests

+########################################################################

+if(ENABLE_TESTING)

+include(GrTest)

+

+########################################################################

+# Append gnuradio-runtime test sources

+########################################################################

+list(APPEND test_gnuradio_runtime_sources

+ qa_gr_buffer.cc

+ qa_gr_circular_file.cc

+ qa_gr_fxpt.cc

+ qa_gr_fxpt_nco.cc

+ qa_gr_fxpt_vco.cc

+ qa_gr_io_signature.cc

+ qa_gr_logger.cc

+ qa_gr_math.cc

+ qa_gr_vmcircbuf.cc

+ qa_runtime.cc

+ qa_sincos.cc

+)

+

+include_directories(${CPPUNIT_INCLUDE_DIRS})

+link_directories(${CPPUNIT_LIBRARY_DIRS})

+

+add_library(test-gnuradio-runtime SHARED ${test_gnuradio_runtime_sources})

+target_link_libraries(test-gnuradio-runtime gnuradio-runtime ${CPPUNIT_LIBRARIES} ${Boost_LIBRARIES})

+

+########################################################################

+# Build the test executable

+# Set the test environment so the build libs will be found under MSVC.

+########################################################################

+list(APPEND GR_TEST_TARGET_DEPS test-gnuradio-runtime)

+add_executable(gr_runtime_test test_runtime.cc)

+target_link_libraries(gr_runtime_test test-gnuradio-runtime)

+GR_ADD_TEST(gr-runtime-test gr_runtime_test)

+

+endif(ENABLE_TESTING)

+

+Copyright (c) 2003-2011 ZeroC, Inc. All rights reserved.

+

+This copy of Ice is free software; you can redistribute it and/or modify

+it under the terms of the GNU General Public License version 2 as

+published by the Free Software Foundation.

+

+Ice 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 version

+2 along with this program; if not, see http://www.gnu.org/licenses.

+

+Linking Ice statically or dynamically with other software (such as a

+library, module or application) is making a combined work based on Ice.

+Thus, the terms and conditions of the GNU General Public License version

+2 cover this combined work.

+

+If such software can only be used together with Ice, then not only the

+combined work but the software itself is a work derived from Ice and as

+such shall be licensed under the terms of the GNU General Public License

+version 2. This includes the situation where Ice is only being used

+through an abstraction layer.

+

+As a special exception to the above, ZeroC grants to the contributors for

+the following projects the permission to license their Ice-based software

+under the terms of the GNU Lesser General Public License (LGPL) version

+2.1 or of the BSD license:

+

+ - Orca Robotics (http://orca-robotics.sourceforge.net)

+

+ - Mumble (http://mumble.sourceforge.net)

+

+This exception does not extend to the parts of Ice used by these

+projects, or to any other derived work: as a whole, any work based on Ice

+shall be licensed under the terms and conditions of the GNU General

+Public License version 2.

+

+You may also combine Ice with any software not derived from Ice, provided

+the license of such software is compatible with the GNU General Public

+License version 2. In addition, as a special exception, ZeroC grants you

+permission to combine Ice with:

+

+ - the OpenSSL library, or with a modified version of the OpenSSL library

+ that uses the same license as OpenSSL

+

+ - any library not derived from Ice and licensed under the terms of

+ the Apache License, version 2.0

+ (http://www.apache.org/licenses/LICENSE-2.0.html)

+

+If you modify this copy of Ice, you may extend any of the exceptions

+provided above to your version of Ice, but you are not obligated to

+do so.

+#include <complex_vec_test.h>

+#include <stddef.h>

+

+std::vector<std::complex<float> >

+complex_vec_test0()

+{

+ std::vector<std::complex<float> > r(5);

+

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

+ r[i] = std::complex<float>(i, i);

+

+ return r;

+}

+

+std::vector<std::complex<float> >

+complex_vec_test1(const std::vector<std::complex<float> > &input)

+{

+ std::vector<std::complex<float> > r(input.size());

+

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

+ r[i] = std::complex<float>(input[i].real()+0.5, input[i].imag()-0.5);

+

+ return r;

+}

+

+std::complex<float>

+complex_scalar_test0()

+{

+ return std::complex<float>(5, 5);

+}

+

+std::complex<float>

+complex_scalar_test1(std::complex<float> input)

+{

+ return std::complex<float>(input.real()+0.5, input.imag()-0.5);

+}

+

+

+std::vector<float>

+float_vec_test0()

+{

+ std::vector<float> r(5);

+

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

+ r[i] = (float) i;

+

+ return r;

+}

+

+std::vector<float>

+float_vec_test1(const std::vector<float> &input)

+{

+ std::vector<float> r(input.size());

+

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

+ r[i] = input[i] + 0.5;

+

+ return r;

+}

+

+std::vector<int>

+int_vec_test0()

+{

+ std::vector<int> r(5);

+

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

+ r[i] = (int) i;

+

+ return r;

+}

+

+std::vector<int>

+int_vec_test1(const std::vector<int> &input)

+{

+ std::vector<int> r(input.size());

+

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

+ r[i] = input[i] + 1;

+

+ return r;

+}

+

+#include <gr_runtime_api.h>

+#include <vector>

+#include <complex>

+

+GR_RUNTIME_API std::vector<std::complex<float> >

+complex_vec_test0();

+

+GR_RUNTIME_API std::vector<std::complex<float> >

+complex_vec_test1(const std::vector<std::complex<float> > &input);

+

+GR_RUNTIME_API std::complex<float>

+complex_scalar_test0();

+

+GR_RUNTIME_API std::complex<float>

+complex_scalar_test1(std::complex<float> input);

+

+GR_RUNTIME_API std::vector<int>

+int_vec_test0();

+

+GR_RUNTIME_API std::vector<int>

+int_vec_test1(const std::vector<int> &input);

+

+GR_RUNTIME_API std::vector<float>

+float_vec_test0();

+

+GR_RUNTIME_API std::vector<float>

+float_vec_test1(const std::vector<float> &input);

+

+/*

+ * Copyright 2012 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.

+ */

+

+#include <gnuradio.ice>

+

+[["python:package:gnuradio.ctrlport"]]

+module GNURadio {

+ module Frontend {

+

+ exception NotSupported {};

+ exception InvalidSetting { string msg; };

+ exception ReceiverFailure { string msg; };

+ exception NotExist {};

+ dictionary<string, string> TunerArgs;

+

+ struct TunerStatus {

+ int a2dbits;

+ float gain;

+ bool isInverted;

+ };

+

+ interface Tuner {

+ TunerStatus configureTuner(TunerArgs args); //ADDED

+ idempotent TunerStatus status();

+ idempotent float setGain(float gain) throws NotSupported, InvalidSetting;

+ idempotent bool setInversion(bool inverted) throws NotSupported, InvalidSetting;

+ };

+

+ struct ChannelStatus {

+ string uid;

+ bool active;

+ float freq;

+ float bandwidth;

+ int payloadBits;

+ bool isComplex;

+ string signalName;

+ };

+

+ interface Channel extends Component {

+ idempotent ChannelStatus status();

+ idempotent FeedInfo feed();

+ idempotent bool active();

+ void start();

+ void stop();

+ idempotent float setCenterFreq(float freq) throws NotSupported, InvalidSetting;

+ idempotent float setBandwidth(float bw) throws NotSupported, InvalidSetting;

+ idempotent int setPayloadBits(int bits) throws NotSupported, InvalidSetting;

+ idempotent bool setComplex(bool complex) throws NotSupported, InvalidSetting;

+ void removeChannel() throws NotSupported;

+ };

+

+ sequence<Tuner*> TunerSeq;

+ sequence<Channel*> ChannelSeq;

+

+ struct ChannelizerStatus {

+ string uid;

+ string signalName;

+ };

+

+ interface Channelizer extends Component {

+ idempotent ChannelizerStatus status();

+ idempotent Tuner* getTuner();

+ idempotent ChannelSeq getChannels();

+ idempotent ChannelSeq getActiveChannels();

+ idempotent ChannelSeq getInactiveChannels();

+ Channel* createChannel(float freq, float bw, int payloadBits, string address, int port) throws NotSupported;

+ };

+

+ sequence<Channelizer*> ChannelizerSeq;

+

+ interface Receiver extends AbstractReceiver {

+ idempotent ChannelizerSeq getInputs();

+// idempotent ChannelizerSeq getActiveInputs();

+// idempotent ChannelizerSeq getInactiveInputs();

+ idempotent Channel* getChannelByID(string id) throws NotExist;

+ idempotent Channelizer* getChannelizerByID(string id) throws NotExist;

+ };

+

+

+ };

+

+

+

+};

+#!/usr/bin/env python

+#

+# Copyright 2004 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.

+#

+

+import math

+import sys

+

+def wrap (x):

+ if x >= 2**31:

+ return x - 2**32

+ return x

+

+def gen_approx_table (f, nentries, min_x, max_x):

+ """return a list of nentries containing tuples of the form:

+ (m, c, abs_error). min_x and max_x specify the domain

+ of the table.

+ """

+ r = []

+ incx = float (max_x - min_x) / nentries

+ for i in range (nentries):

+ a = (i * incx) + min_x

+ b = ((i + 1) * incx) + min_x

+ m = (f(b)-f(a))/(b-a)

+ c = (3*a+b)*(f(a)-f(b))/(4*(b-a)) + (f((a+b)/2) + f(a))/2

+ abs_error = c+m*a-f(a)

+ r.append ((m, c, abs_error))

+ return r

+

+def scaled_sine (x):

+ return math.sin (x * math.pi / 2**31)

+

+def gen_sine_table ():

+ nbits = 10

+ nentries = 2**nbits

+

+ # min_x = -2**31

+ # max_x = 2**31-1

+ min_x = 0

+ max_x = 2**32-1

+ t = gen_approx_table (scaled_sine, nentries, min_x, max_x)

+

+ max_error = 0

+ for e in t:

+ max_error = max (max_error, abs (e[2]))

+

+ # sys.stdout.write ('static const int WORDBITS = 32;\n')

+ # sys.stdout.write ('static const int NBITS = %d;\n' % (nbits,))

+

+ sys.stdout.write (' // max_error = %22.15e\n' % (max_error,))

+

+ # sys.stdout.write ('static const double sine_table[%d][2] = {\n'% (nentries,))

+

+ for e in t:

+ sys.stdout.write (' { %22.15e, %22.15e },\n' % (2 * e[0], e[1]))

+

+ # sys.stdout.write ('};\n')

+

+if __name__ == '__main__':

+ gen_sine_table ()

+/*

+ * Copyright 2012 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.

+ */

+

+[["python:package:gnuradio.ctrlport"]]

+

+#ifndef GNURADIO_DEBUG

+#define GNURADIO_DEBUG

+

+module GNURadio {

+class Knob {};

+class KnobB extends Knob { bool value; };

+class KnobC extends Knob { byte value; };

+class KnobI extends Knob { int value; };

+class KnobF extends Knob { float value; };

+class KnobD extends Knob { double value; };

+class KnobL extends Knob { long value; };

+class KnobS extends Knob { string value; };

+

+sequence<bool> VectorB; sequence<byte> VectorC;

+sequence<int> VectorI; sequence<float> VectorF;

+sequence<double> VectorD; sequence<string> VectorS;

+sequence<long> VectorL;

+

+class KnobVecB extends Knob { VectorB value; };

+class KnobVecC extends Knob { VectorC value; };

+class KnobVecI extends Knob { VectorI value; };

+class KnobVecF extends Knob { VectorF value; };

+class KnobVecD extends Knob { VectorD value; };

+class KnobVecL extends Knob { VectorL value; };

+class KnobVecS extends Knob { VectorS value; };

+

+enum KnobType { KNOBBOOL, KNOBCHAR, KNOBINT, KNOBFLOAT,

+ KNOBDOUBLE, KNOBSTRING, KNOBLONG, KNOBVECBOOL,

+ KNOBVECCHAR, KNOBVECINT, KNOBVECFLOAT, KNOBVECDOUBLE,

+ KNOBVECSTRING, KNOBVECLONG };

+

+const int DISPNULL = 0x0000;

+const int DISPTIME = 0x0001;

+const int DISPXY = 0x0002;

+const int DISPPSD = 0x0004;

+const int DISPSPEC = 0x0008;

+const int DISPRAST = 0x0010;

+const int DISPOPTCPLX = 0x0100;

+const int DISPOPTLOG = 0x0200;

+const int DISPOPTSTEM = 0x0400;

+const int DISPOPTSTRIP = 0x0800;

+const int DISPOPTSCATTER = 0x1000;

+

+struct KnobProp {

+ KnobType type;

+ string units;

+ string description;

+ int display;

+ Knob min;

+ Knob max;

+ Knob defaultvalue;

+};

+

+sequence<string> KnobIDList;

+dictionary<string, Knob> KnobMap;

+dictionary<string, KnobProp> KnobPropMap;

+dictionary<string, string> WaveformArgMap;

+

+interface StreamReceiver {

+ void push(VectorC data);

+};

+

+interface ControlPort {

+ void set(KnobMap knobs);

+ idempotent KnobMap get(KnobIDList knobs);

+ idempotent KnobPropMap properties(KnobIDList knobs);

+ void shutdown();

+

+// string subscribe(StreamReceiver* proxy, string streamName, int requestedPeriod, int RequestedSize);

+// idempotent void unsubscribe(string streamID);

+};

+

+struct FeedInfo {

+ string protocol;

+ string address;

+ string iface;

+ string port;

+};

+

+//TODO: convert this part to a Feed Info

+struct ReceiverInfo {

+ string uid;

+ string signalType;

+ string signalName;

+ string allocatableObjectID;

+ string signalProtocol;

+ string signalAddress;

+ string signalInterface;

+ string signalPort;

+};

+

+interface Component {

+ void setName(string newName);

+};

+

+module Frontend {

+ interface AbstractReceiver extends Component {

+ idempotent ReceiverInfo getReceiverInfo();

+ };

+};

+

+module Booter {

+ dictionary<string, string> WaveformArgs;

+

+ exception WaveformRunningError {

+ string waveformClass;

+ float centerFrequencyHz;

+ };

+ exception SignalSourceError {string msg; };

+

+ interface WaveformBooter extends Frontend::AbstractReceiver {

+ string launchWaveform(string waveformClass, WaveformArgs args)

+ throws WaveformRunningError, SignalSourceError;

+

+// string launchWaveformWithSession(string waveformClass, WaveformArgs args, IceGrid::Session* session)

+// throws WaveformRunningError;

+ WaveformArgMap getDriverEnum();

+ WaveformArgMap getSourceInfo();

+ idempotent bool waveformRunning();

+ idempotent string getWaveformClass();

+ void shutdown();

+ };

+};

+

+//interface Pingable {

+// bool ping();

+//};

+

+};

+

+#endif

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

+/*

+ * Copyright 2006,2012 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_basic_block.h>

+#include <gr_block_registry.h>

+#include <stdexcept>

+#include <sstream>

+#include <iostream>

+

+static long s_next_id = 0;

+static long s_ncurrently_allocated = 0;

+

+long

+gr_basic_block_ncurrently_allocated()

+{

+ return s_ncurrently_allocated;

+}

+

+gr_basic_block::gr_basic_block(const std::string &name,

+ gr_io_signature_sptr input_signature,

+ gr_io_signature_sptr output_signature)

+ : d_name(name),

+ d_input_signature(input_signature),

+ d_output_signature(output_signature),

+ d_unique_id(s_next_id++),

+ d_symbolic_id(global_block_registry.block_register(this)),

+ d_symbol_name(global_block_registry.register_symbolic_name(this)),

+ d_color(WHITE),

+ d_rpc_set(false),

+ message_subscribers(pmt::make_dict())

+{

+ s_ncurrently_allocated++;

+}

+

+gr_basic_block::~gr_basic_block()

+{

+ s_ncurrently_allocated--;

+ global_block_registry.block_unregister(this);

+}

+

+gr_basic_block_sptr

+gr_basic_block::to_basic_block()

+{

+ return shared_from_this();

+}

+

+void

+gr_basic_block::set_block_alias(std::string name)

+{

+ global_block_registry.register_symbolic_name(this, name);

+}

+

+// ** Message passing interface **

+

+// - register a new input message port

+void

+gr_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());

+}

+

+pmt::pmt_t

+gr_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++;

+ }

+ return port_names;

+}

+

+// - register a new output message port

+void

+gr_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(message_subscribers, port_id)) {

+ throw std::runtime_error("message_port_register_out: port already in use");

+ }

+ message_subscribers = pmt::dict_add(message_subscribers, port_id, pmt::PMT_NIL);

+}

+

+pmt::pmt_t

+gr_basic_block::message_ports_out()

+{

+ size_t len = pmt::length(message_subscribers);

+ pmt::pmt_t port_names = pmt::make_vector(len, pmt::PMT_NIL);

+ pmt::pmt_t keys = pmt::dict_keys(message_subscribers);

+ 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 gr_basic_block::message_port_pub(pmt::pmt_t port_id, pmt::pmt_t msg)

+{

+ if(!pmt::dict_has_key(message_subscribers, port_id)) {

+ throw std::runtime_error("port does not exist");

+ }

+

+ pmt::pmt_t currlist = pmt::dict_ref(message_subscribers, port_id, pmt::PMT_NIL);

+ // 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 port = pmt::cdr(target);

+

+ currlist = pmt::cdr(currlist);

+ gr_basic_block_sptr blk = global_block_registry.block_lookup(block);

+ //blk->post(msg);

+ blk->post(port, msg);

+ }

+}

+

+// - subscribe to a message port

+void

+gr_basic_block::message_port_sub(pmt::pmt_t port_id, pmt::pmt_t target){

+ if(!pmt::dict_has_key(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(message_subscribers,port_id,pmt::PMT_NIL);

+

+ // ignore re-adds of the same target

+ if(!pmt::list_has(currlist, target))

+ message_subscribers = pmt::dict_add(message_subscribers,port_id,pmt::list_add(currlist,target));

+}

+

+void

+gr_basic_block::message_port_unsub(pmt::pmt_t port_id, pmt::pmt_t target){

+ if(!pmt::dict_has_key(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(message_subscribers,port_id,pmt::PMT_NIL);

+ message_subscribers = pmt::dict_add(message_subscribers,port_id,pmt::list_rm(currlist,target));

+}

+

+void

+gr_basic_block::_post(pmt::pmt_t which_port, pmt::pmt_t msg)

+{

+ insert_tail(which_port, msg);

+}

+

+void

+gr_basic_block::insert_tail(pmt::pmt_t which_port, pmt::pmt_t msg)

+{

+ gruel::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!");

+ }

+

+ msg_queue[which_port].push_back(msg);

+ msg_queue_ready[which_port]->notify_one();

+

+ // wake up thread if BLKD_IN or BLKD_OUT

+ global_block_registry.notify_blk(alias());

+}

+

+pmt::pmt_t

+gr_basic_block::delete_head_nowait(pmt::pmt_t which_port)

+{

+ gruel::scoped_lock guard(mutex);

+

+ 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

+gr_basic_block::delete_head_blocking(pmt::pmt_t which_port)

+{

+ gruel::scoped_lock guard(mutex);

+

+ while (empty_p(which_port)){

+ msg_queue_ready[which_port]->wait(guard);

+ }

+

+ pmt::pmt_t m(msg_queue[which_port].front());

+ msg_queue[which_port].pop_front();

+ return m;

+}

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

+/*

+ * Copyright 2004,2009,2010,2013 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_block.h>

+#include <gr_block_detail.h>

+#include <stdexcept>

+#include <iostream>

+#include <gr_block_registry.h>

+#include <gr_prefs.h>

+

+gr_block::gr_block (const std::string &name,

+ gr_io_signature_sptr input_signature,

+ gr_io_signature_sptr output_signature)

+ : gr_basic_block(name, input_signature, output_signature),

+ d_output_multiple (1),

+ d_output_multiple_set(false),

+ d_unaligned(0),

+ d_is_unaligned(false),

+ d_relative_rate (1.0),

+ d_history(1),

+ d_fixed_rate(false),

+ d_max_noutput_items_set(false),

+ d_max_noutput_items(0),

+ d_min_noutput_items(0),

+ d_tag_propagation_policy(TPP_ALL_TO_ALL),

+ d_pc_rpc_set(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)

+{

+ global_block_registry.register_primitive(alias(), this);

+

+#ifdef ENABLE_GR_LOG

+#ifdef HAVE_LOG4CPP

+ gr_prefs *p = gr_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", "");

+ std::string debug_level = p->get_string("LOG", "debug_level", "off");

+ std::string debug_file = p->get_string("LOG", "debug_file", "");

+

+ GR_CONFIG_LOGGER(config_file);

+

+ GR_LOG_GETLOGGER(LOG, "gr_log." + alias());

+ GR_LOG_SET_LEVEL(LOG, log_level);

+ if(log_file.size() > 0) {

+ if(log_file == "stdout") {

+ GR_LOG_ADD_CONSOLE_APPENDER(LOG, "cout","gr::log :%p: %c{1} - %m%n");

+ }

+ else if(log_file == "stderr") {

+ GR_LOG_ADD_CONSOLE_APPENDER(LOG, "cerr","gr::log :%p: %c{1} - %m%n");

+ }

+ else {

+ GR_LOG_ADD_FILE_APPENDER(LOG, log_file , true,"%r :%p: %c{1} - %m%n");

+ }

+ }

+ d_logger = LOG;

+

+ GR_LOG_GETLOGGER(DLOG, "gr_log_debug." + alias());

+ GR_LOG_SET_LEVEL(DLOG, debug_level);

+ if(debug_file.size() > 0) {

+ if(debug_file == "stdout") {

+ GR_LOG_ADD_CONSOLE_APPENDER(DLOG, "cout","gr::debug :%p: %c{1} - %m%n");

+ }

+ else if(debug_file == "stderr") {

+ GR_LOG_ADD_CONSOLE_APPENDER(DLOG, "cerr", "gr::debug :%p: %c{1} - %m%n");

+ }

+ else {

+ GR_LOG_ADD_FILE_APPENDER(DLOG, debug_file, true, "%r :%p: %c{1} - %m%n");

+ }

+ }

+ d_debug_logger = DLOG;

+#endif /* HAVE_LOG4CPP */

+#else /* ENABLE_GR_LOG */

+ d_logger = NULL;

+ d_debug_logger = NULL;

+#endif /* ENABLE_GR_LOG */

+}

+

+gr_block::~gr_block ()

+{

+ global_block_registry.unregister_primitive(alias());

+}

+

+// stub implementation: 1:1

+

+void

+gr_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

+gr_block::start()

+{

+ return true;

+}

+

+bool

+gr_block::stop()

+{

+ return true;

+}

+

+void

+gr_block::set_output_multiple (int multiple)

+{

+ if (multiple < 1)

+ throw std::invalid_argument ("gr_block::set_output_multiple");

+

+ d_output_multiple_set = true;

+ d_output_multiple = multiple;

+}

+

+void

+gr_block::set_alignment (int multiple)

+{

+ if (multiple < 1)

+ throw std::invalid_argument ("gr_block::set_alignment_multiple");

+

+ d_output_multiple = multiple;

+}

+

+void

+gr_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 ("gr_block::set_unaligned");

+

+ d_unaligned = na;

+}

+

+void

+gr_block::set_is_unaligned (bool u)

+{

+ d_is_unaligned = u;

+}

+

+void

+gr_block::set_relative_rate (double relative_rate)

+{

+ if (relative_rate < 0.0)

+ throw std::invalid_argument ("gr_block::set_relative_rate");

+

+ d_relative_rate = relative_rate;

+}

+

+

+void

+gr_block::consume (int which_input, int how_many_items)

+{

+ d_detail->consume (which_input, how_many_items);

+}

+

+void

+gr_block::consume_each (int how_many_items)

+{

+ d_detail->consume_each (how_many_items);

+}

+

+void

+gr_block::produce (int which_output, int how_many_items)

+{

+ d_detail->produce (which_output, how_many_items);

+}

+

+int

+gr_block::fixed_rate_ninput_to_noutput(int ninput)

+{

+ throw std::runtime_error("Unimplemented");

+}

+

+int

+gr_block::fixed_rate_noutput_to_ninput(int noutput)

+{

+ throw std::runtime_error("Unimplemented");

+}

+

+uint64_t

+gr_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

+gr_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

+gr_block::add_item_tag(unsigned int which_output,

+ const gr_tag_t &tag)

+{

+ d_detail->add_item_tag(which_output, tag);

+}

+

+void

+gr_block::remove_item_tag(unsigned int which_input,

+ const gr_tag_t &tag)

+{

+ d_detail->remove_item_tag(which_input, tag);

+}

+

+void

+gr_block::get_tags_in_range(std::vector<gr_tag_t> &v,

+ unsigned int which_output,

+ uint64_t start, uint64_t end)

+{

+ d_detail->get_tags_in_range(v, which_output, start, end);

+}

+

+void

+gr_block::get_tags_in_range(std::vector<gr_tag_t> &v,

+ unsigned int which_output,

+ uint64_t start, uint64_t end,

+ const pmt::pmt_t &key)

+{

+ d_detail->get_tags_in_range(v, which_output, start, end, key);

+}

+

+gr_block::tag_propagation_policy_t

+gr_block::tag_propagation_policy()

+{

+ return d_tag_propagation_policy;

+}

+

+void

+gr_block::set_tag_propagation_policy(tag_propagation_policy_t p)

+{

+ d_tag_propagation_policy = p;

+}

+

+

+int

+gr_block::max_noutput_items()

+{

+ return d_max_noutput_items;

+}

+

+void

+gr_block::set_max_noutput_items(int m)

+{

+ if(m <= 0)

+ throw std::runtime_error("gr_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

+gr_block::unset_max_noutput_items()

+{

+ d_max_noutput_items_set = false;

+}

+

+bool

+gr_block::is_set_max_noutput_items()

+{

+ return d_max_noutput_items_set;

+}

+

+void

+gr_block::set_processor_affinity(const std::vector<unsigned int> &mask)

+{

+ d_affinity = mask;

+ if(d_detail) {

+ d_detail->set_processor_affinity(d_affinity);

+ }

+}

+

+void

+gr_block::unset_processor_affinity()

+{

+ d_affinity.clear();

+ if(d_detail) {

+ d_detail->unset_processor_affinity();

+ }

+}

+

+float

+gr_block::pc_noutput_items()

+{

+ if(d_detail) {

+ return d_detail->pc_noutput_items();

+ }

+ else {

+ return 0;

+ }

+}

+

+float

+gr_block::pc_noutput_items_avg()

+{

+ if(d_detail) {

+ return d_detail->pc_noutput_items_avg();

+ }

+ else {

+ return 0;

+ }

+}

+

+float

+gr_block::pc_noutput_items_var()

+{

+ if(d_detail) {

+ return d_detail->pc_noutput_items_var();

+ }

+ else {

+ return 0;

+ }

+}

+

+float

+gr_block::pc_nproduced()

+{

+ if(d_detail) {

+ return d_detail->pc_nproduced();

+ }

+ else {

+ return 0;

+ }

+}

+

+float

+gr_block::pc_nproduced_avg()

+{

+ if(d_detail) {

+ return d_detail->pc_nproduced_avg();

+ }

+ else {

+ return 0;

+ }

+}

+

+float

+gr_block::pc_nproduced_var()

+{

+ if(d_detail) {

+ return d_detail->pc_nproduced_var();

+ }

+ else {

+ return 0;

+ }

+}

+

+float

+gr_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

+gr_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

+gr_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>

+gr_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>

+gr_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>

+gr_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

+gr_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

+gr_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

+gr_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>

+gr_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>

+gr_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>

+gr_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

+gr_block::pc_work_time()

+{

+ if(d_detail) {

+ return d_detail->pc_work_time();

+ }

+ else {

+ return 0;

+ }

+}

+

+float

+gr_block::pc_work_time_avg()

+{

+ if(d_detail) {

+ return d_detail->pc_work_time_avg();

+ }

+ else {

+ return 0;

+ }

+}

+

+float

+gr_block::pc_work_time_var()

+{

+ if(d_detail) {

+ return d_detail->pc_work_time_var();

+ }

+ else {

+ return 0;

+ }

+}

+

+void

+gr_block::reset_perf_counters()

+{

+ if(d_detail) {

+ d_detail->reset_perf_counters();

+ }

+}

+

+void

+gr_block::setup_pc_rpc()

+{

+ d_pc_rpc_set = true;

+#ifdef GR_CTRLPORT

+ d_rpc_vars.push_back(

+ rpcbasic_sptr(new rpcbasic_register_get<gr_block, float>(

+ alias(), "noutput_items", &gr_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<gr_block, float>(

+ alias(), "avg noutput_items", &gr_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<gr_block, float>(

+ alias(), "var noutput_items", &gr_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<gr_block, float>(

+ alias(), "nproduced", &gr_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<gr_block, float>(

+ alias(), "avg nproduced", &gr_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<gr_block, float>(

+ alias(), "var nproduced", &gr_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<gr_block, float>(

+ alias(), "work time", &gr_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<gr_block, float>(

+ alias(), "avg work time", &gr_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<gr_block, float>(

+ alias(), "var work time", &gr_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<gr_block, std::vector<float> >(

+ alias(), "input \% full", &gr_block::pc_input_buffers_full,

+ pmt::make_c32vector(0,0), pmt::make_c32vector(0,1), pmt::make_c32vector(0,0),

+ "", "how full input buffers are", RPC_PRIVLVL_MIN,

+ DISPTIME | DISPOPTSTRIP)));

+

+ d_rpc_vars.push_back(

+ rpcbasic_sptr(new rpcbasic_register_get<gr_block, std::vector<float> >(

+ alias(), "avg input \% full", &gr_block::pc_input_buffers_full_avg,

+ pmt::make_c32vector(0,0), pmt::make_c32vector(0,1), pmt::make_c32vector(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<gr_block, std::vector<float> >(

+ alias(), "var input \% full", &gr_block::pc_input_buffers_full_var,

+ pmt::make_c32vector(0,0), pmt::make_c32vector(0,1), pmt::make_c32vector(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<gr_block, std::vector<float> >(

+ alias(), "output \% full", &gr_block::pc_output_buffers_full,

+ pmt::make_c32vector(0,0), pmt::make_c32vector(0,1), pmt::make_c32vector(0,0),

+ "", "how full output buffers are", RPC_PRIVLVL_MIN,

+ DISPTIME | DISPOPTSTRIP)));

+

+ d_rpc_vars.push_back(

+ rpcbasic_sptr(new rpcbasic_register_get<gr_block, std::vector<float> >(

+ alias(), "avg output \% full", &gr_block::pc_output_buffers_full_avg,

+ pmt::make_c32vector(0,0), pmt::make_c32vector(0,1), pmt::make_c32vector(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<gr_block, std::vector<float> >(

+ alias(), "var output \% full", &gr_block::pc_output_buffers_full_var,

+ pmt::make_c32vector(0,0), pmt::make_c32vector(0,1), pmt::make_c32vector(0,0),

+ "", "Var. of how full output buffers are", RPC_PRIVLVL_MIN,

+ DISPTIME | DISPOPTSTRIP)));

+#endif /* GR_CTRLPORT */

+}

+

+std::ostream&

+operator << (std::ostream& os, const gr_block *m)

+{

+ os << "<gr_block " << m->name() << " (" << m->unique_id() << ")>";

+ return os;

+}

+

+int

+gr_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("gr_block::general_work() not implemented");

+ return 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_block_detail.h>

+#include <gr_buffer.h>

+#include <iostream>

+

+static long s_ncurrently_allocated = 0;

+

+long

+gr_block_detail_ncurrently_allocated ()

+{

+ return s_ncurrently_allocated;

+}

+

+gr_block_detail::gr_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_done (false),

+ d_ins_noutput_items(0),

+ d_avg_noutput_items(0),

+ d_var_noutput_items(0),

+ d_ins_nproduced(0),

+ d_avg_nproduced(0),

+ d_var_nproduced(0),

+ d_ins_input_buffers_full(ninputs, 0),

+ d_avg_input_buffers_full(ninputs, 0),

+ d_var_input_buffers_full(ninputs, 0),

+ d_ins_output_buffers_full(noutputs, 0),

+ d_avg_output_buffers_full(noutputs, 0),

+ d_var_output_buffers_full(noutputs, 0),

+ d_ins_work_time(0),

+ d_avg_work_time(0),

+ d_var_work_time(0),

+ d_pc_counter(0)

+{

+ s_ncurrently_allocated++;

+}

+

+gr_block_detail::~gr_block_detail ()

+{

+ // should take care of itself

+ s_ncurrently_allocated--;

+}

+

+void

+gr_block_detail::set_input (unsigned int which, gr_buffer_reader_sptr reader)

+{

+ if (which >= d_ninputs)

+ throw std::invalid_argument ("gr_block_detail::set_input");

+

+ d_input[which] = reader;

+}

+

+void

+gr_block_detail::set_output (unsigned int which, gr_buffer_sptr buffer)

+{

+ if (which >= d_noutputs)

+ throw std::invalid_argument ("gr_block_detail::set_output");

+

+ d_output[which] = buffer;

+}

+

+gr_block_detail_sptr

+gr_make_block_detail (unsigned int ninputs, unsigned int noutputs)

+{

+ return gr_block_detail_sptr (new gr_block_detail (ninputs, noutputs));

+}

+

+void

+gr_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_ninputs; i++)

+ d_input[i]->set_done (done);

+}

+

+void

+gr_block_detail::consume (int which_input, int how_many_items)

+{

+ if (how_many_items > 0) {

+ input (which_input)->update_read_pointer (how_many_items);

+ }

+}

+

+

+void

+gr_block_detail::consume_each (int 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

+gr_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

+gr_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

+gr_block_detail::nitems_read(unsigned int which_input)

+{

+ if(which_input >= d_ninputs)

+ throw std::invalid_argument ("gr_block_detail::n_input_items");

+ return d_input[which_input]->nitems_read();

+}

+

+uint64_t

+gr_block_detail::nitems_written(unsigned int which_output)

+{

+ if(which_output >= d_noutputs)

+ throw std::invalid_argument ("gr_block_detail::n_output_items");

+ return d_output[which_output]->nitems_written();

+}

+

+void

+gr_block_detail::add_item_tag(unsigned int which_output, const gr_tag_t &tag)

+{

+ if(!pmt::is_symbol(tag.key)) {

+ throw pmt::wrong_type("gr_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

+gr_block_detail::remove_item_tag(unsigned int which_input, const gr_tag_t &tag)

+{

+ if(!pmt::is_symbol(tag.key)) {

+ throw pmt::wrong_type("gr_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);

+ }

+}

+

+void

+gr_block_detail::get_tags_in_range(std::vector<gr_tag_t> &v,

+ unsigned int which_input,

+ uint64_t abs_start,

+ uint64_t abs_end)

+{

+ // get from gr_buffer_reader's deque of tags

+ d_input[which_input]->get_tags_in_range(v, abs_start, abs_end);

+}

+

+void

+gr_block_detail::get_tags_in_range(std::vector<gr_tag_t> &v,

+ unsigned int which_input,

+ uint64_t abs_start,

+ uint64_t abs_end,

+ const pmt::pmt_t &key)

+{

+ std::vector<gr_tag_t> found_items;

+

+ v.resize(0);

+

+ // get from gr_buffer_reader's deque of tags

+ d_input[which_input]->get_tags_in_range(found_items, abs_start, abs_end);

+

+ // Filter further by key name

+ pmt::pmt_t itemkey;

+ std::vector<gr_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);

+ }

+ }

+}

+

+void

+gr_block_detail::set_processor_affinity(const std::vector<unsigned int> &mask)

+{

+ if(threaded) {

+ try {

+ gruel::thread_bind_to_processor(thread, mask);

+ }

+ catch (std::runtime_error e) {

+ std::cerr << "set_processor_affinity: invalid mask." << std::endl;;

+ }

+ }

+}

+

+void

+gr_block_detail::unset_processor_affinity()

+{

+ if(threaded) {

+ gruel::thread_unbind(thread);

+ }

+}

+

+void

+gr_block_detail::start_perf_counters()

+{

+ d_start_of_work = gruel::high_res_timer_now();

+}

+

+void

+gr_block_detail::stop_perf_counters(int noutput_items, int nproduced)

+{

+ d_end_of_work = gruel::high_res_timer_now();

+ gruel::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_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;

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

+ float pfull = static_cast<float>(d_input[i]->items_available()) /

+ static_cast<float>(d_input[i]->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++) {

+ float pfull = 1.0f - static_cast<float>(d_output[i]->space_available()) /

+ static_cast<float>(d_output[i]->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 = 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;

+

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

+ float pfull = static_cast<float>(d_input[i]->items_available()) /

+ static_cast<float>(d_input[i]->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++) {

+ float pfull = 1.0f - static_cast<float>(d_output[i]->space_available()) /

+ static_cast<float>(d_output[i]->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

+gr_block_detail::reset_perf_counters()

+{

+ d_pc_counter = 0;

+}

+

+float

+gr_block_detail::pc_noutput_items()

+{

+ return d_ins_noutput_items;

+}

+

+float

+gr_block_detail::pc_nproduced()

+{

+ return d_ins_nproduced;

+}

+

+float

+gr_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;

+}

+

+std::vector<float>

+gr_block_detail::pc_input_buffers_full()

+{

+ return d_ins_input_buffers_full;

+}

+

+float

+gr_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;

+}

+

+std::vector<float>

+gr_block_detail::pc_output_buffers_full()

+{

+ return d_ins_output_buffers_full;

+}

+

+float

+gr_block_detail::pc_work_time()

+{

+ return d_ins_work_time;

+}

+

+float

+gr_block_detail::pc_noutput_items_avg()

+{

+ return d_avg_noutput_items;

+}

+

+float

+gr_block_detail::pc_nproduced_avg()

+{

+ return d_avg_nproduced;

+}

+

+float

+gr_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;

+}

+

+std::vector<float>

+gr_block_detail::pc_input_buffers_full_avg()

+{

+ return d_avg_input_buffers_full;

+}

+

+float

+gr_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;

+}

+

+std::vector<float>

+gr_block_detail::pc_output_buffers_full_avg()

+{

+ return d_avg_output_buffers_full;

+}

+

+float

+gr_block_detail::pc_work_time_avg()

+{

+ return d_avg_work_time;

+}

+

+

+float

+gr_block_detail::pc_noutput_items_var()

+{

+ return d_var_noutput_items/(d_pc_counter-1);

+}

+

+float

+gr_block_detail::pc_nproduced_var()

+{

+ return d_var_nproduced/(d_pc_counter-1);

+}

+

+float

+gr_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;

+}

+

+std::vector<float>

+gr_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);

+ return var;

+}

+

+float

+gr_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;

+}

+

+std::vector<float>

+gr_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);

+ return var;

+}

+

+float

+gr_block_detail::pc_work_time_var()

+{

+ return d_var_work_time/(d_pc_counter-1);

+}

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

+/*

+ * Copyright 2004,2008,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_block_executor.h>

+#include <gr_block.h>

+#include <gr_block_detail.h>

+#include <gr_buffer.h>

+#include <gr_prefs.h>

+#include <boost/thread.hpp>

+#include <boost/format.hpp>

+#include <iostream>

+#include <limits>

+#include <assert.h>

+#include <stdio.h>

+

+// must be defined to either 0 or 1

+#define ENABLE_LOGGING 0

+

+#if (ENABLE_LOGGING)

+#define LOG(x) do { x; } while(0)

+#else

+#define LOG(x) do {;} while(0)

+#endif

+

+static int which_scheduler = 0;

+

+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)

+{

+ 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 (gr_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++){

+ gruel::scoped_lock guard(*d->output(i)->mutex());

+ int avail_n = round_down(d->output(i)->space_available(), output_multiple);

+ int best_n = round_down(d->output(i)->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 (d->output(i)->done()){ // Downstream is done, therefore we're done.

+ return -1;

+ }

+ return 0;

+ }

+ min_space = std::min (min_space, n);

+ }

+ return min_space;

+}

+

+static bool

+propagate_tags(gr_block::tag_propagation_policy_t policy, gr_block_detail *d,

+ const std::vector<uint64_t> &start_nitems_read, double rrate,

+ std::vector<gr_tag_t> &rtags)

+{

+ // Move tags downstream

+ // if a sink, we don't need to move downstream

+ if(d->sink_p()) {

+ return true;

+ }

+

+ switch(policy) {

+ case gr_block::TPP_DONT:

+ return true;

+ break;

+ case gr_block::TPP_ALL_TO_ALL:

+ // every tag on every input propogates to everyone downstream

+ for(int i = 0; i < d->ninputs(); i++) {

+ d->get_tags_in_range(rtags, i, start_nitems_read[i],

+ d->nitems_read(i));

+

+ std::vector<gr_tag_t>::iterator t;

+ if(rrate == 1.0) {

+ for(t = rtags.begin(); t != rtags.end(); t++) {

+ for(int o = 0; o < d->noutputs(); o++)

+ d->output(o)->add_item_tag(*t);

+ }

+ }

+ else {

+ for(t = rtags.begin(); t != rtags.end(); t++) {

+ gr_tag_t new_tag = *t;

+ new_tag.offset *= rrate;

+ for(int o = 0; o < d->noutputs(); o++)

+ d->output(o)->add_item_tag(new_tag);

+ }

+ }

+ }

+ break;

+ case gr_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 gr_block_detail

+ if(d->ninputs() == d->noutputs()) {

+ for(int i = 0; i < d->ninputs(); i++) {

+ d->get_tags_in_range(rtags, i, start_nitems_read[i],

+ d->nitems_read(i));

+

+ std::vector<gr_tag_t>::iterator t;

+ for(t = rtags.begin(); t != rtags.end(); t++) {

+ gr_tag_t new_tag = *t;

+ new_tag.offset *= rrate;

+ d->output(i)->add_item_tag(new_tag);

+ }

+ }

+ }

+ else {

+ std::cerr << "Error: gr_block_executor: propagation_policy 'ONE-TO-ONE' requires ninputs == noutputs" << std::endl;

+ return false;

+ }

+

+ break;

+ default:

+ return true;

+ }

+ return true;

+}

+

+gr_block_executor::gr_block_executor (gr_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 << "gr_block_executor: "

+ << d_block << std::endl;

+ }

+

+#ifdef GR_PERFORMANCE_COUNTERS

+ gr_prefs *prefs = gr_prefs::singleton();

+ d_use_pc = prefs->get_bool("PerfCounters", "on", false);

+#endif /* GR_PERFORMANCE_COUNTERS */

+

+ d_block->start(); // enable any drivers, etc.

+}

+

+gr_block_executor::~gr_block_executor ()

+{

+ if (ENABLE_LOGGING)

+ delete d_log;

+

+ d_block->stop(); // stop any drivers, etc.

+}

+

+gr_block_executor::state

+gr_block_executor::run_one_iteration()

+{

+ int noutput_items;

+ int max_items_avail;

+ int max_noutput_items = d_max_noutput_items;

+ int new_alignment=0;

+ int alignment_state=-1;

+

+ gr_block *m = d_block.get();

+ gr_block_detail *d = m->detail().get();

+

+ LOG(*d_log << std::endl << m);

+

+ 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

+ }

+

+ 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.

+ */

+ gruel::scoped_lock guard(*d->input(i)->mutex());

+ d_ninput_items[i] = d->input(i)->items_available();

+ d_input_done[i] = d->input(i)->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);

+

+ 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]);

+ }

+

+ // 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;

+ }

+

+ 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.

+ */

+ gruel::scoped_lock guard(*d->input(i)->mutex());

+ d_ninput_items[i] = d->input(i)->items_available ();

+ d_input_done[i] = d->input(i)->done();

+ }

+ 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 ";

+ if (m->relative_rate() >= 1.0)

+ *d_log << "1:" << m->relative_rate() << std::endl;

+ else

+ *d_log << 1.0/m->relative_rate() << ":1\n";

+ *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;

+ }

+ 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;

+ }

+ }

+

+ // 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

+

+ int i;

+ for (i = 0; i < d->ninputs (); i++)

+ if (d_ninput_items_required[i] > d_ninput_items[i]) // not enough

+ break;

+

+ 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;

+ }

+

+ // 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?

+ if (d_ninput_items_required[i] > d->input(i)->max_possible_items_available ()){

+ // Nope, never going to happen...

+ std::cerr << "\nsched: <gr_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"

+ << " max_possible_items_available = "

+ << d->input(i)->max_possible_items_available() << "\n"

+ << " If this is a filter, consider reducing the number of taps.\n";

+ 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);

+ }

+ 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();

+

+ 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();

+

+ // 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();

+#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);

+

+#ifdef GR_PERFORMANCE_COUNTERS

+ 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);

+ }

+

+ if(!propagate_tags(m->tag_propagation_policy(), d,

+ d_start_nitems_read, m->relative_rate(),

+ d_returned_tags))

+ goto were_done;

+

+ if (n == gr_block::WORK_DONE)

+ goto were_done;

+

+ if (n != gr_block::WORK_CALLED_PRODUCE)

+ d->produce_each (n); // advance write pointers

+

+ 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 << "gr_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:

+ LOG(*d_log << " were_done\n");

+ d->set_done (true);

+ return DONE;

+}

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

+/*

+ * Copyright 2004,2008 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.

+ */

+

+#ifndef INCLUDED_GR_BLOCK_EXECUTOR_H

+#define INCLUDED_GR_BLOCK_EXECUTOR_H

+

+#include <gr_runtime_api.h>

+#include <gr_runtime_types.h>

+#include <fstream>

+#include <gr_tags.h>

+

+//class gr_block_executor;

+//typedef boost::shared_ptr<gr_block_executor> gr_block_executor_sptr;

+

+

+/*!

+ * \brief Manage the execution of a single block.

+ * \ingroup internal

+ */

+

+class GR_RUNTIME_API gr_block_executor {

+protected:

+ gr_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<gr_tag_t> d_returned_tags;

+ int d_max_noutput_items;

+

+#ifdef GR_PERFORMANCE_COUNTERS

+ bool d_use_pc;

+#endif /* GR_PERFORMANCE_COUNTERS */

+

+ public:

+ gr_block_executor(gr_block_sptr block, int max_noutput_items=100000);

+ ~gr_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.

+ };

+

+ /*

+ * \brief Run one iteration.

+ */

+ state run_one_iteration();

+};

+

+#endif /* INCLUDED_GR_BLOCK_EXECUTOR_H */

+/*

+ * Copyright 2011-2012 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.

+ */

+

+#include <gr_block_gateway.h>

+#include <gr_io_signature.h>

+#include <iostream>

+#include <boost/bind.hpp>

+

+/***********************************************************************

+ * 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]);

+ }

+}

+

+/***********************************************************************

+ * The gr_block gateway implementation class

+ **********************************************************************/

+class gr_block_gateway_impl : public gr_block_gateway{

+public:

+ gr_block_gateway_impl(

+ gr_feval_ll *handler,

+ const std::string &name,

+ gr_io_signature_sptr in_sig,

+ gr_io_signature_sptr out_sig,

+ const gr_block_gw_work_type work_type,

+ const unsigned factor

+ ):

+ gr_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;

+

+ case GR_BLOCK_GW_WORK_SYNC:

+ _decim = 1;

+ _interp = 1;

+ this->set_fixed_rate(true);

+ break;

+

+ case GR_BLOCK_GW_WORK_DECIM:

+ _decim = factor;

+ _interp = 1;

+ break;

+

+ case GR_BLOCK_GW_WORK_INTERP:

+ _decim = 1;

+ _interp = factor;

+ this->set_output_multiple(_interp);

+ break;

+ }

+ }

+

+ /*******************************************************************

+ * Overloads for various scheduler-called functions

+ ******************************************************************/

+ void forecast(

+ int noutput_items,

+ gr_vector_int &ninput_items_required

+ ){

+ switch(_work_type){

+ case GR_BLOCK_GW_WORK_GENERAL:

+ _message.action = gr_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;

+ }

+ }

+

+ int 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 = gr_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 work(

+ int noutput_items,

+ gr_vector_const_void_star &input_items,

+ gr_vector_void_star &output_items

+ ){

+ _message.action = gr_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;

+ _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 fixed_rate_noutput_to_ninput(int noutput_items){

+ return (noutput_items*_decim/_interp) + history() - 1;

+ }

+

+ int fixed_rate_ninput_to_noutput(int ninput_items){

+ return std::max(0, ninput_items - (int)history() + 1)*_interp/_decim;

+ }

+

+ bool start(void){

+ _message.action = gr_block_gw_message_type::ACTION_START;

+ _handler->calleval(0);

+ return _message.start_args_return_value;

+ }

+

+ bool stop(void){

+ _message.action = gr_block_gw_message_type::ACTION_STOP;

+ _handler->calleval(0);

+ return _message.stop_args_return_value;

+ }

+

+ gr_block_gw_message_type &gr_block_message(void){

+ return _message;

+ }

+

+private:

+ gr_feval_ll *_handler;

+ gr_block_gw_message_type _message;

+ const gr_block_gw_work_type _work_type;

+ unsigned _decim, _interp;

+};

+

+boost::shared_ptr<gr_block_gateway> gr_make_block_gateway(

+ gr_feval_ll *handler,

+ const std::string &name,

+ gr_io_signature_sptr in_sig,

+ gr_io_signature_sptr out_sig,

+ const gr_block_gw_work_type work_type,

+ const unsigned factor

+){

+ return boost::shared_ptr<gr_block_gateway>(

+ new gr_block_gateway_impl(handler, name, in_sig, out_sig, work_type, factor)

+ );

+}

+#include <gr_basic_block.h>

+#include <gr_block_registry.h>

+#include <gr_tpb_detail.h>

+#include <gr_block_detail.h>

+#include <gr_block.h>

+#include <stdio.h>

+

+gr_block_registry global_block_registry;

+

+gr_block_registry::gr_block_registry(){

+ d_ref_map = pmt::make_dict();

+}

+

+long gr_block_registry::block_register(gr_basic_block* block){

+ 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 gr_block_registry::block_unregister(gr_basic_block* block){

+ 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()));

+ }

+}

+

+std::string gr_block_registry::register_symbolic_name(gr_basic_block* block){

+ std::stringstream ss;

+ ss << block->name() << block->symbolic_id();

+ //std::cout << "register_symbolic_name: " << ss.str() << std::endl;

+ register_symbolic_name(block, ss.str());

+ return ss.str();

+}

+

+void gr_block_registry::register_symbolic_name(gr_basic_block* block, std::string name){

+ if(dict_has_key(d_ref_map, pmt::intern(name))){

+ throw std::runtime_error("symbol already exists, can not re-use!");

+ }

+ d_ref_map = dict_add(d_ref_map, pmt::intern(name), pmt::make_any(block));

+}

+

+gr_basic_block_sptr gr_block_registry::block_lookup(pmt::pmt_t symbol){

+ pmt::pmt_t ref = 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!");

+ }

+ gr_basic_block* blk = boost::any_cast<gr_basic_block*>( pmt::any_ref(ref) );

+ return blk->shared_from_this();

+}

+

+

+void gr_block_registry::register_primitive(std::string blk, gr_block* ref){

+ primitive_map[blk] = ref;

+}

+

+void gr_block_registry::unregister_primitive(std::string blk){

+ primitive_map.erase(primitive_map.find(blk));

+}

+

+void gr_block_registry::notify_blk(std::string blk){

+ if(primitive_map.find(blk) == primitive_map.end()){ return; }

+ if(primitive_map[blk]->detail().get())

+ primitive_map[blk]->detail()->d_tpb.notify_msg();

+}

+

+/* -*- 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;

+}

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

+/*

+ * Copyright 2002,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_circular_file.h>

+

+#include <unistd.h>

+#ifdef HAVE_SYS_MMAN_H

+#include <sys/mman.h>

+#endif

+#include <sys/types.h>

+#include <sys/stat.h>

+#include <unistd.h>

+#include <fcntl.h>

+#include <stdio.h>

+#include <assert.h>

+#include <stdlib.h>

+

+#include <algorithm>

+#include <stdio.h>

+#include <string.h>

+

+#ifdef HAVE_IO_H

+#include <io.h>

+#endif

+

+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;

+

+gr_circular_file::gr_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){

+#ifdef HAVE_MMAP

+ 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);

+ }

+#endif

+ }

+ else {

+#ifdef HAVE_MMAP

+ mm_prot = PROT_READ;

+#endif

+ 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 (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);

+ }

+

+ d_header = (int *) p;

+#else

+ perror ("gr_circular_file: mmap unsupported by this system");

+ exit (1);

+#endif

+

+ if (writable){ // init header

+

+ 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;

+ }

+

+ // sanity check (the asserts are a bit unforgiving...)

+

+ assert (d_header[HD_MAGIC] == HEADER_MAGIC);

+ assert (d_header[HD_HEADER_SIZE] == HEADER_SIZE);

+ assert (d_header[HD_BUFFER_SIZE] > 0);

+ 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_bytes_read = 0;

+ d_buffer = (unsigned char *) d_header + d_header[HD_BUFFER_BASE];

+}

+

+gr_circular_file::~gr_circular_file ()

+{

+#ifdef HAVE_MMAP

+ if (munmap ((char *) d_header, d_mapped_size) < 0){

+ perror ("gr_circular_file: munmap");

+ exit (1);

+ }

+#endif

+ close (d_fd);

+}

+

+bool

+gr_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);

+

+ buffer_current += n;

+ if (buffer_current >= buffer_size)

+ buffer_current = 0;

+

+ data += n;

+ nbytes -= n;

+ }

+

+ d_header[HD_BUFFER_CURRENT] = buffer_current;

+ return true;

+}

+

+int

+gr_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;

+ }

+ return total;

+}

+

+void

+gr_circular_file::reset_read_pointer ()

+{

+ d_bytes_read = 0;

+}

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

+/*

+ * Copyright 2002 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.

+ */

+

+#ifndef _GR_CIRCULAR_FILE_H_

+#define _GR_CIRCULAR_FILE_H_

+

+#include <gr_runtime_api.h>

+

+/*

+ * 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 gr_circular_file {

+ int d_fd;

+ int *d_header;

+ unsigned char *d_buffer;

+ int d_mapped_size;

+ int d_bytes_read;

+

+public:

+ gr_circular_file (const char *filename, bool writable = false, int size = 0);

+ ~gr_circular_file ();

+

+ 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);

+

+ // reset read pointer to beginning of buffer.

+ void reset_read_pointer ();

+};

+

+#endif /* _GR_CIRCULAR_FILE_H_ */ \ No newline at end of file

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

+/*

+ * Copyright 2006,2009 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.

+ */

+

+#if HAVE_CONFIG_H

+#include <config.h>

+#endif

+

+#include <gr_constants.h>

+

+const std::string

+gr_prefix()

+{

+ return "@prefix@";

+}

+

+const std::string

+gr_sysconfdir()

+{

+ return "@SYSCONFDIR@";

+}

+

+const std::string

+gr_prefsdir()

+{

+ return "@GR_PREFSDIR@";

+}

+

+const std::string

+gr_build_date()

+{

+ return "@BUILD_DATE@";

+}

+

+const std::string

+gr_version()

+{

+ return "@VERSION@";

+}

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

+/*

+ * Copyright 2005 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_dispatcher.h>

+#include <math.h>

+#include <errno.h>

+#include <stdio.h>

+

+#ifdef HAVE_SELECT

+# ifdef HAVE_SYS_SELECT_H

+# include <sys/select.h>

+# else

+# ifdef HAVE_SYS_TIME_H

+# include <sys/time.h>

+# endif

+# ifdef HAVE_SYS_TYPES_H

+# include <sys/types.h>

+# endif

+# ifdef HAVE_UNISTD_H

+# include <unistd.h>

+# endif

+# endif

+#endif

+

+

+static gr_dispatcher_sptr s_singleton;

+

+gr_dispatcher_sptr

+gr_make_dispatcher()

+{

+ return gr_dispatcher_sptr(new gr_dispatcher());

+}

+

+gr_dispatcher_sptr

+gr_dispatcher_singleton()

+{

+ if (s_singleton)

+ return s_singleton;

+

+ s_singleton = gr_make_dispatcher();

+ return s_singleton;

+}

+

+#if !defined(HAVE_SELECT) // Stub it out

+

+gr_dispatcher::gr_dispatcher()

+{

+}

+

+gr_dispatcher::~gr_dispatcher()

+{

+}

+

+bool

+gr_dispatcher::add_handler(gr_select_handler_sptr handler)

+{

+ return true;

+}

+

+bool

+gr_dispatcher::del_handler(gr_select_handler_sptr handler)

+{

+ return true;

+}

+

+bool

+gr_dispatcher::del_handler(gr_select_handler *handler)

+{

+ return true;

+}

+

+void

+gr_dispatcher::loop(double timeout)

+{

+}

+

+#else // defined(HAVE_SELECT)

+

+gr_dispatcher::gr_dispatcher()

+ : d_handler(FD_SETSIZE), d_max_index(-1)

+{

+}

+

+gr_dispatcher::~gr_dispatcher()

+{

+}

+

+bool

+gr_dispatcher::add_handler(gr_select_handler_sptr handler)

+{

+ int fd = handler->fd();

+ if (fd < 0 || fd >= FD_SETSIZE)

+ return false;

+

+ d_max_index = std::max(d_max_index, fd);

+ d_handler[fd] = handler;

+ return true;

+}

+

+bool

+gr_dispatcher::del_handler(gr_select_handler_sptr handler)

+{

+ return del_handler(handler.get());

+}

+

+bool

+gr_dispatcher::del_handler(gr_select_handler *handler)

+{

+ int fd = handler->fd();

+ if (fd < 0 || fd >= FD_SETSIZE)

+ return false;

+

+ d_handler[fd].reset();

+

+ if (fd == d_max_index){

+ int i;

+ for (i = fd - 1; i >= 0 && !d_handler[i]; i--)

+ ;

+ d_max_index = i;

+ }

+ return true;

+}

+

+

+void

+gr_dispatcher::loop(double timeout)

+{

+ struct timeval master;

+ struct timeval tmp;

+ fd_set rd_set;

+ fd_set wr_set;

+

+ double secs = floor (timeout);

+ master.tv_sec = (long) secs;

+ master.tv_usec = (long) ((timeout - secs) * 1e6);

+

+ while (d_max_index >= 0){

+ FD_ZERO(&rd_set);

+ FD_ZERO(&wr_set);

+

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

+ if (d_handler[i] && d_handler[i]->readable())

+ FD_SET(i, &rd_set);

+ if (d_handler[i] && d_handler[i]->writable())

+ FD_SET(i, &wr_set);

+ }

+

+ tmp = master;

+ int retval = select(d_max_index+1, &rd_set, &wr_set, 0, &tmp);

+ if (retval == 0) // timed out with nothing ready

+ continue;

+ if (retval < 0){

+ if (errno == EINTR)

+ continue;

+ perror ("gr_dispatcher/select");

+ return;

+ }

+

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

+ if (FD_ISSET(i, &rd_set))

+ if (d_handler[i])

+ d_handler[i]->handle_read();

+ if (FD_ISSET(i, &wr_set))

+ if (d_handler[i])

+ d_handler[i]->handle_write();

+ }

+ }

+}

+

+#endif

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

+/*

+ * Copyright 2005 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.

+ */

+/*

+ * This code is based on error.cc from the "Click Modular Router".

+ * Original copyright follows:

+ */

+/*

+ * error.{cc,hh} -- flexible classes for error reporting

+ * Eddie Kohler

+ *

+ * Copyright (c) 1999-2000 Massachusetts Institute of Technology

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a

+ * copy of this software and associated documentation files (the "Software"),

+ * to deal in the Software without restriction, subject to the conditions

+ * listed in the Click LICENSE file. These conditions include: you must

+ * preserve this copyright notice, and you cannot mention the copyright

+ * holders in advertising related to the Software without their permission.

+ * The Software is provided WITHOUT ANY WARRANTY, EXPRESS OR IMPLIED. This

+ * notice is a summary of the Click LICENSE file; the license in that file is

+ * legally binding.

+ */

+

+#ifdef HAVE_CONFIG_H

+#include "config.h"

+#endif

+

+#include <gr_error_handler.h>

+#include <assert.h>

+#include <stdexcept>

+#include <unistd.h>

+

+#ifdef HAVE_IO_H

+#include <io.h>

+#endif

+

+static gr_error_handler *s_default_handler = 0;

+static gr_error_handler *s_silent_handler = 0;

+

+bool

+gr_error_handler::has_default_handler()

+{

+ return s_default_handler != 0;

+}

+

+void

+gr_error_handler::set_default_handler(gr_error_handler *errh)

+{

+ s_default_handler = errh;

+}

+

+gr_error_handler *

+gr_error_handler::default_handler()

+{

+ assert (s_default_handler != 0);

+ return s_default_handler;

+}

+

+gr_error_handler *

+gr_error_handler::silent_handler()

+{

+ assert (s_silent_handler != 0);

+ return s_silent_handler;

+}

+

+// ----------------------------------------------------------------

+

+gr_error_handler::~gr_error_handler()

+{

+ // nop

+}

+

+void

+gr_error_handler::debug(const char *format, ...)

+{

+ va_list val;

+ va_start(val, format);

+ verror(ERR_DEBUG, format, val);

+ va_end(val);

+}

+

+void

+gr_error_handler::message(const char *format, ...)

+{

+ va_list val;

+ va_start(val, format);

+ verror(ERR_MESSAGE, format, val);

+ va_end(val);

+}

+

+void

+gr_error_handler::warning(const char *format, ...)

+{

+ va_list val;

+ va_start(val, format);

+ verror(ERR_WARNING, format, val);

+ va_end(val);

+}

+

+void

+gr_error_handler::error(const char *format, ...)

+{

+ va_list val;

+ va_start(val, format);

+ verror(ERR_ERROR, format, val);

+ va_end(val);

+}

+

+void

+gr_error_handler::fatal(const char *format, ...)

+{

+ va_list val;

+ va_start(val, format);

+ verror(ERR_FATAL, format, val);

+ va_end(val);

+}

+

+void

+gr_error_handler::verror(seriousness s, const char *format, va_list val)

+{

+ std::string text = make_text(s, format, val);

+ handle_text(s, text);

+ count_error(s);

+}

+

+void

+gr_error_handler::verror_text(seriousness s, const std::string &text)

+{

+ // text is already made

+ handle_text(s, text);

+ count_error(s);

+}

+

+std::string

+gr_error_handler::make_text(seriousness s, const char *format, va_list val)

+{

+ char text_buf[4096];

+ vsnprintf(text_buf, sizeof(text_buf), format, val);

+ text_buf[sizeof(text_buf)-1] = 0;

+ return text_buf;

+}

+

+// ----------------------------------------------------------------

+

+void

+gr_base_error_handler::count_error(seriousness s)

+{

+ if (s < ERR_WARNING)

+ /* do nothing */;

+ else if (s < ERR_ERROR)

+ d_nwarnings++;

+ else

+ d_nerrors++;

+}

+

+// ----------------------------------------------------------------

+

+gr_file_error_handler::gr_file_error_handler(FILE *file)

+ : d_file(file), d_fd(-1)

+{

+}

+

+gr_file_error_handler::gr_file_error_handler(int file_descriptor)

+{

+ d_fd = dup(file_descriptor); // so we can fclose it

+ if (d_fd == -1){

+ perror("gr_file_error_handler:dup");

+ throw std::invalid_argument("gr_file_error_handler:dup");

+ }

+ d_file = fdopen(d_fd, "w");

+ if (d_file == 0){

+ perror("gr_file_error_handler:fdopen");

+ throw std::invalid_argument("gr_file_error_handler:fdopen");

+ }

+}

+

+gr_file_error_handler::~gr_file_error_handler()

+{

+ if (d_fd != -1){

+ fclose(d_file);

+ }

+}

+

+void

+gr_file_error_handler::handle_text(seriousness s, const std::string &text)

+{

+ if (text.length() <= 0)

+ return;

+

+ fwrite(text.data(), 1, text.length(), d_file);

+ if (text[text.length()-1] != '\n')

+ fwrite("\n", 1, 1, d_file);

+

+ if (d_fd != -1)

+ fflush(d_file); // keep synced with any other users of fd

+}

+

+

+// ----------------------------------------------------------------

+// static error handlers

+//

+

+class gr_silent_error_handler : public gr_base_error_handler

+{

+public:

+ gr_silent_error_handler() {}

+ void handle_text(seriousness s, const std::string &str);

+};

+

+void

+gr_silent_error_handler::handle_text(seriousness s, const std::string &str)

+{

+ // nop

+}

+

+class force_init {

+public:

+ force_init()

+ {

+ s_default_handler = new gr_file_error_handler(stdout);

+ s_silent_handler = new gr_silent_error_handler();

+ }

+};

+

+static force_init kludge;

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

+/*

+ * Copyright 2005 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.

+ */

+

+#include <gr_math.h> // declaration is in here

+#include <cmath>

+

+#define REAL float

+

+/***************************************************************************/

+/* Constant definitions */

+/***************************************************************************/

+

+#define TAN_MAP_RES 0.003921569 /* (smallest non-zero value in table) */

+#define RAD_PER_DEG 0.017453293

+#define TAN_MAP_SIZE 256

+

+/* arctangents from 0 to pi/4 radians */

+static REAL

+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.853983e-01,

+ 7.853983e-01

+ };

+

+

+/*****************************************************************************

+Function: Arc tangent

+

+Syntax: angle = fast_atan2(y, x);

+REAL y y component of input vector

+REAL x x component of input vector

+REAL 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

+symetry 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

++/- 0.045 degrees.

+*****************************************************************************/

+

+REAL

+gr_fast_atan2f(REAL y, REAL x)

+{

+ REAL x_abs, y_abs, z;

+ REAL alpha, angle, base_angle;

+ int index;

+

+ /* don't divide by zero! */ // FIXME could get hosed with -0.0

+ if ((y == 0.0) && (x == 0.0))

+ return 0.0;

+

+ /* normalize to +/- 45 degree range */

+ y_abs = fabs(y);

+ x_abs = fabs(x);

+ //z = (y_abs < x_abs ? y_abs / x_abs : x_abs / y_abs);

+ if (y_abs < x_abs)

+ z = y_abs / x_abs;

+ else

+ 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;

+ else {

+ /* find index and interpolation value */

+ alpha = z * (REAL) TAN_MAP_SIZE - .5;

+ index = (int) alpha;

+ alpha -= (REAL) 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 */

+ }

+ }

+

+#ifdef ZERO_TO_TWOPI

+ if (angle < 0)

+ return (angle + TWOPI);

+ else

+ return (angle);

+#else

+ return (angle);

+#endif

+}

+

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

+/*

+ * Copyright 2006 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_feval.h>

+

+gr_feval_dd::~gr_feval_dd(){}

+

+double

+gr_feval_dd::eval(double x)

+{

+ return 0;

+}

+

+double

+gr_feval_dd::calleval(double x)

+{

+ return eval(x);

+}

+

+// ----------------------------------------------------------------

+

+gr_feval_cc::~gr_feval_cc(){}

+

+gr_complex

+gr_feval_cc::eval(gr_complex x)

+{

+ return 0;

+}

+

+gr_complex

+gr_feval_cc::calleval(gr_complex x)

+{

+ return eval(x);

+}

+

+// ----------------------------------------------------------------

+

+gr_feval_ll::~gr_feval_ll(){}

+

+long

+gr_feval_ll::eval(long x)

+{

+ return 0;

+}

+

+long

+gr_feval_ll::calleval(long x)

+{

+ return eval(x);

+}

+

+// ----------------------------------------------------------------

+

+gr_feval::~gr_feval(){}

+

+void

+gr_feval::eval(void)

+{

+ // nop

+}

+

+void

+gr_feval::calleval(void)

+{

+ eval();

+}

+

+// ----------------------------------------------------------------

+

+gr_feval_p::~gr_feval_p(){}

+

+void

+gr_feval_p::eval(pmt::pmt_t x)

+{

+ // nop

+}

+

+void

+gr_feval_p::calleval(pmt::pmt_t x)

+{

+ eval(x);

+}

+

+/*

+ * Trivial examples showing C++ (transparently) calling Python

+ */

+double

+gr_feval_dd_example(gr_feval_dd *f, double x)

+{

+ return f->calleval(x);

+}

+

+gr_complex

+gr_feval_cc_example(gr_feval_cc *f, gr_complex x)

+{

+ return f->calleval(x);

+}

+

+long

+gr_feval_ll_example(gr_feval_ll *f, long x)

+{

+ return f->calleval(x);

+}

+

+void

+gr_feval_example(gr_feval *f)

+{

+ f->calleval();

+}

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

+/*

+ * Copyright 2007 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_flat_flowgraph.h>

+#include <gr_block_detail.h>

+#include <gr_io_signature.h>

+#include <gr_buffer.h>

+#include <gr_prefs.h>

+#include <volk/volk.h>

+#include <iostream>

+#include <map>

+#include <boost/format.hpp>

+

+#define GR_FLAT_FLOWGRAPH_DEBUG 0

+

+// 32Kbyte buffer size between blocks

+#define GR_FIXED_BUFFER_SIZE (32*(1L<<10))

+

+static const unsigned int s_fixed_buffer_size = GR_FIXED_BUFFER_SIZE;

+

+gr_flat_flowgraph_sptr

+gr_make_flat_flowgraph()

+{

+ return gr_flat_flowgraph_sptr(new gr_flat_flowgraph());

+}

+

+gr_flat_flowgraph::gr_flat_flowgraph()

+{

+}

+

+gr_flat_flowgraph::~gr_flat_flowgraph()

+{

+}

+

+void

+gr_flat_flowgraph::setup_connections()

+{

+ gr_basic_block_vector_t blocks = calc_used_blocks();

+

+ // Assign block details to blocks

+ for (gr_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(gr_basic_block_viter_t p = blocks.begin(); p != blocks.end(); p++) {

+ connect_block_inputs(*p);

+

+ gr_block_sptr block = cast_to_block_sptr(*p);

+ block->set_unaligned(0);

+ block->set_is_unaligned(false);

+ }

+

+ // Connect message ports connetions

+ for(gr_msg_edge_viter_t i = d_msg_edges.begin(); i != d_msg_edges.end(); i++){

+ if(GR_FLAT_FLOWGRAPH_DEBUG)

+ std::cout << 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()) );

+ }

+

+}

+

+gr_block_detail_sptr

+gr_flat_flowgraph::allocate_block_detail(gr_basic_block_sptr block)

+{

+ int ninputs = calc_used_ports(block, true).size();

+ int noutputs = calc_used_ports(block, false).size();

+ gr_block_detail_sptr detail = gr_make_block_detail(ninputs, noutputs);

+

+ gr_block_sptr grblock = cast_to_block_sptr(block);

+ if(!grblock)

+ throw std::runtime_error("allocate_block_detail found non-gr_block");

+

+ if (GR_FLAT_FLOWGRAPH_DEBUG)

+ std::cout << "Creating block detail for " << block << std::endl;

+

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

+ grblock->expand_minmax_buffer(i);

+

+ gr_buffer_sptr buffer = allocate_buffer(block, i);

+ if (GR_FLAT_FLOWGRAPH_DEBUG)

+ std::cout << "Allocated buffer for output " << block << ":" << i << std::endl;

+ detail->set_output(i, buffer);

+

+ // Update the block's max_output_buffer based on what was actually allocated.

+ grblock->set_max_output_buffer(i, buffer->bufsize());

+ }

+

+ return detail;

+}

+

+gr_buffer_sptr

+gr_flat_flowgraph::allocate_buffer(gr_basic_block_sptr block, int port)

+{

+ gr_block_sptr grblock = cast_to_block_sptr(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

+ // increase the available parallelism when using the TPB scheduler.

+ // (We're double buffering, where we used to single buffer)

+ 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 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

+ gr_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!");

+ }

+

+ for (gr_basic_block_viter_t p = blocks.begin(); p != blocks.end(); p++) {

+ gr_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)));

+ }

+

+// std::cout << "gr_make_buffer(" << nitems << ", " << item_size << ", " << grblock << "\n";

+ return gr_make_buffer(nitems, item_size, grblock);

+}

+

+void

+gr_flat_flowgraph::connect_block_inputs(gr_basic_block_sptr block)

+{

+ gr_block_sptr grblock = cast_to_block_sptr(block);

+ if (!grblock)

+ throw std::runtime_error("connect_block_inputs found non-gr_block");

+

+ // Get its detail and edges that feed into it

+ gr_block_detail_sptr detail = grblock->detail();

+ gr_edge_vector_t in_edges = calc_upstream_edges(block);

+

+ // For each edge that feeds into it

+ for (gr_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();

+ gr_basic_block_sptr src_block = e->src().block();

+ gr_block_sptr src_grblock = cast_to_block_sptr(src_block);

+ if (!src_grblock)

+ throw std::runtime_error("connect_block_inputs found non-gr_block");

+ gr_buffer_sptr src_buffer = src_grblock->detail()->output(src_port);

+

+ if (GR_FLAT_FLOWGRAPH_DEBUG)

+ std::cout << "Setting input " << dst_port << " from edge " << (*e) << std::endl;

+

+ detail->set_input(dst_port, gr_buffer_add_reader(src_buffer, grblock->history()-1, grblock));

+ }

+}

+

+void

+gr_flat_flowgraph::merge_connections(gr_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 (gr_basic_block_viter_t p = d_blocks.begin(); p != d_blocks.end(); p++) {

+ gr_block_sptr block = cast_to_block_sptr(*p);

+

+ if (!block->detail()) {

+ if (GR_FLAT_FLOWGRAPH_DEBUG)

+ std::cout << "merge: allocating new detail for block " << (*p) << std::endl;

+ block->set_detail(allocate_block_detail(block));

+ }

+ else

+ if (GR_FLAT_FLOWGRAPH_DEBUG)

+ std::cout << "merge: reusing original detail for block " << (*p) << std::endl;

+ }

+

+ // Calculate the old edges that will be going away, and clear the buffer readers

+ // on the RHS.

+ for (gr_edge_viter_t old_edge = old_ffg->d_edges.begin(); old_edge != old_ffg->d_edges.end(); old_edge++) {

+ if (GR_FLAT_FLOWGRAPH_DEBUG)

+ std::cout << "merge: testing old edge " << (*old_edge) << "...";

+

+ gr_edge_viter_t new_edge;

+ for (new_edge = d_edges.begin(); new_edge != d_edges.end(); new_edge++)

+ if (new_edge->src() == old_edge->src() &&

+ new_edge->dst() == old_edge->dst())

+ break;

+

+ if (new_edge == d_edges.end()) { // not found in new edge list

+ if (GR_FLAT_FLOWGRAPH_DEBUG)

+ std::cout << "not in new edge list" << std::endl;

+ // zero the buffer reader on RHS of old edge

+ gr_block_sptr block(cast_to_block_sptr(old_edge->dst().block()));

+ int port = old_edge->dst().port();

+ block->detail()->set_input(port, gr_buffer_reader_sptr());

+ }

+ else {

+ if (GR_FLAT_FLOWGRAPH_DEBUG)

+ std::cout << "found in new edge list" << std::endl;

+ }

+ }

+

+ // Now connect inputs to outputs, reusing old buffer readers if they exist

+ for (gr_basic_block_viter_t p = d_blocks.begin(); p != d_blocks.end(); p++) {

+ gr_block_sptr block = cast_to_block_sptr(*p);

+

+ if (GR_FLAT_FLOWGRAPH_DEBUG)

+ std::cout << "merge: merging " << (*p) << "...";

+

+ if (old_ffg->has_block_p(*p)) {

+ // Block exists in old flow graph

+ if (GR_FLAT_FLOWGRAPH_DEBUG)

+ std::cout << "used in old flow graph" << std::endl;

+ gr_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++) {

+ if (GR_FLAT_FLOWGRAPH_DEBUG)

+ std::cout << "Checking input " << block << ":" << i << "...";

+ gr_edge edge = calc_upstream_edge(*p, i);

+

+ // Fish out old buffer reader and see if it matches correct buffer from edge list

+ gr_block_sptr src_block = cast_to_block_sptr(edge.src().block());

+ gr_block_detail_sptr src_detail = src_block->detail();

+ gr_buffer_sptr src_buffer = src_detail->output(edge.src().port());

+ gr_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())) {

+ if (GR_FLAT_FLOWGRAPH_DEBUG)

+ std::cout << "matched, reusing" << std::endl;

+ }

+ else {

+ if (GR_FLAT_FLOWGRAPH_DEBUG)

+ std::cout << "needs a new reader" << std::endl;

+

+ // Create new buffer reader and assign

+ detail->set_input(i, gr_buffer_add_reader(src_buffer, block->history()-1, block));

+ }

+ }

+ }

+ else {

+ // Block is new, it just needs buffer readers at this point

+ if (GR_FLAT_FLOWGRAPH_DEBUG)

+ std::cout << "new block" << std::endl;

+ connect_block_inputs(block);

+

+ // Make sure all buffers are aligned

+ setup_buffer_alignment(block);

+ }

+

+ // Now deal with the fact that the block details might have changed numbers of

+ // inputs and outputs vs. in the old flowgraph.

+ }

+}

+

+void

+gr_flat_flowgraph::setup_buffer_alignment(gr_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();

+ unsigned long int ri = (unsigned long int)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();

+ unsigned long int wi = (unsigned long int)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

+gr_flat_flowgraph::edge_list()

+{

+ std::stringstream s;

+ for(gr_edge_viter_t e = d_edges.begin(); e != d_edges.end(); e++)

+ s << (*e) << std::endl;

+ return s.str();

+}

+

+void gr_flat_flowgraph::dump()

+{

+ for (gr_edge_viter_t e = d_edges.begin(); e != d_edges.end(); e++)

+ std::cout << " edge: " << (*e) << std::endl;

+

+ for (gr_basic_block_viter_t p = d_blocks.begin(); p != d_blocks.end(); p++) {

+ std::cout << " block: " << (*p) << std::endl;

+ gr_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++) {

+ gr_buffer_sptr buffer = detail->output(i);

+ std::cout << " output " << i << ": " << buffer << std::endl;

+ }

+

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

+ gr_buffer_reader_sptr reader = detail->input(i);

+ std::cout << " reader " << i << ": " << reader

+ << " reading from buffer=" << reader->buffer() << std::endl;

+ }

+ }

+

+}

+

+gr_block_vector_t

+gr_flat_flowgraph::make_block_vector(gr_basic_block_vector_t &blocks)

+{

+ gr_block_vector_t result;

+ for (gr_basic_block_viter_t p = blocks.begin(); p != blocks.end(); p++) {

+ result.push_back(cast_to_block_sptr(*p));

+ }

+

+ return result;

+}

+

+

+void gr_flat_flowgraph::clear_endpoint(const gr_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 gr_flat_flowgraph::replace_endpoint(const gr_msg_endpoint &e, const gr_msg_endpoint &r, bool is_src){

+ size_t n_replr(0);

+ if(GR_FLAT_FLOWGRAPH_DEBUG)

+ std::cout << boost::format("gr_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){

+ if(GR_FLAT_FLOWGRAPH_DEBUG)

+ std::cout << boost::format("gr_flat_flowgraph::replace_endpoint() flattening to ( %s, %s )\n") % r.block()% d_msg_edges[i].dst().block();

+ d_msg_edges.push_back( gr_msg_edge(r, d_msg_edges[i].dst() ) );

+ n_replr++;

+ }

+ } else {

+ if(d_msg_edges[i].dst() == e){

+ if(GR_FLAT_FLOWGRAPH_DEBUG)

+ std::cout << boost::format("gr_flat_flowgraph::replace_endpoint() flattening to ( %s, %s )\n") % r.block()% d_msg_edges[i].dst().block();

+ d_msg_edges.push_back( gr_msg_edge(d_msg_edges[i].src(), r ) );

+ n_replr++;

+ }

+ }

+ }

+}

+

+void

+gr_flat_flowgraph::enable_pc_rpc()

+{

+#ifdef GR_PERFORMANCE_COUNTERS

+ if(gr_prefs::singleton()->get_bool("PerfCounters", "on", false)) {

+ gr_basic_block_viter_t p;

+ for(p = d_blocks.begin(); p != d_blocks.end(); p++) {

+ gr_block_sptr block = cast_to_block_sptr(*p);

+ if(!block->is_pc_rpc_set())

+ block->setup_pc_rpc();

+ }

+ }

+#endif /* GR_PERFORMANCE_COUNTERS */

+}

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

+/*

+ * Copyright 2006,2007 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.

+ */

+

+#ifndef INCLUDED_GR_FLAT_FLOWGRAPH_H

+#define INCLUDED_GR_FLAT_FLOWGRAPH_H

+

+#include <gr_runtime_api.h>

+#include <gr_flowgraph.h>

+#include <gr_block.h>

+

+// Create a shared pointer to a heap allocated gr_flat_flowgraph

+// (types defined in gr_runtime_types.h)

+GR_RUNTIME_API gr_flat_flowgraph_sptr gr_make_flat_flowgraph();

+

+/*!

+ *\brief Class specializing gr_flat_flowgraph that has all nodes

+ * as gr_blocks, with no hierarchy

+ * \ingroup internal

+ */

+class GR_RUNTIME_API gr_flat_flowgraph : public gr_flowgraph

+{

+public:

+ friend GR_RUNTIME_API gr_flat_flowgraph_sptr gr_make_flat_flowgraph();

+

+ // Destruct an arbitrary gr_flat_flowgraph

+ ~gr_flat_flowgraph();

+

+ // Wire gr_blocks together in new flat_flowgraph

+ void setup_connections();

+

+ // Merge applicable connections from existing flat flowgraph

+ void merge_connections(gr_flat_flowgraph_sptr sfg);

+

+ // Return a string list of edges

+ std::string edge_list();

+

+ void dump();

+

+ /*!

+ * Make a vector of gr_block from a vector of gr_basic_block

+ */

+ static gr_block_vector_t make_block_vector(gr_basic_block_vector_t &blocks);

+

+ void replace_endpoint(const gr_msg_endpoint &e, const gr_msg_endpoint &r, bool is_src);

+ void clear_endpoint(const gr_msg_endpoint &e, bool is_src);

+

+ /*!

+ * Enables export of perf. counters to ControlPort on all blocks in

+ * the flowgraph.

+ */

+ void enable_pc_rpc();

+

+private:

+ gr_flat_flowgraph();

+

+ gr_block_detail_sptr allocate_block_detail(gr_basic_block_sptr block);

+ gr_buffer_sptr allocate_buffer(gr_basic_block_sptr block, int port);

+ void connect_block_inputs(gr_basic_block_sptr block);

+

+ /* When reusing a flowgraph's blocks, this call makes sure all of the

+ * buffer's are aligned at the machine's alignment boundary and tells

+ * the blocks that they are aligned.

+ *

+ * Called from both setup_connections and merge_connections for

+ * start and restarts.

+ */

+ void setup_buffer_alignment(gr_block_sptr block);

+};

+

+#endif /* INCLUDED_GR_FLAT_FLOWGRAPH_H */

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

+/*

+ * Copyright 2007,2011 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_flowgraph.h>

+#include <gr_io_signature.h>

+#include <stdexcept>

+#include <sstream>

+#include <iterator>

+

+#define GR_FLOWGRAPH_DEBUG 0

+

+gr_edge::~gr_edge()

+{

+}

+

+gr_flowgraph_sptr gr_make_flowgraph()

+{

+ return gr_flowgraph_sptr(new gr_flowgraph());

+}

+

+gr_flowgraph::gr_flowgraph()

+{

+}

+

+gr_flowgraph::~gr_flowgraph()

+{

+}

+

+// FIXME: move to libgruel as a utility function

+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());

+

+ sort(v.begin(), v.end());

+ unique_copy(v.begin(), v.end(), inserter);

+ return result;

+}

+

+void

+gr_flowgraph::connect(const gr_endpoint &src, const gr_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);

+

+ // All ist klar, Herr Kommisar

+ d_edges.push_back(gr_edge(src,dst));

+}

+

+void

+gr_flowgraph::disconnect(const gr_endpoint &src, const gr_endpoint &dst)

+{

+ for (gr_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 " << gr_edge(src, dst) << ", not found";

+ throw std::invalid_argument(msg.str());

+}

+

+void

+gr_flowgraph::validate()

+{

+ d_blocks = calc_used_blocks();

+

+ for (gr_basic_block_viter_t p = d_blocks.begin(); p != d_blocks.end(); p++) {

+ std::vector<int> used_ports;

+ int ninputs, noutputs;

+

+ if (GR_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, 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());

+ }

+ }

+}

+

+void

+gr_flowgraph::clear()

+{

+ // Boost shared pointers will deallocate as needed

+ d_blocks.clear();

+ d_edges.clear();

+}

+

+void

+gr_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());

+ }

+

+ int max = sig->max_streams();

+ if (max != gr_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

+gr_flowgraph::check_valid_port(const gr_msg_endpoint &e)

+{

+ if (GR_FLOWGRAPH_DEBUG)

+ std::cout << "check_valid_port( " << e.block() << ", " << e.port() << ")\n";

+

+ if(!e.block()->has_msg_port(e.port()))

+ throw std::invalid_argument("invalid msg port in connect() or disconnect()");

+}

+

+void

+gr_flowgraph::check_dst_not_used(const gr_endpoint &dst)

+{

+ // A destination is in use if it is already on the edge list

+ for (gr_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

+gr_flowgraph::check_type_match(const gr_endpoint &src, const gr_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());

+ }

+}

+

+gr_basic_block_vector_t

+gr_flowgraph::calc_used_blocks()

+{

+ gr_basic_block_vector_t tmp;

+

+ // make sure free standing message blocks are included

+ for (gr_msg_edge_viter_t p = d_msg_edges.begin(); p != d_msg_edges.end(); p++) {

+// for now only blocks receiving messages get a thread context - uncomment to allow senders to also obtain one

+// tmp.push_back(p->src().block());

+ tmp.push_back(p->dst().block());

+ }

+

+ // Collect all blocks in the edge list

+ for (gr_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<gr_basic_block_sptr>(tmp);

+}

+

+std::vector<int>

+gr_flowgraph::calc_used_ports(gr_basic_block_sptr block, bool check_inputs)

+{

+ std::vector<int> tmp;

+

+ // Collect all seen ports

+ gr_edge_vector_t edges = calc_connections(block, check_inputs);

+ for (gr_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);

+}

+

+gr_edge_vector_t

+gr_flowgraph::calc_connections(gr_basic_block_sptr block, bool check_inputs)

+{

+ gr_edge_vector_t result;

+

+ for (gr_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

+gr_flowgraph::check_contiguity(gr_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();

+

+ 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 < 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 != gr_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());

+ }

+ }

+ }

+}

+

+gr_basic_block_vector_t

+gr_flowgraph::calc_downstream_blocks(gr_basic_block_sptr block, int port)

+{

+ gr_basic_block_vector_t tmp;

+

+ for (gr_edge_viter_t p = d_edges.begin(); p != d_edges.end(); p++)

+ if (p->src() == gr_endpoint(block, port))

+ tmp.push_back(p->dst().block());

+

+ return unique_vector<gr_basic_block_sptr>(tmp);

+}

+

+gr_basic_block_vector_t

+gr_flowgraph::calc_downstream_blocks(gr_basic_block_sptr block)

+{

+ gr_basic_block_vector_t tmp;

+

+ for (gr_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<gr_basic_block_sptr>(tmp);

+}

+

+gr_edge_vector_t

+gr_flowgraph::calc_upstream_edges(gr_basic_block_sptr block)

+{

+ gr_edge_vector_t result;

+

+ for (gr_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

+gr_flowgraph::has_block_p(gr_basic_block_sptr block)

+{

+ gr_basic_block_viter_t result;

+ result = std::find(d_blocks.begin(), d_blocks.end(), block);

+ return (result != d_blocks.end());

+}

+

+gr_edge

+gr_flowgraph::calc_upstream_edge(gr_basic_block_sptr block, int port)

+{

+ gr_edge result;

+

+ for (gr_edge_viter_t p = d_edges.begin(); p != d_edges.end(); p++) {

+ if (p->dst() == gr_endpoint(block, port)) {

+ result = (*p);

+ break;

+ }

+ }

+

+ return result;

+}

+

+std::vector<gr_basic_block_vector_t>

+gr_flowgraph::partition()

+{

+ std::vector<gr_basic_block_vector_t> result;

+ gr_basic_block_vector_t blocks = calc_used_blocks();

+ gr_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));

+

+ for (gr_basic_block_viter_t p = graph.begin(); p != graph.end(); p++)

+ blocks.erase(find(blocks.begin(), blocks.end(), *p));

+ }

+

+ return result;

+}

+

+gr_basic_block_vector_t

+gr_flowgraph::calc_reachable_blocks(gr_basic_block_sptr block, gr_basic_block_vector_t &blocks)

+{

+ gr_basic_block_vector_t result;

+

+ // Mark all blocks as unvisited

+ for (gr_basic_block_viter_t p = blocks.begin(); p != blocks.end(); p++)

+ (*p)->set_color(gr_basic_block::WHITE);

+

+ // Recursively mark all reachable blocks

+ reachable_dfs_visit(block, blocks);

+

+ // Collect all the blocks that have been visited

+ for (gr_basic_block_viter_t p = blocks.begin(); p != blocks.end(); p++)

+ if ((*p)->color() == gr_basic_block::BLACK)

+ result.push_back(*p);

+

+ return result;

+}

+

+// Recursively mark all reachable blocks from given block and block list

+void

+gr_flowgraph::reachable_dfs_visit(gr_basic_block_sptr block, gr_basic_block_vector_t &blocks)

+{

+ // Mark the current one as visited

+ block->set_color(gr_basic_block::BLACK);

+

+ // Recurse into adjacent vertices

+ gr_basic_block_vector_t adjacent = calc_adjacent_blocks(block, blocks);

+

+ for (gr_basic_block_viter_t p = adjacent.begin(); p != adjacent.end(); p++)

+ if ((*p)->color() == gr_basic_block::WHITE)

+ reachable_dfs_visit(*p, blocks);

+}

+

+// Return a list of block adjacent to a given block along any edge

+gr_basic_block_vector_t

+gr_flowgraph::calc_adjacent_blocks(gr_basic_block_sptr block, gr_basic_block_vector_t &blocks)

+{

+ gr_basic_block_vector_t tmp;

+

+ // Find any blocks that are inputs or outputs

+ for (gr_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<gr_basic_block_sptr>(tmp);

+}

+

+gr_basic_block_vector_t

+gr_flowgraph::topological_sort(gr_basic_block_vector_t &blocks)

+{

+ gr_basic_block_vector_t tmp;

+ gr_basic_block_vector_t result;

+ tmp = sort_sources_first(blocks);

+

+ // Start 'em all white

+ for (gr_basic_block_viter_t p = tmp.begin(); p != tmp.end(); p++)

+ (*p)->set_color(gr_basic_block::WHITE);

+

+ for (gr_basic_block_viter_t p = tmp.begin(); p != tmp.end(); p++) {

+ if ((*p)->color() == gr_basic_block::WHITE)

+ topological_dfs_visit(*p, result);

+ }

+

+ reverse(result.begin(), result.end());

+ return result;

+}

+

+gr_basic_block_vector_t

+gr_flowgraph::sort_sources_first(gr_basic_block_vector_t &blocks)

+{

+ gr_basic_block_vector_t sources, nonsources, result;

+

+ for (gr_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 (gr_basic_block_viter_t p = sources.begin(); p != sources.end(); p++)

+ result.push_back(*p);

+

+ for (gr_basic_block_viter_t p = nonsources.begin(); p != nonsources.end(); p++)

+ result.push_back(*p);

+

+ return result;

+}

+

+bool

+gr_flowgraph::source_p(gr_basic_block_sptr block)

+{

+ return (calc_upstream_edges(block).size() == 0);

+}

+

+void

+gr_flowgraph::topological_dfs_visit(gr_basic_block_sptr block, gr_basic_block_vector_t &output)

+{

+ block->set_color(gr_basic_block::GREY);

+ gr_basic_block_vector_t blocks(calc_downstream_blocks(block));

+

+ for (gr_basic_block_viter_t p = blocks.begin(); p != blocks.end(); p++) {

+ switch ((*p)->color()) {

+ case gr_basic_block::WHITE:

+ topological_dfs_visit(*p, output);

+ break;

+

+ case gr_basic_block::GREY:

+ throw std::runtime_error("flow graph has loops!");

+

+ case gr_basic_block::BLACK:

+ continue;

+

+ default:

+ throw std::runtime_error("invalid color on block!");

+ }

+ }

+

+ block->set_color(gr_basic_block::BLACK);

+ output.push_back(block);

+}

+

+void gr_flowgraph::connect(const gr_msg_endpoint &src, const gr_msg_endpoint &dst){

+ check_valid_port(src);

+ check_valid_port(dst);

+ for (gr_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(gr_msg_edge(src,dst));

+}

+

+void gr_flowgraph::disconnect(const gr_msg_endpoint &src, const gr_msg_endpoint &dst){

+ check_valid_port(src);

+ check_valid_port(dst);

+ for (gr_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!");

+}

+

+

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

+/*

+ * Copyright 2004 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_fxpt.h>

+

+const float gr_fxpt::s_sine_table[1 << NBITS][2] = {

+#include "sine_table.h"

+};

+

+const float gr_fxpt::PI = 3.14159265358979323846;

+const float gr_fxpt::TWO_TO_THE_31 = 2147483648.0;

+

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

+/*

+ * Copyright 2006,2007,2008 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_hier_block2.h>

+#include <gr_io_signature.h>

+#include <gr_hier_block2_detail.h>

+#include <iostream>

+

+#define GR_HIER_BLOCK2_DEBUG 0

+

+

+gr_hier_block2_sptr

+gr_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 gr_hier_block2(name, input_signature, output_signature));

+}

+

+gr_hier_block2::gr_hier_block2(const std::string &name,

+ gr_io_signature_sptr input_signature,

+ gr_io_signature_sptr output_signature)

+ : gr_basic_block(name, input_signature, output_signature),

+ d_detail(new gr_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);

+}

+

+gr_hier_block2::~gr_hier_block2()

+{

+ delete d_detail;

+}

+

+gr_hier_block2::opaque_self

+gr_hier_block2::self()

+{

+ return shared_from_this();

+}

+

+gr_hier_block2_sptr

+gr_hier_block2::to_hier_block2()

+{

+ return cast_to_hier_block2_sptr(shared_from_this());

+}

+

+void

+gr_hier_block2::connect(gr_basic_block_sptr block)

+{

+ d_detail->connect(block);

+}

+

+void

+gr_hier_block2::connect(gr_basic_block_sptr src, int src_port,

+ gr_basic_block_sptr dst, int dst_port)

+{

+ d_detail->connect(src, src_port, dst, dst_port);

+}

+

+void

+gr_hier_block2::msg_connect(gr_basic_block_sptr src, pmt::pmt_t srcport,

+ gr_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

+gr_hier_block2::msg_connect(gr_basic_block_sptr src, std::string srcport,

+ gr_basic_block_sptr dst, std::string dstport)

+{

+ d_detail->msg_connect(src, pmt::mp(srcport), dst, pmt::mp(dstport));

+}

+

+void

+gr_hier_block2::msg_disconnect(gr_basic_block_sptr src, pmt::pmt_t srcport,

+ gr_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

+gr_hier_block2::msg_disconnect(gr_basic_block_sptr src, std::string srcport,

+ gr_basic_block_sptr dst, std::string dstport)

+{

+ d_detail->msg_disconnect(src, pmt::mp(srcport), dst, pmt::mp(dstport));

+}

+

+void

+gr_hier_block2::disconnect(gr_basic_block_sptr block)

+{

+ d_detail->disconnect(block);

+}

+

+void

+gr_hier_block2::disconnect(gr_basic_block_sptr src, int src_port,

+ gr_basic_block_sptr dst, int dst_port)

+{

+ d_detail->disconnect(src, src_port, dst, dst_port);

+}

+

+void

+gr_hier_block2::disconnect_all()

+{

+ d_detail->disconnect_all();

+}

+

+void

+gr_hier_block2::lock()

+{

+ d_detail->lock();

+}

+

+void

+gr_hier_block2::unlock()

+{

+ d_detail->unlock();

+}

+

+

+gr_flat_flowgraph_sptr

+gr_hier_block2::flatten() const

+{

+ gr_flat_flowgraph_sptr new_ffg = gr_make_flat_flowgraph();

+ d_detail->flatten_aux(new_ffg);

+ return new_ffg;

+}

+/*

+ * Copyright 2006,2007,2009 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_hier_block2_detail.h>

+#include <gr_io_signature.h>

+#include <gr_prefs.h>

+#include <stdexcept>

+#include <sstream>

+#include <boost/format.hpp>

+

+#define GR_HIER_BLOCK2_DETAIL_DEBUG 0

+

+gr_hier_block2_detail::gr_hier_block2_detail(gr_hier_block2 *owner) :

+ d_owner(owner),

+ d_parent_detail(0),

+ d_fg(gr_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 == gr_io_signature::IO_INFINITE ||

+ max_outputs == gr_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<gr_endpoint_vector_t>(max_inputs);

+ d_outputs = gr_endpoint_vector_t(max_outputs);

+}

+

+

+gr_hier_block2_detail::~gr_hier_block2_detail()

+{

+ d_owner = 0; // Don't use delete, we didn't allocate

+}

+

+void

+gr_hier_block2_detail::connect(gr_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());

+ }

+

+ // 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());

+ }

+

+ gr_hier_block2_sptr hblock(cast_to_hier_block2_sptr(block));

+

+ if (hblock && hblock.get() != d_owner) {

+ if (GR_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

+gr_hier_block2_detail::connect(gr_basic_block_sptr src, int src_port,

+ gr_basic_block_sptr dst, int dst_port)

+{

+ std::stringstream msg;

+

+ if (GR_HIER_BLOCK2_DETAIL_DEBUG)

+ std::cout << "connecting: " << gr_endpoint(src, src_port)

+ << " -> " << gr_endpoint(dst, dst_port) << std::endl;

+

+ if (src.get() == dst.get())

+ throw std::invalid_argument("connect: src and destination blocks cannot be the same");

+

+ gr_hier_block2_sptr src_block(cast_to_hier_block2_sptr(src));

+ gr_hier_block2_sptr dst_block(cast_to_hier_block2_sptr(dst));

+

+ if (src_block && src.get() != d_owner) {

+ if (GR_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 (GR_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());

+ }

+

+ 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());

+ }

+

+ return connect_output(dst_port, src_port, src);

+ }

+

+ // Internal connections

+ d_fg->connect(src, src_port, dst, dst_port);

+

+ // TODO: connects to NC

+}

+

+void

+gr_hier_block2_detail::msg_connect(gr_basic_block_sptr src, pmt::pmt_t srcport,

+ gr_basic_block_sptr dst, pmt::pmt_t dstport)

+{

+ if (GR_HIER_BLOCK2_DETAIL_DEBUG)

+ std::cout << "connecting message port..." << std::endl;

+

+ // register the subscription

+// this is done later...

+// src->message_port_sub(srcport, pmt::cons(dst->alias_pmt(), dstport));

+

+ // 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);

+ }

+

+ bool hier_out = (d_owner == src.get()) && src->message_port_is_hier_out(srcport);;

+ bool hier_in = (d_owner == dst.get()) && dst->message_port_is_hier_in(dstport);

+

+ gr_hier_block2_sptr src_block(cast_to_hier_block2_sptr(src));

+ gr_hier_block2_sptr dst_block(cast_to_hier_block2_sptr(dst));

+

+ if (src_block && src.get() != d_owner) {

+ if (GR_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 (GR_HIER_BLOCK2_DETAIL_DEBUG)

+ std::cout << "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(GR_HIER_BLOCK2_DETAIL_DEBUG)

+ std::cout << boost::format("connect( (%s, %s, %d), (%s, %s, %d) )\n") %

+ src % srcport % hier_out %

+ dst % dstport % hier_in;

+ d_fg->connect( gr_msg_endpoint(src, srcport, hier_out), gr_msg_endpoint(dst, dstport, hier_in));

+}

+

+void

+gr_hier_block2_detail::msg_disconnect(gr_basic_block_sptr src, pmt::pmt_t srcport,

+ gr_basic_block_sptr dst, pmt::pmt_t dstport)

+{

+ if (GR_HIER_BLOCK2_DETAIL_DEBUG)

+ std::cout << "disconnecting message port..." << std::endl;

+

+ // unregister the subscription - if already subscribed

+ src->message_port_unsub(srcport, pmt::cons(dst->alias_pmt(), dstport));

+

+ // remove edge for this message connection

+ bool hier_out = (d_owner == src.get()) && src->message_port_is_hier_out(srcport);;

+ bool hier_in = (d_owner == dst.get()) && dst->message_port_is_hier_in(dstport);

+ d_fg->disconnect( gr_msg_endpoint(src, srcport, hier_out), gr_msg_endpoint(dst, dstport, hier_in));

+}

+

+void

+gr_hier_block2_detail::disconnect(gr_basic_block_sptr block)

+{

+ // Check on singleton list

+ for (gr_basic_block_viter_t p = d_blocks.begin(); p != d_blocks.end(); p++) {

+ if (*p == block) {

+ d_blocks.erase(p);

+

+ gr_hier_block2_sptr hblock(cast_to_hier_block2_sptr(block));

+ if (block && block.get() != d_owner) {

+ if (GR_HIER_BLOCK2_DETAIL_DEBUG)

+ std::cout << "disconnect: block is hierarchical, clearing parent" << std::endl;

+ hblock->d_detail->d_parent_detail = 0;

+ }

+

+ return;

+ }

+ }

+

+ // Otherwise find all edges containing block

+ gr_edge_vector_t edges, tmp = d_fg->edges();

+ gr_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);

+

+ if (GR_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());

+ }

+

+ for (p = edges.begin(); p != edges.end(); p++) {

+ disconnect((*p).src().block(), (*p).src().port(),

+ (*p).dst().block(), (*p).dst().port());

+ }

+}

+

+void

+gr_hier_block2_detail::disconnect(gr_basic_block_sptr src, int src_port,

+ gr_basic_block_sptr dst, int dst_port)

+{

+ if (GR_HIER_BLOCK2_DETAIL_DEBUG)

+ std::cout << "disconnecting: " << gr_endpoint(src, src_port)

+ << " -> " << gr_endpoint(dst, dst_port) << std::endl;

+

+ if (src.get() == dst.get())

+ throw std::invalid_argument("disconnect: source and destination blocks cannot be the same");

+

+ gr_hier_block2_sptr src_block(cast_to_hier_block2_sptr(src));

+ gr_hier_block2_sptr dst_block(cast_to_hier_block2_sptr(dst));

+

+ if (src_block && src.get() != d_owner) {

+ if (GR_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 (GR_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 (dst.get() == d_owner)

+ return disconnect_output(dst_port, src_port, src);

+

+ // Internal connections

+ d_fg->disconnect(src, src_port, dst, dst_port);

+}

+

+void

+gr_hier_block2_detail::connect_input(int my_port, int port, gr_basic_block_sptr block)

+{

+ std::stringstream msg;

+

+ 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());

+ }

+

+ gr_endpoint_vector_t &endps = d_inputs[my_port];

+ gr_endpoint endp(block, port);

+

+ gr_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());

+ }

+

+ endps.push_back(endp);

+}

+

+void

+gr_hier_block2_detail::connect_output(int my_port, int port, gr_basic_block_sptr block)

+{

+ std::stringstream msg;

+

+ 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());

+ }

+

+ d_outputs[my_port] = gr_endpoint(block, port);

+}

+

+void

+gr_hier_block2_detail::disconnect_input(int my_port, int port, gr_basic_block_sptr block)

+{

+ std::stringstream msg;

+

+ 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());

+ }

+

+ gr_endpoint_vector_t &endps = d_inputs[my_port];

+ gr_endpoint endp(block, port);

+

+ gr_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());

+ }

+

+ endps.erase(p);

+}

+

+void

+gr_hier_block2_detail::disconnect_output(int my_port, int port, gr_basic_block_sptr block)

+{

+ std::stringstream msg;

+

+ 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());

+ }

+

+ d_outputs[my_port] = gr_endpoint();

+}

+

+gr_endpoint_vector_t

+gr_hier_block2_detail::resolve_port(int port, bool is_input)

+{

+ std::stringstream msg;

+

+ if (GR_HIER_BLOCK2_DETAIL_DEBUG)

+ std::cout << "Resolving port " << port << " as an "

+ << (is_input ? "input" : "output")

+ << " of " << d_owner->name() << std::endl;

+

+ gr_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 (d_inputs[port].empty()) {

+ msg << "resolve_port: hierarchical block '" << d_owner->name()

+ << "': input " << port << " is not connected internally";

+ throw std::runtime_error(msg.str());

+ }

+

+ gr_endpoint_vector_t &endps = d_inputs[port];

+ gr_endpoint_viter_t p;

+ for (p = endps.begin(); p != endps.end(); p++) {

+ gr_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] == gr_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);

+ }

+

+ 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

+gr_hier_block2_detail::disconnect_all()

+{

+ d_fg->clear();

+ d_blocks.clear();

+ d_inputs.clear();

+ d_outputs.clear();

+}

+

+gr_endpoint_vector_t

+gr_hier_block2_detail::resolve_endpoint(const gr_endpoint &endp, bool is_input) const

+{

+ std::stringstream msg;

+ gr_endpoint_vector_t result;

+

+ // Check if endpoint is a leaf node

+ if (cast_to_block_sptr(endp.block())) {

+ if (GR_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

+ gr_hier_block2_sptr hier_block2(cast_to_hier_block2_sptr(endp.block()));

+ if (hier_block2) {

+ if (GR_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;

+ throw std::runtime_error(msg.str());

+}

+

+void

+gr_hier_block2_detail::flatten_aux(gr_flat_flowgraph_sptr sfg) const

+{

+ if (GR_HIER_BLOCK2_DETAIL_DEBUG)

+ std::cout << " ** Flattening " << d_owner->name() << std::endl;

+

+ // Add my edges to the flow graph, resolving references to actual endpoints

+ gr_edge_vector_t edges = d_fg->edges();

+ gr_msg_edge_vector_t msg_edges = d_fg->msg_edges();

+ gr_edge_viter_t p;

+ gr_msg_edge_viter_t q,u;

+

+ // Only run setup_rpc if ControlPort config param is enabled.

+ bool ctrlport_on = gr_prefs::singleton()->get_bool("ControlPort", "on", false);

+

+ // For every block (gr_block and gr_hier_block2), set up the RPC

+ // interface.

+ for(p = edges.begin(); p != edges.end(); p++) {

+ gr_basic_block_sptr b;

+ b = p->src().block();

+

+ if(ctrlport_on) {

+ if(!b->is_rpc_set()) {

+ b->setup_rpc();

+ b->rpc_set();

+ }

+ }

+

+ b = p->dst().block();

+ if(ctrlport_on) {

+ if(!b->is_rpc_set()) {

+ b->setup_rpc();

+ b->rpc_set();

+ }

+ }

+ }

+

+ if (GR_HIER_BLOCK2_DETAIL_DEBUG)

+ std::cout << "Flattening stream connections: " << std::endl;

+

+ for (p = edges.begin(); p != edges.end(); p++) {

+ if (GR_HIER_BLOCK2_DETAIL_DEBUG)

+ std::cout << "Flattening edge " << (*p) << std::endl;

+

+ gr_endpoint_vector_t src_endps = resolve_endpoint(p->src(), false);

+ gr_endpoint_vector_t dst_endps = resolve_endpoint(p->dst(), true);

+

+ gr_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 (GR_HIER_BLOCK2_DETAIL_DEBUG)

+ std::cout << (*s) << "->" << (*d) << std::endl;

+ sfg->connect(*s, *d);

+ }

+ }

+ }

+

+ // loop through flattening hierarchical connections

+ if (GR_HIER_BLOCK2_DETAIL_DEBUG)

+ std::cout << "Flattening msg connections: " << std::endl;

+

+

+ std::vector<std::pair<gr_msg_endpoint, bool> > resolved_endpoints;

+ for(q = msg_edges.begin(); q != msg_edges.end(); q++) {

+ if (GR_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();

+

+ bool normal_connection = true;

+

+ // resolve existing connections to hier ports

+ if(q->dst().is_hier()){

+ if (GR_HIER_BLOCK2_DETAIL_DEBUG)

+ std::cout << boost::format(" resolve hier output (%s, %s)") % q->dst().block() % q->dst().port() << std::endl;

+ sfg->replace_endpoint( q->dst(), q->src(), true );

+ resolved_endpoints.push_back(std::pair<gr_msg_endpoint, bool>(q->dst(),true));

+ normal_connection = false;

+ }

+

+ if(q->src().is_hier()){

+ if (GR_HIER_BLOCK2_DETAIL_DEBUG)

+ std::cout << boost::format(" resolve hier input (%s, %s)") % q->src().block() % q->src().port() << std::endl;

+ sfg->replace_endpoint( q->src(), q->dst(), false );

+ resolved_endpoints.push_back(std::pair<gr_msg_endpoint, bool>(q->src(),false));

+ normal_connection = false;

+ }

+

+ // propogate non hier connections through

+ if(normal_connection){

+ sfg->connect( q->src(), q->dst() );

+ }

+ }

+ for(std::vector<std::pair<gr_msg_endpoint, bool> >::iterator it = resolved_endpoints.begin(); it != resolved_endpoints.end(); it++){

+ sfg->clear_endpoint( (*it).first, (*it).second );

+ }

+

+/* // connect primitive edges in the new fg

+ for(q = msg_edges.begin(); q != msg_edges.end(); q++) {

+ if( (!q->src().is_hier()) && (!q->dst().is_hier()) ){

+ sfg->connect( q->src(), q->dst() );

+ } else {

+ std::cout << "not connecting hier connection!" << std::endl;

+ }

+ }*/

+

+ // Construct unique list of blocks used either in edges, inputs,

+ // outputs, or by themselves. I still hate STL.

+ gr_basic_block_vector_t blocks; // unique list of used blocks

+ gr_basic_block_vector_t tmp = d_fg->calc_used_blocks();

+

+ // First add the list of singleton blocks

+ std::vector<gr_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";