Ignore:
Timestamp:
Jan 29, 2018, 6:08:07 PM (4 years ago)
Author:
alain
Message:

blip

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/kernel/kern/cluster.c

    r416 r428  
    5555error_t cluster_init( struct boot_info_s * info )
    5656{
    57     error_t     error;
    58     lpid_t      lpid;     // local process_index
    59     lid_t       lid;      // local core index
     57    error_t         error;
     58    lpid_t          lpid;     // local process_index
     59    lid_t           lid;      // local core index
     60    uint32_t        i;        // index in loop on external peripherals
     61    boot_device_t * dev;      // pointer on external peripheral
     62    uint32_t        func;     // external peripheral functionnal type
    6063
    6164        cluster_t * cluster = LOCAL_CLUSTER;
     
    6972        cluster->io_cxy          = info->io_cxy;
    7073
     74    // initialize external peripherals channels
     75    for( i = 0 ; i < info->ext_dev_nr ; i++ )
     76    {
     77        dev  = &info->ext_dev[i];
     78        func = FUNC_FROM_TYPE( dev->type );   
     79        if( func == DEV_FUNC_TXT ) cluster->nb_txt_channels = dev->channels;
     80        if( func == DEV_FUNC_NIC ) cluster->nb_nic_channels = dev->channels;
     81        if( func == DEV_FUNC_IOC ) cluster->nb_ioc_channels = dev->channels;
     82        if( func == DEV_FUNC_FBF ) cluster->nb_fbf_channels = dev->channels;
     83    }
     84
    7185    // initialize cluster local parameters
    7286        cluster->cores_nr        = info->cores_nr;
     
    199213
    200214////////////////////////////////////////////////////////////////////////////////////
    201 //  Process management related functions
     215//  Process related functions
    202216////////////////////////////////////////////////////////////////////////////////////
    203217
     
    336350    remote_spinlock_lock_busy( XPTR( local_cxy , &pm->local_lock ) , & irq_state );
    337351
    338     xlist_add_first( XPTR( local_cxy , &pm->local_root ),
    339                      XPTR( local_cxy , &process->local_list ) );
     352    xlist_add_last( XPTR( local_cxy , &pm->local_root ),
     353                    XPTR( local_cxy , &process->local_list ) );
    340354    pm->local_nr++;
    341355
     
    417431}
    418432
    419 ////////////////////////////////////////////////////////////////////////////////////////
    420 // TODO Il me semble que la seule chose que fait ce kernel thread à chaque réveil
    421 // est de mettre à jour la DQDT, et de se rendormir... A-t-on besoin d'un thread ? [AG]
    422 //////////////////////////////////////////////////////////////////////////////////////////
    423 
    424 #if 0
    425 void * cluster_manager_thread( void * arg )
    426 {
    427         register struct dqdt_cluster_s * root;
    428         register struct cluster_s      * root_home;
    429 
    430         register uint32_t                tm_start;
    431         register uint32_t                tm_end;
    432         register uint32_t                cpu_id;
    433         struct cluster_s               * cluster;
    434         struct thread_s                * this;
    435         struct event_s                   event;
    436         struct alarm_info_s              info;
    437         register uint32_t                cntr;
    438         register bool_t                  isRootMgr;
    439         register uint32_t                period;
    440 
    441         cpu_enable_all_irq( NULL );
    442 
    443         cluster   = arg;
    444         this      = CURRENT_THREAD;
    445         cpu_id    = cpu_get_id();
    446         root      = dqdt_root;
    447         root_home = dqdt_root->home;
    448         isRootMgr = (cluster == root_home) ? true : false;
    449         cntr      = 0;
    450         period    = (isRootMgr) ?
    451                 CONFIG_DQDT_ROOTMGR_PERIOD * MSEC_PER_TICK :
    452                 CONFIG_DQDT_MGR_PERIOD * MSEC_PER_TICK;
    453 
    454         event_set_senderId(&event, this);
    455         event_set_priority(&event, E_CHR);
    456         event_set_handler(&event, &manager_alarm_event_handler);
    457 
    458         info.event = &event;
    459         thread_preempt_disable(CURRENT_THREAD);
    460 
    461     // infinite loop
    462         while(1)
    463         {
    464                 tm_start = cpu_time_stamp();
    465                 dqdt_update();
    466                 tm_end   = cpu_time_stamp();
    467 
    468                 if(isRootMgr)
    469                 {
    470                         if((cntr % 10) == 0)
    471                         {
    472                                 printk(INFO, "INFO: cpu %d, DQDT update ended [ %u - %u ]\n",
    473                                        cpu_id,
    474                                        tm_end,
    475                                        tm_end - tm_start);
    476 
    477                                 dqdt_print_summary(root);
    478                         }
    479                 }
    480 
    481                 alarm_wait( &info , period );
    482                 sched_sleep(this);
    483                 cntr ++;
    484         }
    485 
    486         return NULL;
    487 } // end cluster_manager_thread()
    488 
    489 //////////////////////////////////////////
    490 EVENT_HANDLER(manager_alarm_event_handler)
    491 {
    492         struct thread_s *manager;
    493 
    494         manager = event_get_senderId(event);
    495 
    496         thread_preempt_disable(CURRENT_THREAD);
    497 
    498         //printk(INFO, "%s: cpu %d [%u]\n", __FUNCTION__, cpu_get_id(), cpu_time_stamp());
    499 
    500         sched_wakeup(manager);
    501 
    502         thread_preempt_enable(CURRENT_THREAD);
    503 
    504         return 0;
    505 }
    506 
    507 ///////////////////////////////////////////////
    508 EVENT_HANDLER(cluster_key_create_event_handler)
    509 {
    510         struct cluster_s *cluster;
    511         struct thread_s *sender;
    512         ckey_t *ckey;
    513         uint32_t key;
    514 
    515         sender  = event_get_senderId(event);
    516         ckey    = event_get_argument(event);
    517         cluster = current_cluster;
    518         key     = cluster->next_key;
    519 
    520         while((key < CLUSTER_TOTAL_KEYS_NR) && (cluster->keys_tbl[key] != NULL))
    521                 key ++;
    522 
    523         if(key < CLUSTER_TOTAL_KEYS_NR)
    524         {
    525                 ckey->val = key;
    526                 cluster->keys_tbl[key] = (void *) 0x1; // Reserved
    527                 cluster->next_key = key;
    528                 event_set_error(event, 0);
    529         }
    530         else
    531                 event_set_error(event, ENOSPC);
    532 
    533         sched_wakeup(sender);
    534         return 0;
    535 }
    536 
    537 ///////////////////////////////////////////////
    538 EVENT_HANDLER(cluster_key_delete_event_handler)
    539 {
    540         struct cluster_s *cluster;
    541         struct thread_s *sender;
    542         ckey_t *ckey;
    543         uint32_t key;
    544 
    545         sender  = event_get_senderId(event);
    546         ckey    = event_get_argument(event);
    547         cluster = current_cluster;
    548         key     = ckey->val;
    549 
    550         if(key < cluster->next_key)
    551                 cluster->next_key = key;
    552 
    553         cluster->keys_tbl[key] = NULL;
    554         event_set_error(event, 0);
    555 
    556         sched_wakeup(sender);
    557         return 0;
    558 }
    559 
    560 #define _CKEY_CREATE  0x0
    561 #define _CKEY_DELETE  0x1
    562 
    563 error_t cluster_do_key_op(ckey_t *key, uint32_t op)
    564 {
    565         struct event_s event;
    566         struct thread_s *this;
    567         struct cluster_s *cluster;
    568         struct cpu_s *cpu;
    569 
    570         this = CURRENT_THREAD;
    571 
    572         event_set_priority(&event, E_FUNC);
    573         event_set_senderId(&event, this);
    574         event_set_argument(&event, key);
    575 
    576         if(op == _CKEY_CREATE)
    577                 event_set_handler(&event, cluster_key_create_event_handler);
    578         else
    579                 event_set_handler(&event, cluster_key_delete_event_handler);
    580 
    581         cluster = current_cluster;
    582         cpu     = cluster->bscluster->bscpu;
    583         event_send(&event, &cpu->re_listner);
    584 
    585         sched_sleep(this);
    586 
    587         return event_get_error(&event);
    588 }
    589 
    590 error_t cluster_key_create(ckey_t *key)
    591 {
    592         return cluster_do_key_op(key, _CKEY_CREATE);
    593 }
    594 
    595 error_t cluster_key_delete(ckey_t *key)
    596 {
    597         return cluster_do_key_op(key, _CKEY_DELETE);
    598 }
    599 
    600 void* cluster_getspecific(ckey_t *key)
    601 {
    602         struct cluster_s *cluster;
    603 
    604         cluster = current_cluster;
    605         return cluster->keys_tbl[key->val];
    606 }
    607 
    608 void  cluster_setspecific(ckey_t *key, void *val)
    609 {
    610         struct cluster_s *cluster;
    611 
    612         cluster = current_cluster;
    613         cluster->keys_tbl[key->val] = val;
    614 }
    615 #endif
     433///////////////////////////////////////////
     434void cluster_processes_display( cxy_t cxy )
     435{
     436    xptr_t        root_xp;
     437    xptr_t        iter_xp;
     438    xptr_t        process_xp;     
     439
     440    // get extended pointer on root of process in cluster cxy
     441    root_xp = XPTR( cxy , &LOCAL_CLUSTER->pmgr.local_root );
     442
     443    // skip one line
     444    printk("\n");
     445
     446    // loop on all reference processes in cluster cxy
     447    XLIST_FOREACH( root_xp , iter_xp )
     448    {
     449        process_xp = XLIST_ELEMENT( iter_xp , process_t , local_list );
     450        process_display( process_xp );
     451    }
     452}  // end cluster_processes_display()
     453
     454
Note: See TracChangeset for help on using the changeset viewer.