Esempio n. 1
0
 def __init__(self, item_size, num_inputs, num_outputs, input_index, output_index):
     """
     Selector constructor.
     
     Args:
         item_size: the size of the gr data stream in bytes
         num_inputs: the number of inputs (integer)
         num_outputs: the number of outputs (integer)
         input_index: the index for the source data
         output_index: the index for the destination data
     """
     gr.hier_block2.__init__(
         self, 'selector',
         gr.io_signature(num_inputs, num_inputs, item_size),
         gr.io_signature(num_outputs, num_outputs, item_size),
     )
     #terminator blocks for unused inputs and outputs
     self.input_terminators = [blocks.null_sink(item_size) for i in range(num_inputs)]
     self.output_terminators = [blocks.head(item_size, 0) for i in range(num_outputs)]
     self.copy = blocks.copy(item_size)
     #connections
     for i in range(num_inputs): self.connect((self, i), self.input_terminators[i])
     for i in range(num_outputs): self.connect(blocks.null_source(item_size),
                                                       self.output_terminators[i], (self, i))
     self.item_size = item_size
     self.input_index = input_index
     self.output_index = output_index
     self.num_inputs = num_inputs
     self.num_outputs = num_outputs
     self._connect_current()
Esempio n. 2
0
    def __init__(self):
        gr.top_block.__init__(self, "Affinity Set Test")

        ##################################################
	# Variables
	##################################################
	self.samp_rate = samp_rate = 32000

	##################################################
	# Blocks
	##################################################
        vec_len = 1
	self.blocks_throttle_0 = blocks.throttle(gr.sizeof_oc_complex*vec_len, samp_rate)
	self.blocks_null_source_0 = blocks.null_source(gr.sizeof_oc_complex*vec_len)
	self.blocks_null_sink_0 = blocks.null_sink(gr.sizeof_oc_complex*vec_len)
	self.filter_filt_0 = filter.fir_filter_ccc(1, 40000*[0.2+0.3j,])
	self.filter_filt_1 = filter.fir_filter_ccc(1, 40000*[0.2+0.3j,])

	self.filter_filt_0.set_processor_affinity([0,])
	self.filter_filt_1.set_processor_affinity([0,1])

	##################################################
	# Connections
	##################################################
	self.connect((self.blocks_null_source_0, 0), (self.blocks_throttle_0, 0))
	self.connect((self.blocks_throttle_0, 0), (self.filter_filt_0, 0))
	self.connect((self.filter_filt_0, 0), (self.filter_filt_1, 0))
	self.connect((self.filter_filt_1, 0), (self.blocks_null_sink_0, 0))
Esempio n. 3
0
    def __init__(self):
        gr.top_block.__init__(self)

        default_nsamples = 10e6
        parser=OptionParser(option_class=eng_option)
        parser.add_option("-p", "--npipelines", type="intx", default=1,
                          metavar="NPIPES", help="the number of pipelines to create (default=%default)")
        parser.add_option("-s", "--nstages", type="intx", default=1,
                          metavar="NSTAGES", help="the number of stages in each pipeline (default=%default)")
        parser.add_option("-N", "--nsamples", type="eng_float", default=default_nsamples,
                          help=("the number of samples to run through the graph (default=%s)" %
                                (eng_notation.num_to_str(default_nsamples))))
        parser.add_option("-m", "--machine-readable", action="store_true", default=False,
                          help="enable machine readable output")

        (options, args) = parser.parse_args()
        if len(args) != 0:
            parser.print_help()
            raise SystemExit, 1

        self.npipes = options.npipelines
        self.nstages = options.nstages
        self.nsamples = options.nsamples
        self.machine_readable = options.machine_readable

        ntaps = 256

        # Something vaguely like floating point ops
        self.flop = 2 * ntaps * options.npipelines * options.nstages * options.nsamples

        src = blocks.null_source(gr.sizeof_float)
        head = blocks.head(gr.sizeof_float, int(options.nsamples))
        self.connect(src, head)

        for n in range(options.npipelines):
            self.connect(head, pipeline(options.nstages, ntaps))
Esempio n. 4
0
    def __init__(self, N, op,
                 isizeof=gr.sizeof_oc_complex,
                 osizeof=gr.sizeof_oc_complex,
                 nsrcs=1, nsnks=1):
        gr.top_block.__init__(self, "helper")

        self.op = op
        self.srcs = []
        self.snks = []
        self.head = blocks.head(isizeof, N)

        for n in xrange(nsrcs):
            self.srcs.append(blocks.null_source(isizeof))

        for n in xrange(nsnks):
            self.snks.append(blocks.null_sink(osizeof))

        self.connect(self.srcs[0], self.head, (self.op,0))

        for n in xrange(1, nsrcs):
            self.connect(self.srcs[n], (self.op,n))

        for n in xrange(nsnks):
            self.connect((self.op,n), self.snks[n])