rohc team mailing list archive

[Yakir Matusovsky <yakir.matusovsky@xxxxxxxxxxx>]

Didier,

Looks like my code is using the decompressor side feedback as described. I do also see feedback generated over the air. However, did not see anything in the function that wraps up the whole compress process with compress4(). No feedbacks there, no timer, these are good points and they are needed for my wireless links. Will do more work to add these. Cheers!

Liked you simplified API idea. No argument it is a positive move. Few notes,
1) The "automated" decompress () process - clear, of course in case this side is sending packets back "quite" often.
2) The compress() process - makes sense to piggyback requests this way, as well.
3) You've noted a "random_cb" in the args of rohc_couple_new(). What this cb could be for? Handling the sending of feedbacks which have expired because no packets was sent for some time? If not, would be nice to have something to register to - the app: to implement a timer cb for both ends? 
4) Hmm... flushing feedback could have been nice if you knew to correlate feedbacks to open compressed sessions. If the feedback can be relevant (as other side might be still waiting) I'd prefer to send whatever I've got rather than flush it. Makes sense? Of course, can run another timer to garbage collect this, if qualifies as garbage...

PS. On another page, having a way to tune the non-piggybacked feedback sending period is an valuable feature for low-bandwidth links.

Regards,
Yakir 
On 21/03/18, 9:19 AM, "Rohc on behalf of Didier Barvaux" <rohc-bounces+yakir.matusovsky=mimomax.com@xxxxxxxxxxxxxxxxxxx on behalf of didier@xxxxxxxxxxx> wrote:

    Yakir,
    
    > I am attempting a brave move from 1.7 to 2.1 on ARM.
    > One thing that has popped up straight away was the absence of the
    > rohc_feedback. The following snippet is from 1.7,
    > 
    > [snip code]
    > 
    > Post 1.7, has the feedback handling been made implicit?
    
    You're right, feedback handling changed between 1.6.x and 1.7.x. The
    1.7.x versions also handled the old API, but versions 2.0.0 (or any
    later version) dropped it.
    
    The new way to handle feedback is now more flexible: handling both
    piggy-backing or feedback-only channels becomes possible.
    
    The API changes are described on the wiki:
    https://rohc-lib.org/wiki/doku.php?id=library-migration#api_changes_between_16x_and_17x
    
    However, the feedback changes are not described. Here are some
    explanations. If you find them helpful, I'll add them to the wiki.
    
    
    The feedbacks are transmitted in two ways:
     * piggybacked with one ROHC packet that goes in the other direction
     * sent alone.
     
    Piggybacking may saves bandwidth, however it requires some return
    traffic. If there is no return traffic, the feedbacks shall be sent
    alone in order to avoid adding jitter. The behaviour might be controlled
    by an application with a timeout: queue the feedbacks until a return
    packet arrives or the times out.
    
    When feedback are piggybacked, the decompressor is associated to a
    local compressor that will transmit the feedback over the network. The
    remote decompressor will extract the feedback and give it to the local
    compressor that will interpret it.
     
     comp. A    ----[ROHC for A + feedback for B]--->  decomp. A
       /\                                                |
       |                                                 | feedback for comp. A
       | feedback for comp. B                            |   +
       |   +                                             | feedback for comp. B
       | feedback for comp. A                            |
       |                                                 \/
     decomp. B  <---[ROHC for B + feedback for A]----  comp. B
    
    The rohc_decompress3() function allows you to perform both
    transmission ways. The function returns two feedbacks:
     * The 4th parameter is the feedback sent by the remote decompressor
       that shall be delivered to the local compressor. The function
       rohc_comp_deliver_feedback2() may be used for the delivery.
     * The 5th parameter is the feedback that the local decompressor wants
       to transmit to its remote compressor. That packet may be sent as-is
       over the network, or it may be prepended to any ROHC packet
       generated by the local compressor.
     
    The test/non_regression/test_non_regression.c uses two couples of ROHC
    compressor/decompressor that use each other for piggybacking.
    
    A more complete application than the non-regression test should handle
    the case in which there is no traffic in the other direction. To
    achieve that, the application may store all generated feedbacks
    locally. Then:
     1/ If a packet goes the reverse way, then you build a ROHC packet with:
           a/ the stored feedbacks
           b/ the ROHC packet generated by the rohc_compress4() function.
        You may concatenate them together: 1 or more feedbacks first then
        the ROHC packet itself. The only limit is the MTU of your link
        layer.
     2/ If no packet goes the reverse way for a long time, then you send
        all the stored feedbacks to your link layer. The decompressor will
        handle them fine: the rohc_decompress3() function returns
        ROHC_STATUS_OK and an empty decompressed packet (3rd argument of the
        function).
    
    
    
    You are not the only one struggling with feedback handling. I should
    maybe add a "simple" API that makes easy to create a couple of local
    compressor and decompressor. It could hide the details and handle
    feedback between the local (de)compressors transparently for the
    library users. Something that could look like:
    
    /* create couple */
    rohc_couple = rohc_couple_new(ROHC_SMALL_CID, ROHC_SMALL_CID_MAX, random_cb, NULL);
    if(rohc_couple == NULL)
    {
      /* handle error */
    }
    
    /* decompress one ROHC packet:
        - internally deliver the feedback sent by the remote decompressor to
          the local compressor,
        - decompress any compressed packet into the provided
          'uncompressed_packet' buffer (some ROHC packets may contains only
          feedback, resulting in no uncompressed packet),
        - internally store the feedback that the local decompressor wants
          to transmit to its remote compressor.
    */
    status = rohc_couple_decompress(rohc_couple, rohc_packet, &uncompressed_packet);
    if(status != ROHC_STATUS_OK)
    {
      /* handle error */
    }
    if(uncompressed_packet.len != 0)
    {
      /* uncompressed packet is available, do something with it */
    }
    
    /* sometimes later, compress one uncompressed packet */
    status = rohc_couple_compress(rohc_couple, uncompressed_packet, &rohc_packet);
    if(status != ROHC_STATUS_OK)
    {
      /* handle error */
    }
    /* compressed packet is available with piggybacked feedback, send it to
       the remote node */
    
    /* if there is no packet to compress, one may flush the stored feedback */
    status = rohc_couple_flush(rohc_couple, &rohc_packet);
    if(status != ROHC_STATUS_OK)
    {
      /* handle error */
    }
    /* compressed packet is available with feedback information only, send
       it to the remote node */
    
    
    What do you think of?
    
    
    > PS. BTW, thanks for other 32bit CPU kernel div64 fix --- will test
    > this soon
    
    OK. Keep me informed please.
    
    
    Regards,
    Didier
    
    
    _______________________________________________
    Mailing list: https://launchpad.net/~rohc
    Post to     : rohc@xxxxxxxxxxxxxxxxxxx
    Unsubscribe : https://launchpad.net/~rohc
    More help   : https://help.launchpad.net/ListHelp