Ignore:
Timestamp:
Jan 13, 2021, 12:36:17 AM (9 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/remote_barrier.c

    r671 r683  
    22 * remote_barrier.c -  POSIX barrier implementation.
    33 *
    4  * Author   Alain Greiner (2016,2017,2018,2019)
     4 * Author   Alain Greiner    (2016,2017,2018,2019,2020)
    55 *
    66 * Copyright (c) UPMC Sorbonne Universites
     
    8484{
    8585    generic_barrier_t * gen_barrier_ptr;  // local pointer on generic barrier descriptor
    86     void              * barrier;          // local pointer on implementation barrier descriptor     
    87     kmem_req_t          req;              // kmem request
     86    void              * barrier;          // local pointer on impl barrier descriptor     
    8887
    8988    // get pointer on local process_descriptor
     
    9695
    9796    // allocate memory for generic barrier descriptor
    98     req.type   = KMEM_KCM;
    99     req.order  = bits_log2( sizeof(generic_barrier_t) );
    100     req.flags  = AF_ZERO | AF_KERNEL;
    101     gen_barrier_ptr = kmem_remote_alloc( ref_cxy , &req );
    102 
     97    gen_barrier_ptr = kmem_remote_alloc( ref_cxy,
     98                                         bits_log2(sizeof(generic_barrier_t)),
     99                                         AF_KERNEL );
    103100    if( gen_barrier_ptr == NULL )
    104101    {
     
    108105
    109106    // create implementation specific barrier descriptor
    110     if( attr == NULL )                                    // simple barrier implementation
     107    if( attr == NULL )                                    // simple barrier
    111108    {
    112109        // create simple barrier descriptor
    113110         barrier = simple_barrier_create( count );
    114 
    115         if( barrier == NULL ) return -1;
    116     }
    117     else                                                  // QDT barrier implementation
     111    }
     112    else                                                  // QDT barrier
    118113    {
    119114        uint32_t x_size   = attr->x_size;
     
    126121            printk("\n[ERROR] in %s : count(%d) != x_size(%d) * y_size(%d) * nthreads(%d)\n",
    127122            __FUNCTION__, count, x_size, y_size, nthreads );
     123            kmem_remote_free( ref_cxy,
     124                              gen_barrier_ptr,
     125                              bits_log2(sizeof(generic_barrier_t)) );
    128126            return -1;
    129127        }
     
    131129        // create DQT barrier descriptor
    132130        barrier = dqt_barrier_create( x_size , y_size , nthreads );
    133 
    134         if( barrier == NULL ) return -1;
     131    }
     132
     133    if( barrier == NULL )
     134    {
     135        printk("\n[ERROR] in %s : cannot create impl barrier\n", __FUNCTION__ );
     136        kmem_remote_free( ref_cxy,
     137                          gen_barrier_ptr,
     138                          bits_log2(sizeof(generic_barrier_t)) );
     139        return -1;
    135140    }
    136141
     
    157162void generic_barrier_destroy( xptr_t gen_barrier_xp )
    158163{
    159     kmem_req_t  req;              // kmem request
    160 
    161164    // get pointer on local process_descriptor
    162165    process_t * process = CURRENT_THREAD->process;
     
    191194    remote_busylock_release( lock_xp );
    192195
    193     // release memory allocated to barrier descriptor
    194     req.type          = KMEM_KCM;
    195     req.ptr           = gen_barrier_ptr;
    196     kmem_remote_free( ref_cxy , &req );
     196    // release memory allocated to generic barrier descriptor
     197    kmem_remote_free( gen_barrier_cxy,
     198                      gen_barrier_ptr,
     199                      bits_log2(sizeof(generic_barrier_t)) );
    197200
    198201}  // end generic_barrier_destroy()
     
    246249simple_barrier_t * simple_barrier_create( uint32_t  count )
    247250{
    248     kmem_req_t         req;
    249251    simple_barrier_t * barrier;
    250252
     
    258260
    259261    // allocate memory for simple barrier descriptor
    260     req.type   = KMEM_KCM;
    261     req.order  = bits_log2( sizeof(simple_barrier_t) );
    262     req.flags  = AF_ZERO | AF_KERNEL;
    263     barrier    = kmem_remote_alloc( ref_cxy , &req );
    264 
     262    barrier  = kmem_remote_alloc( ref_cxy,
     263                                  bits_log2(sizeof(simple_barrier_t)),
     264                                  AF_ZERO );
    265265    if( barrier == NULL )
    266266    {
     
    291291void simple_barrier_destroy( xptr_t barrier_xp )
    292292{
    293     kmem_req_t  req;
    294 
    295293    // get barrier cluster and local pointer
    296294    cxy_t              barrier_cxy = GET_CXY( barrier_xp );
     
    298296
    299297    // release memory allocated for barrier descriptor
    300     req.type = KMEM_KCM;
    301     req.ptr  = barrier_ptr;
    302     kmem_remote_free( barrier_cxy , &req );
     298    kmem_remote_free( barrier_cxy,
     299                      barrier_ptr,
     300                      bits_log2(sizeof(simple_barrier_t)) );
    303301
    304302#if DEBUG_BARRIER_DESTROY
     
    471469    uint32_t        y;             // Y coordinate in QDT mesh
    472470    uint32_t        l;             // level coordinate
    473     kmem_req_t      req;           // kmem request
    474471
    475472    // compute number of DQT levels, depending on the mesh size
     
    478475
    479476// check x_size and y_size arguments
    480 assert( __FUNCTION__, (z <= 16) , "DQT mesh size larger than (16*16)\n");
     477assert( __FUNCTION__, (z <= 16),
     478"DQT mesh size larger than (16*16)\n");
    481479
    482480// check size of an array of 5 DQT nodes
    483 assert( __FUNCTION__, (sizeof(dqt_node_t) * 5 <= 512 ), "array of DQT nodes larger than 512 bytes\n");
     481assert( __FUNCTION__, (sizeof(dqt_node_t) * 5 <= 512 ),
     482"array of DQT nodes larger than 512 bytes\n");
    484483
    485484// check size of DQT barrier descriptor
    486 assert( __FUNCTION__, (sizeof(dqt_barrier_t) <= 0x4000 ), "DQT barrier descriptor larger than 4 pages\n");
     485assert( __FUNCTION__, (sizeof(dqt_barrier_t) <= 0x4000 ),
     486"DQT barrier descriptor larger than 4 pages\n");
    487487
    488488    // get pointer on client thread and process descriptors
     
    502502
    503503    // 1. allocate 4 small pages for the DQT barrier descriptor in reference cluster
    504     req.type   = KMEM_PPM;
    505     req.order  = 2;                     // 4 small pages == 16 Kbytes                     
    506     req.flags  = AF_ZERO | AF_KERNEL;
    507     barrier    = kmem_remote_alloc( ref_cxy , &req );
    508 
     504    barrier    = kmem_remote_alloc( ref_cxy,
     505                                    CONFIG_PPM_PAGE_ORDER + 2,   // 4 small pages
     506                                    AF_ZERO );     
    509507    if( barrier == NULL )
    510508    {
     
    536534        {
    537535            cxy_t  cxy = HAL_CXY_FROM_XY( x , y );   // target cluster identifier
    538             xptr_t local_array_xp;                   // xptr of nodes array in cluster cxy
     536            xptr_t local_array_xp;                   // xptr on nodes array in cluster cxy
    539537
    540538            // allocate memory in existing clusters only
    541539            if( LOCAL_CLUSTER->cluster_info[x][y] )
    542540            {
    543                 req.type  = KMEM_KCM;
    544                 req.order = 9;                    // 512 bytes
    545                 req.flags = AF_ZERO | AF_KERNEL;
    546 
    547                 void * ptr = kmem_remote_alloc( cxy , &req );
     541                void * ptr = kmem_remote_alloc( cxy , 9 , AF_ZERO );  // 512 bytes
    548542
    549543                if( ptr == NULL )
     
    729723void dqt_barrier_destroy( xptr_t   barrier_xp )
    730724{
    731     kmem_req_t   req;                      // kmem request
    732725    uint32_t     x;
    733726    uint32_t     y;
    734 
    735727
    736728    // get DQT barrier descriptor cluster and local pointer
     
    767759                void  * buf       = GET_PTR( buf_xp );
    768760
    769 assert( __FUNCTION__, (cxy == GET_CXY(buf_xp)) , "bad extended pointer on dqt_nodes array\n" );
    770 
    771                 req.type  = KMEM_KCM;
    772                 req.ptr   = buf;
    773                 kmem_remote_free( cxy , &req );
     761                kmem_remote_free( cxy , buf , 9 );    // 512 bytes
    774762
    775763#if DEBUG_BARRIER_DESTROY
     
    785773
    786774    // 2. release memory allocated for barrier descriptor in ref cluster
    787     req.type = KMEM_PPM;
    788     req.ptr  = barrier_ptr;
    789     kmem_remote_free( barrier_cxy , &req );
     775    kmem_remote_free( barrier_cxy,
     776                      barrier_ptr,
     777                      CONFIG_PPM_PAGE_ORDER + 2 );   // 4 small pages
    790778
    791779#if DEBUG_BARRIER_DESTROY
Note: See TracChangeset for help on using the changeset viewer.