Changeset 93 for trunk


Ignore:
Timestamp:
Jun 29, 2017, 12:46:00 PM (8 years ago)
Author:
max@…
Message:

style

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/kernel/libk/remote_spinlock.c

    r60 r93  
    11/*
    22 * remote_spinlock.c - kernel remote spinlock implementation.
    3  * 
     3 *
    44 * Authors  Mohamed Karaoui (2015)
    55 *          Alain   Greiner (2016)
    … …  
    3333///////////////////////////////////////////
    3434void remote_spinlock_init( xptr_t lock_xp )
    35 { 
    36     remote_spinlock_t * ptr = (remote_spinlock_t *)GET_PTR( lock_xp );
    37     cxy_t               cxy = GET_CXY( lock_xp );
    38 
    39     hal_remote_sw ( XPTR( cxy , &ptr->taken ) , 0 );
    40     hal_remote_swd( XPTR( cxy , &ptr->owner ) , XPTR_NULL );
    41     xlist_entry_init( XPTR( cxy , &ptr->list ) );
     35{
     36        remote_spinlock_t * ptr = (remote_spinlock_t *)GET_PTR( lock_xp );
     37        cxy_t               cxy = GET_CXY( lock_xp );
     38
     39        hal_remote_sw ( XPTR( cxy , &ptr->taken ) , 0 );
     40        hal_remote_swd( XPTR( cxy , &ptr->owner ) , XPTR_NULL );
     41        xlist_entry_init( XPTR( cxy , &ptr->list ) );
    4242}
    4343
    4444/////////////////////////////////////////////////
    4545error_t remote_spinlock_trylock( xptr_t lock_xp )
    46 { 
     46{
    4747        reg_t               mode;
    4848        bool_t              isAtomic = false;
    4949
    50     // get cluster and local pointer on remote_spinlock
    51     remote_spinlock_t * lock_ptr = (remote_spinlock_t *)GET_PTR( lock_xp );
    52     cxy_t               lock_cxy = GET_CXY( lock_xp );
    53 
    54     // get cluster and local pointer on local thread
    55     cxy_t               thread_cxy = local_cxy;
    56     thread_t          * thread_ptr = CURRENT_THREAD;
    57 
    58     // disable interrupts
    59     hal_disable_irq( &mode );
     50        // get cluster and local pointer on remote_spinlock
     51        remote_spinlock_t * lock_ptr = (remote_spinlock_t *)GET_PTR( lock_xp );
     52        cxy_t               lock_cxy = GET_CXY( lock_xp );
     53
     54        // get cluster and local pointer on local thread
     55        cxy_t               thread_cxy = local_cxy;
     56        thread_t          * thread_ptr = CURRENT_THREAD;
     57
     58        // disable interrupts
     59        hal_disable_irq( &mode );
    6060
    6161        if( hal_remote_lw( XPTR( lock_cxy , &lock_ptr->taken ) ) == 0 )
    62     {
     62        {
    6363                isAtomic = hal_remote_atomic_cas( XPTR( lock_cxy , &lock_ptr->taken ) , 0 , 1 );
    64     }
    65 
    66         if( isAtomic == false )    // failure 
     64        }
     65
     66        if( isAtomic == false )    // failure
    6767        {
    6868                hal_restore_irq( mode );
    6969                return 1;
    7070        }
    71     else                      // success : register lock in thread
    72     {
    73             thread_ptr->remote_locks++;
    74 
    75         hal_remote_swd( XPTR( lock_cxy , &lock_ptr->owner ) ,
    76                     (uint64_t)XPTR( thread_cxy , thread_ptr) );
    77 
    78         xlist_add_first( XPTR( thread_cxy , &thread_ptr->xlocks_root ) ,
    79                      XPTR( lock_cxy , &lock_ptr->list ) );
    80 
    81             hal_restore_irq(mode); 
    82             return 0;
    83     }
     71        else                      // success : register lock in thread
     72        {
     73                thread_ptr->remote_locks++;
     74
     75                hal_remote_swd( XPTR( lock_cxy , &lock_ptr->owner ) ,
     76                            (uint64_t)XPTR( thread_cxy , thread_ptr) );
     77
     78                xlist_add_first( XPTR( thread_cxy , &thread_ptr->xlocks_root ) ,
     79                             XPTR( lock_cxy , &lock_ptr->list ) );
     80
     81                hal_restore_irq(mode);
     82                return 0;
     83        }
    8484}
    8585
    … …  
    8888                                uint32_t * irq_state )
    8989{
    90     bool_t              isAtomic = false;
     90        bool_t              isAtomic = false;
    9191        reg_t               mode;
    92     volatile uint32_t   taken;
    93 
    94     // get cluster and local pointer on remote_spinlock
    95     remote_spinlock_t * lock_ptr = (remote_spinlock_t *)GET_PTR( lock_xp );
    96     cxy_t               lock_cxy = GET_CXY( lock_xp );
    97 
    98     // get cluster and local pointer on local thread
    99     cxy_t               thread_cxy = local_cxy;
    100     thread_t          * thread_ptr = CURRENT_THREAD;
    101 
    102     // disable interrupts
     92        volatile uint32_t   taken;
     93
     94        // get cluster and local pointer on remote_spinlock
     95        remote_spinlock_t * lock_ptr = (remote_spinlock_t *)GET_PTR( lock_xp );
     96        cxy_t               lock_cxy = GET_CXY( lock_xp );
     97
     98        // get cluster and local pointer on local thread
     99        cxy_t               thread_cxy = local_cxy;
     100        thread_t          * thread_ptr = CURRENT_THREAD;
     101
     102        // disable interrupts
    103103        hal_disable_irq( &mode );
    104  
    105     // loop until success
     104
     105        // loop until success
    106106        while( isAtomic == false )
    107107        {
    108108                taken = hal_remote_lw( XPTR( lock_cxy , &lock_ptr->taken ) );
    109109
    110         // try to take the lock if not already taken
     110                // try to take the lock if not already taken
    111111                if( taken == 0 )
    112112                {
    113                     isAtomic = hal_remote_atomic_cas( XPTR( lock_cxy , &lock_ptr->taken ) , 0 , 1 );
    114         }
    115         }
    116 
    117     // register lock in thread
     113                        isAtomic = hal_remote_atomic_cas( XPTR( lock_cxy , &lock_ptr->taken ) , 0 , 1 );
     114                }
     115        }
     116
     117        // register lock in thread
    118118        thread_ptr->remote_locks++;
    119119
    120     hal_remote_swd( XPTR( lock_cxy , &lock_ptr->owner ) ,
    121                     (uint64_t)XPTR( thread_cxy , thread_ptr) );
    122 
    123     xlist_add_first( XPTR( thread_cxy , &thread_ptr->xlocks_root ) ,
    124                      XPTR( lock_cxy , &lock_ptr->list ) );
    125 
    126     // irq_state must be restored when lock is released
    127     *irq_state = mode;
     120        hal_remote_swd( XPTR( lock_cxy , &lock_ptr->owner ) ,
     121                        (uint64_t)XPTR( thread_cxy , thread_ptr) );
     122
     123        xlist_add_first( XPTR( thread_cxy , &thread_ptr->xlocks_root ) ,
     124                         XPTR( lock_cxy , &lock_ptr->list ) );
     125
     126        // irq_state must be restored when lock is released
     127        *irq_state = mode;
    128128
    129129}  // end remote_spinlock_lock_busy()
    … …  
    133133                                  uint32_t  irq_state )
    134134{
    135     // get cluster and local pointer on remote_spinlock
    136     remote_spinlock_t * lock_ptr = (remote_spinlock_t *)GET_PTR( lock_xp );
    137     cxy_t               lock_cxy = GET_CXY( lock_xp );
    138 
    139     // get pointer on local thread
    140     thread_t          * thread_ptr = CURRENT_THREAD;
     135        // get cluster and local pointer on remote_spinlock
     136        remote_spinlock_t * lock_ptr = (remote_spinlock_t *)GET_PTR( lock_xp );
     137        cxy_t               lock_cxy = GET_CXY( lock_xp );
     138
     139        // get pointer on local thread
     140        thread_t          * thread_ptr = CURRENT_THREAD;
    141141
    142142        hal_remote_swd( XPTR( lock_cxy , &lock_ptr->owner ) , XPTR_NULL );
    … …  
    146146        thread_ptr->remote_locks--;
    147147
    148     xlist_unlink( XPTR( lock_cxy , &lock_ptr->list ) );
    149 
    150     hal_restore_irq( irq_state );
     148        xlist_unlink( XPTR( lock_cxy , &lock_ptr->list ) );
     149
     150        hal_restore_irq( irq_state );
    151151}
    152152
    … …  
    154154void remote_spinlock_lock( xptr_t lock_xp )
    155155{
    156     bool_t              isAtomic = false;
     156        bool_t              isAtomic = false;
    157157        reg_t               mode;
    158     volatile uint32_t   taken;
    159 
    160     // get cluster and local pointer on remote_spinlock
    161     remote_spinlock_t * lock_ptr = (remote_spinlock_t *)GET_PTR( lock_xp );
    162     cxy_t               lock_cxy = GET_CXY( lock_xp );
    163 
    164     // get cluster and local pointer on local thread
    165     cxy_t               thread_cxy = local_cxy;
    166     thread_t          * thread_ptr = CURRENT_THREAD;
    167 
    168     // disable interrupts
     158        volatile uint32_t   taken;
     159
     160        // get cluster and local pointer on remote_spinlock
     161        remote_spinlock_t * lock_ptr = (remote_spinlock_t *)GET_PTR( lock_xp );
     162        cxy_t               lock_cxy = GET_CXY( lock_xp );
     163
     164        // get cluster and local pointer on local thread
     165        cxy_t               thread_cxy = local_cxy;
     166        thread_t          * thread_ptr = CURRENT_THREAD;
     167
     168        // disable interrupts
    169169        hal_disable_irq( &mode );
    170  
    171     // loop until success
     170
     171        // loop until success
    172172        while( isAtomic == false )
    173173        {
    174174                taken = hal_remote_lw( XPTR( lock_cxy , &lock_ptr->taken ) );
    175175
    176         // deschedule if possible when lock already taken
     176                // deschedule if possible when lock already taken
    177177                if( taken != 0 )
    178178                {
    179                 hal_restore_irq( mode );
    180             if( thread_can_yield() ) sched_yield();
    181                 hal_disable_irq( &mode );
     179                        hal_restore_irq( mode );
     180                        if( thread_can_yield() ) sched_yield();
     181                        hal_disable_irq( &mode );
    182182                        continue;
    183183                }
    184    
    185         // try to take the lock if not already taken
     184
     185                // try to take the lock if not already taken
    186186                isAtomic = hal_remote_atomic_cas( XPTR( lock_cxy , &lock_ptr->taken ) , 0 , 1 );
    187187        }
    188188
    189     // register lock in thread
     189        // register lock in thread
    190190        thread_ptr->remote_locks++;
    191191
    192     hal_remote_swd( XPTR( lock_cxy , &lock_ptr->owner ) ,
    193                     (uint64_t)XPTR( thread_cxy , thread_ptr) );
    194 
    195     xlist_add_first( XPTR( thread_cxy , &thread_ptr->xlocks_root ) ,
    196                      XPTR( lock_cxy , &lock_ptr->list ) );
    197 
    198     // enable interrupts
     192        hal_remote_swd( XPTR( lock_cxy , &lock_ptr->owner ) ,
     193                        (uint64_t)XPTR( thread_cxy , thread_ptr) );
     194
     195        xlist_add_first( XPTR( thread_cxy , &thread_ptr->xlocks_root ) ,
     196                         XPTR( lock_cxy , &lock_ptr->list ) );
     197
     198        // enable interrupts
    199199        hal_restore_irq( mode );
    200200}
    … …  
    203203void remote_spinlock_unlock( xptr_t lock_xp )
    204204{
    205     // get cluster and local pointer on remote_spinlock
    206     remote_spinlock_t * lock_ptr = (remote_spinlock_t *)GET_PTR( lock_xp );
    207     cxy_t               lock_cxy = GET_CXY( lock_xp );
    208 
    209     // get pointer on local thread
    210     thread_t          * thread_ptr = CURRENT_THREAD;
     205        // get cluster and local pointer on remote_spinlock
     206        remote_spinlock_t * lock_ptr = (remote_spinlock_t *)GET_PTR( lock_xp );
     207        cxy_t               lock_cxy = GET_CXY( lock_xp );
     208
     209        // get pointer on local thread
     210        thread_t          * thread_ptr = CURRENT_THREAD;
    211211
    212212        hal_remote_swd( XPTR( lock_cxy , &lock_ptr->owner ) , XPTR_NULL );
    … …  
    216216        thread_ptr->remote_locks--;
    217217
    218     xlist_unlink( XPTR( lock_cxy , &lock_ptr->list ) );
    219 }
    220 
     218        xlist_unlink( XPTR( lock_cxy , &lock_ptr->list ) );
     219}
     220
Note: See TracChangeset for help on using the changeset viewer.