Ignore:
Timestamp:
Jan 13, 2021, 12:36:17 AM (11 months ago)
Author:
alain
Message:

All modifications required to support the <tcp_chat> application
including error recovery in case of packet loss.A

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/kernel/libk/grdxt.c

    r671 r683  
    4040                    uint32_t  ix3_width )
    4141{
     42
     43assert( __FUNCTION__, (rt != NULL),
     44"pointer on radix tree is NULL\n" );
     45
    4246    void      ** root;
    43         kmem_req_t   req;
    4447 
    4548        rt->ix1_width = ix1_width;
     
    4851
    4952    // allocates first level array
    50         req.type  = KMEM_KCM;
    51         req.order = ix1_width + ( (sizeof(void*) == 4) ? 2 : 3 );
    52         req.flags = AF_KERNEL | AF_ZERO;
    53         root = kmem_alloc( &req );
     53        uint32_t order = ix1_width + ( (sizeof(void*) == 4) ? 2 : 3 );
     54        root = kmem_alloc( order , AF_ZERO );
    5455
    5556        if( root == NULL )
     
    6869void grdxt_destroy( grdxt_t * rt )
    6970{
    70         kmem_req_t req;
     71
     72assert( __FUNCTION__, (rt != NULL),
     73"pointer on radix tree is NULL\n" );
     74
     75    uint32_t   order;
    7176
    7277    uint32_t   w1 = rt->ix1_width;
     
    8186        uint32_t   ix2;
    8287        uint32_t   ix3;
    83 
    84 assert( __FUNCTION__, (rt != NULL) , "pointer on radix tree is NULL\n" );
    8588
    8689        for( ix1=0 ; ix1 < (uint32_t)(1 << w1) ; ix1++ )
     
    106109
    107110            // release level 3 array
    108             req.type = KMEM_KCM;
    109                     req.ptr  = ptr3;
    110                     kmem_free( &req );
     111                order = w3 + ( (sizeof(void*) == 4) ? 2 : 3 );
     112                    kmem_free( ptr3 , order );
    111113        }
    112114
    113115        // release level 2 array
    114         req.type = KMEM_KCM;
    115                 req.ptr  = ptr2;
    116                 kmem_free( &req );
     116            order = w2 + ( (sizeof(void*) == 4) ? 2 : 3 );
     117                kmem_free( ptr2 , order );
    117118    }
    118119
    119120    // release level 1 array
    120     req.type = KMEM_KCM;
    121         req.ptr  = ptr1;
    122         kmem_free( &req );
     121        order = w1 + ( (sizeof(void*) == 4) ? 2 : 3 );
     122        kmem_free( ptr1 , order );
    123123
    124124}  // end grdxt_destroy()
     
    129129                      void     * value )
    130130{
    131         kmem_req_t      req;
     131    uint32_t        order;
    132132
    133133    uint32_t        w1 = rt->ix1_width;
     
    136136
    137137// Check key value
    138 assert( __FUNCTION__, ((key >> (w1 + w2 + w3)) == 0 ), "illegal key value %x\n", key );
     138assert( __FUNCTION__, ((key >> (w1 + w2 + w3)) == 0 ),
     139"illegal key value %x\n", key );
    139140
    140141    // compute indexes
     
    155156        {
    156157        // allocate memory for level 2 array
    157         req.type  = KMEM_KCM;
    158         req.order = w2 + ( (sizeof(void*) == 4) ? 2 : 3 );
    159         req.flags = AF_KERNEL | AF_ZERO;
    160         ptr2 = kmem_alloc( &req );
     158        order = w2 + ( (sizeof(void*) == 4) ? 2 : 3 );
     159        ptr2 = kmem_alloc( order , AF_ZERO );
    161160
    162161        if( ptr2 == NULL) return -1;
     
    173172        {
    174173        // allocate memory for level 3 array
    175         req.type = KMEM_KCM;
    176         req.order = w3 + ( (sizeof(void*) == 4) ? 2 : 3 );
    177         req.flags = AF_KERNEL | AF_ZERO;
    178         ptr3 = kmem_alloc( &req );
     174        order = w3 + ( (sizeof(void*) == 4) ? 2 : 3 );
     175        ptr3 = kmem_alloc( order , AF_ZERO );
    179176
    180177        if( ptr3 == NULL) return -1;
     
    202199
    203200// Check key value
    204 assert( __FUNCTION__, ((key >> (w1 + w2 + w3)) == 0 ), "illegal key value %x\n", key );
     201assert( __FUNCTION__, ((key >> (w1 + w2 + w3)) == 0 ),
     202"illegal key value %x\n", key );
    205203
    206204    // compute indexes
     
    244242
    245243// Check key value
    246 assert( __FUNCTION__, ((key >> (w1 + w2 + w3)) == 0 ), "illegal key value %x\n", key );
     244assert( __FUNCTION__, ((key >> (w1 + w2 + w3)) == 0 ),
     245"illegal key value %x\n", key );
    247246
    248247    void         ** ptr1 = rt->root;
     
    284283
    285284// Check key value
    286 assert( __FUNCTION__, ((start_key >> (w1 + w2 + w3)) == 0 ), "illegal key value %x\n", start_key );
     285assert( __FUNCTION__, ((start_key >> (w1 + w2 + w3)) == 0 ),
     286"illegal key value %x\n", start_key );
    287287
    288288    // compute max indexes
     
    338338                           uint32_t   ix3_width )
    339339{
     340
     341assert( __FUNCTION__, (rt_xp != XPTR_NULL),
     342"extended pointer on radix tree is NULL\n" );
     343
    340344    void      ** root;
    341         kmem_req_t   req;
    342345
    343346    // get cluster and local pointer
     
    351354
    352355    // allocates first level array
    353         req.type  = KMEM_KCM;
    354         req.order = ix1_width + ( (sizeof(void*) == 4) ? 2 : 3 );
    355         req.flags = AF_KERNEL | AF_ZERO;
    356         root      = kmem_remote_alloc( rt_cxy , &req );
     356        uint32_t order = ix1_width + ( (sizeof(void*) == 4) ? 2 : 3 );
     357        root = kmem_remote_alloc( rt_cxy , order , AF_ZERO );
    357358
    358359        if( root == NULL )
     
    372373void grdxt_remote_destroy( xptr_t  rt_xp )
    373374{
    374         kmem_req_t req;
     375
     376assert( __FUNCTION__, (rt_xp != XPTR_NULL),
     377"extended pointer on radix tree is NULL\n" );
     378
     379    uint32_t   order;
    375380
    376381    uint32_t   w1;
     
    422427
    423428            // release level 3 array
    424             req.type = KMEM_KCM;
    425                     req.ptr  = ptr3;
    426                     kmem_remote_free( rt_cxy , &req );
     429                    order = w3 + ((sizeof(void*) == 4) ? 2 : 3 );
     430                    kmem_remote_free( rt_cxy , ptr3 , order );
    427431        }
    428432
    429433        // release level 2 array
    430         req.type = KMEM_KCM;
    431                 req.ptr  = ptr2;
    432             kmem_remote_free( rt_cxy , &req );
     434        order = w2 + ((sizeof(void*) == 4) ? 2 : 3 );
     435        kmem_remote_free( rt_cxy , ptr2 , order );
    433436    }
    434437
    435438    // release level 1 array
    436     req.type = KMEM_KCM;
    437         req.ptr  = ptr1;
    438     kmem_remote_free( rt_cxy , &req );
     439    order = w1 + ((sizeof(void*) == 4) ? 2 : 3 );
     440    kmem_remote_free( rt_cxy , ptr1 , order );
    439441
    440442}  // end grdxt_remote_destroy()
     
    445447                             void     * value )
    446448{
    447     kmem_req_t  req;
     449    uint32_t order;
    448450
    449451    // get cluster and local pointer on remote rt descriptor
     
    507509    {
    508510        // allocate memory in remote cluster
    509         req.type  = KMEM_KCM;
    510         req.order = w2 + ((sizeof(void*) == 4) ? 2 : 3 );
    511         req.flags = AF_ZERO | AF_KERNEL;
    512         ptr2 = kmem_remote_alloc( rt_cxy , &req );
     511        order = w2 + ((sizeof(void*) == 4) ? 2 : 3 );
     512        ptr2 = kmem_remote_alloc( rt_cxy , order , AF_ZERO );
    513513
    514514        if( ptr2 == NULL ) return -1;
     
    538538    {
    539539        // allocate memory in remote cluster
    540         req.type  = KMEM_KCM;
    541         req.order = w3 + ((sizeof(void*) == 4) ? 2 : 3 );
    542         req.flags = AF_ZERO | AF_KERNEL;
    543         ptr3 = kmem_remote_alloc( rt_cxy , &req );
     540        order = w3 + ((sizeof(void*) == 4) ? 2 : 3 );
     541        ptr3 = kmem_remote_alloc( rt_cxy , order , AF_ZERO );
    544542
    545543        if( ptr3 == NULL ) return -1;
Note: See TracChangeset for help on using the changeset viewer.