Multiprocessor flow graphs

Hi all,

I’m trying to modify the benchmark_ofdm_rx.py example to handle a
decimation of 8 for a project I am working on. Going straight for the
usrp->file works fine, so if I can handle the processing requirement I
should be able to demod ofdm packets in real time. The PC I’m working
with has 4 processors, but as far as I know, the gnuradio flow graphs
should only be using one per program. Therefore, I took the blocks from
the various files used in benchmark_ofdm_rx and put them into a single
long flow graph. I then split the flow graph and am trying to do the
following:

if os.fork() == 0: # child process
{first half of benchmark_ofdm_rx.py flow graph}
topblock.connect(middleblock, shared_memory_sink)
topblock.run()
else: # parent process
topblock.connect(shared_memory_source, nextblock)
{second half of benchmark_ofdm_rx.py flow graph}
topblock.run()

Originally I tried this with the shared_memory_source/sink being the
udp_source/sink blocks provided with gnuradio. The modified flow graph
worked perfectly at high decimations, and seemed to be utilizing two
processors. However, as I got closer to 8 I would “lose” packets across
the udp source/sink. This happened no matter what I set the MTU to. I
tried using fifos/pipes instead, but there is apparently a 64K memory
limit in the linux kernel. My current idea is to use the circular buffer
classes that Gnuradio has modified to use non-private shared memory
source/sinks. From what I’ve understood from Gnuradio these circular
buffers are what link up the blocks in a graph, so it should be fine for
handling the interprocess throughput I need. Is the best way to
accomplish what I’m trying to do?

Thanks,
Dev

This forum is not affiliated to the Ruby language, Ruby on Rails framework, nor any Ruby applications discussed here.

| Privacy Policy | Terms of Service | Remote Ruby Jobs