Re: Two more questions: Re: [Discuss-gnuradio] Two GMSK decoders with two msg queues

[Eric Blossom]

On Tue, Oct 17, 2006 at 12:00:11AM -0400, Dawei Shen wrote:
> Sorry, my previous email is sent by mistake, let me restate my questions:
> 
> Hey Eric, Michael and other friends:
> 
> My code is working well now. But I met two new problems, which are not so
> crucial, but really important to me.
> 
> 2. Another problem is more difficult to describe, the following is part of
> my main code:
> 
> class my_graph(gr.flow_graph):
> 
>    def __init__(self, rx_callbackA, rx_callbackB, spb, bt, SNR,
> freq_error):
>        gr.flow_graph.__init__(self)
> 
>        fg = self
> 
>        # Tuning Parameters
>        gain_mu = 0.002*spb
>        omega = spb*(1+freq_error)
> 
>        # transmitter
>        self.packet_transmitterA = gmsk2_mod_pkts(fg, spb=spb, bt=bt)
>        self.packet_transmitterB = gmsk2_mod_pkts(fg, spb=spb, bt=bt)
> 
>        adder = gr.add_cc ()
>        const = gr.multiply_const_cc (0.5)
> 
>        fg.connect (self.packet_transmitterA , (adder, 0))
>        fg.connect (self.packet_transmitterB, const, (adder, 1))
> 
>        self.packet_receiver = Separator_demod_pkts(fg,
> callbackA=rx_callbackA, callbackB=rx_callbackB,
>                                                  spb=spb, gain_mu=gain_mu,
>                                                  freq_error=freq_error,
> omega=omega)
> 
>        fg.connect (adder, self.packet_receiver)
> Then in the main function, i do
>    while n < nbytes:
>        send_pkt_A(struct.pack('!H', pktnoA) + 'A' + (pkt_sizeA - 3) *
> chr(pktnoA & 0xff))
>        send_pkt_B(struct.pack('!H', pktnoB) + 'B' + (pkt_sizeB - 3) *
> chr(pktnoB & 0xff))
>        n += pkt_size
>        print "n now is %d" % n
>        pktnoA += 1
>        pktnoB += 1
> 
> Here pkt_size is 1500, nbytes is 1M as default. I omit other parts of my
> code because they are not so important here. I print the value of n in the
> loop because I want to see when it stops. So the output is sth like this:
> I am stream A's callback function
> ok =  True  from 'A', pktno =   46  len(payload) = 1500  118/118
> n now is 108000
> I am stream B's callback function
> ok =  True  from 'B', pktno =  247  len(payload) = 1000  119/119
> n now is 109500
> I am stream B's callback function
> ok =  True  from 'B', pktno =  248  len(payload) = 1000  120/120
> I am stream A's callback function
> ok =  True  from 'A', pktno =   47  len(payload) = 1500  121/121
> I am stream B's callback function
> ok =  True  from 'B', pktno =  249  len(payload) = 1000  122/122
> I am stream A's callback function
> ok =  True  from 'A', pktno =   48  len(payload) = 1500  123/123
> 
> 
> Then it stops!!! Nothing happens after that. It appears to me that the
> process goes somewhere and never comes back. The current value of n is still
> far from nbytes, but it just stops there. One possible solution I found out
> was that I could change the "msgq_limit" parameter of the gr_message_source
> in gmsk2_pkt. If I increase "msgq_limit", the program could go further and
> further, with larger n and processed packets, but still stops some timeand
> never continues.
> 
> So could anyone help me address these two things? Thank you very much in
> advance!
> 
> Dawei

I suspect you've got some kind of deadlock.  Without seeing all the
code, it's hard to know what's going on.  Are you trying to jam the
1MB worth of packets into the queue before fg.start() or fg.run() is
called?  If so, it's no wonder that it dead locks ;) Neither the
receiver nor the transmitter are running yet and send_pkt_* is just
queueing the packets to be modulated.  If you set msgq_limit to 0,
there will be no limit enforced and all the packets to be modulated
will be enqueued (this of course allocates memory to hold everything).

Eric