Changeset 321 for soft


Ignore:
Timestamp:
Jun 10, 2014, 1:26:45 PM (10 years ago)
Author:
alain
Message:

The schedulers initialisation has been modified:

  • The routing of HWIs corresponding to internal peripherals is not anymore defined in mapping. In each cluster, the GIET-VM implements a round-robin distribution to all processors in cluster.
  • The routing of the WTIs corresponding to external peripherals is not anymore defined in the mapping. The GIET-VM implement a round-robin distribution policy to all processors in the mesh.
Location:
soft/giet_vm/giet_boot
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • soft/giet_vm/giet_boot/boot.c

    r316 r321  
    2222//    - the "map.bin" file contains the hardware architecture description and the
    2323//      mapping directives. It must be stored in the the seg_boot_mapping segment
    24 //      (at address seg_boot_mapping_base).
     24//      (at address SEG_BOOT_MAPPING_BASE defined in hard_config.h file).
    2525//    - the "sys.elf" file contains the kernel binary code and data.
    2626//    - the various "application.elf" files.
    … …  
    110110#endif
    111111
     112#if !defined(SEG_BOOT_MAPPING_BASE)
     113# error: You must define SEG_BOOT_MAPPING_BASE in the hard_config.h file
     114#endif
     115
     116#if !defined(SEG_BOOT_BUFFER_BASE)
     117# error: You must define SEG_BOOT_BUFFER_BASE in the hard_config.h file
     118#endif
     119
     120#if !defined(SEG_BOOT_BUFFER_SIZE)
     121# error: You must define SEG_BOOT_BUFFER_SIZE in the hard_config.h file
     122#endif
     123
    112124#if !defined(NB_PROCS_MAX)
    113125# error The NB_PROCS_MAX value must be defined in the 'hard_config.h' file !
    … …  
    157169void boot_mapping_check()
    158170{
    159     mapping_header_t * header = (mapping_header_t *) & seg_boot_mapping_base;
     171    mapping_header_t * header = (mapping_header_t *)SEG_BOOT_MAPPING_BASE;
    160172
    161173    // checking mapping availability
    … …  
    262274mapping_pseg_t *boot_pseg_get(unsigned int seg_id)
    263275{
    264     mapping_header_t* header = (mapping_header_t*)(&seg_boot_mapping_base);
     276    mapping_header_t* header = (mapping_header_t*)SEG_BOOT_MAPPING_BASE;
    265277    mapping_pseg_t * pseg    = _get_pseg_base(header);
    266278
    … …  
    396408    unsigned int verbose = 0;   // can be used to activate trace in add_pte()
    397409
    398     mapping_header_t * header = (mapping_header_t *) & seg_boot_mapping_base;
     410    mapping_header_t * header = (mapping_header_t *)SEG_BOOT_MAPPING_BASE;
    399411    mapping_vspace_t * vspace = _get_vspace_base(header);
    400412    mapping_vseg_t   * vseg   = _get_vseg_base(header);
    … …  
    523535
    524536    // computes vseg alignment constraint
    525     mapping_header_t* header    = (mapping_header_t*)&seg_boot_mapping_base;
     537    mapping_header_t* header    = (mapping_header_t*)SEG_BOOT_MAPPING_BASE;
    526538    mapping_vobj_t*   vobj_base = _get_vobj_base( header );
    527539    unsigned int      align     = vobj_base[vseg->vobj_offset].align;
    … …  
    627639
    628640    // computes vseg alignment constraint
    629     mapping_header_t* header    = (mapping_header_t*)&seg_boot_mapping_base;
     641    mapping_header_t* header    = (mapping_header_t*)SEG_BOOT_MAPPING_BASE;
    630642    mapping_vobj_t*   vobj_base = _get_vobj_base( header );
    631643    unsigned int      align     = vobj_base[vseg->vobj_offset].align;
    … …  
    689701        _puts(" cannot be mapped on pseg ");
    690702        _puts( pseg->name );
    691         _puts("\n");
     703        _puts(" in cluster[");
     704        _putd( pseg->clusterid );
     705        _puts("]\n");
    692706        _exit();
    693707    }
    … …  
    710724    unsigned int offset;
    711725
    712     mapping_header_t * header = (mapping_header_t *) & seg_boot_mapping_base;
     726    mapping_header_t * header = (mapping_header_t *)SEG_BOOT_MAPPING_BASE;
    713727    mapping_vobj_t   * vobj   = _get_vobj_base(header);
    714728
    … …  
    808822void boot_pt_init()
    809823{
    810     mapping_header_t * header = (mapping_header_t *) &seg_boot_mapping_base;
     824    mapping_header_t * header = (mapping_header_t *)SEG_BOOT_MAPPING_BASE;
    811825    mapping_vspace_t * vspace = _get_vspace_base(header);
    812826    mapping_vseg_t   * vseg   = _get_vseg_base(header);
    … …  
    941955void boot_vobjs_init()
    942956{
    943     mapping_header_t* header = (mapping_header_t *) & seg_boot_mapping_base;
     957    mapping_header_t* header = (mapping_header_t *)SEG_BOOT_MAPPING_BASE;
    944958    mapping_vspace_t* vspace = _get_vspace_base(header);
    945959    mapping_vobj_t* vobj     = _get_vobj_base(header);
    … …  
    11771191                           unsigned int* length )
    11781192{
    1179     mapping_header_t* header = (mapping_header_t *) & seg_boot_mapping_base;
     1193    mapping_header_t* header = (mapping_header_t *)SEG_BOOT_MAPPING_BASE;
    11801194    mapping_vobj_t*   vobj   = _get_vobj_base(header);
    11811195    mapping_vseg_t*   vseg   = _get_vseg_base(header);
    … …  
    12121226// - In Step 1, it initialises the _schedulers[gpid] pointers array, and scan
    12131227//              the processors to initialise the schedulers, including the
    1214 //              idle_task context (ltid == 14).
    1215 // - In Step 2, it scan all tasks in all vspaces to initialise the tasks contexts,
    1216 //              as specified in the mapping_info data structure.
     1228//              idle_task context (ltid == 14) and HWI / SWI / PTI vectors.
     1229// - In Step 2, it scan all tasks in all vspaces to complete the tasks contexts,
     1230//              initialisation as specified in the mapping_info data structure.
    12171231////////////////////////////////////////////////////////////////////////////////////
    12181232void boot_schedulers_init()
    12191233{
    1220     mapping_header_t*  header  = (mapping_header_t *) & seg_boot_mapping_base;
     1234    mapping_header_t*  header  = (mapping_header_t *)SEG_BOOT_MAPPING_BASE;
    12211235    mapping_cluster_t* cluster = _get_cluster_base(header);
    12221236    mapping_vspace_t*  vspace  = _get_vspace_base(header);
    … …  
    12311245    unsigned int vspace_id;     // vspace index in mapping_info
    12321246    unsigned int task_id;       // task index in mapping_info
    1233 
    1234     // TTY, NIC, CMA, HBA, TIM and DMA channels allocators
     1247    unsigned int vobj_id;       // vobj index in mapping_info
     1248
     1249    unsigned int lpid;          // local processor index (for several loops)
     1250
     1251    // TTY, NIC, CMA, HBA, user timer, and WTI channel allocators to user tasks:
    12351252    // - TTY[0] is reserved for the kernel
    12361253    // - In all clusters the first NB_PROCS_MAX timers
    12371254    //   are reserved for the kernel (context switch)
    1238 
    1239     unsigned int alloc_tty_channel = 1;             // TTY channel allocator
    1240     unsigned int alloc_nic_channel = 0;             // NIC channel allocator
    1241     unsigned int alloc_cma_channel = 0;             // CMA channel allocator
    1242     unsigned int alloc_hba_channel = 0;             // HBA channel allocator
    1243     unsigned int alloc_tim_channel[X_SIZE*Y_SIZE];  // user TIMER allocators
     1255    unsigned int alloc_tty_channel = 1;              // global
     1256    unsigned int alloc_nic_channel = 0;              // global
     1257    unsigned int alloc_cma_channel = 0;              // global
     1258    unsigned int alloc_hba_channel = 0;              // global
     1259    unsigned int alloc_tim_channel[X_SIZE*Y_SIZE];   // one per cluster
     1260
     1261    // WTI allocators to processors
     1262    // In all clusters, first NB_PROCS_MAX WTIs are for WAKUP
     1263    unsigned int alloc_wti_channel[X_SIZE*Y_SIZE];   // one per cluster
     1264
     1265    // pointers on the XCU and PIC peripherals
     1266    mapping_periph_t*  xcu = NULL;
     1267    mapping_periph_t*  pic = NULL;
     1268
     1269    // schedulers array base address in a cluster
     1270    unsigned int          sched_vbase; 
     1271    unsigned int          sched_length; 
     1272    static_scheduler_t*   psched; 
    12441273
    12451274    /////////////////////////////////////////////////////////////////////////
    … …  
    12691298#endif
    12701299        alloc_tim_channel[cluster_id] = NB_PROCS_MAX;
     1300        alloc_wti_channel[cluster_id] = NB_PROCS_MAX;
    12711301
    12721302        // checking processors number
    … …  
    12811311        }
    12821312 
    1283         static_scheduler_t* psched;  // schedulers array base address in cluster
    1284 
    12851313        // no schedulers initialisation if nprocs == 0
    12861314        if ( cluster[cluster_id].procs > 0 )
    12871315        {
    1288             // get scheduler array virtual base address and length from mapping
    1289             unsigned int        sched_vbase;   // schedulers segment virtual base address
    1290             unsigned int        sched_length;  // schedulers segment length
     1316            // get scheduler array virtual base address from mapping
    12911317            boot_get_sched_vaddr( cluster_id, &sched_vbase, &sched_length );
    12921318
    … …  
    13031329            psched = (static_scheduler_t*)sched_vbase;
    13041330
    1305             // scan cluster peripherals to find the ICU/XCU
    1306             unsigned int found = 0;
     1331            // scan peripherals to find the ICU/XCU and the PIC component
     1332
     1333            xcu = NULL; 
    13071334            for ( periph_id = cluster[cluster_id].periph_offset ;
    13081335                  periph_id < cluster[cluster_id].periph_offset + cluster[cluster_id].periphs;
    … …  
    13121339                    (periph[periph_id].type == PERIPH_TYPE_ICU) )
    13131340                {
    1314                     found = 1;
    1315                     break;
     1341                    xcu = &periph[periph_id];
     1342
     1343                    if ( xcu->arg < cluster[cluster_id].procs )
     1344                    {
     1345                        _puts("\n[BOOT ERROR] Not enough inputs for XCU[");
     1346                        _putd( x );
     1347                        _puts(",");
     1348                        _putd( y );
     1349                        _puts("]\n");
     1350                        _exit();
     1351                    }
     1352                }
     1353                if( periph[periph_id].type == PERIPH_TYPE_PIC )   
     1354                {
     1355                    pic = &periph[periph_id];
    13161356                }
    13171357            }
    1318             if ( found == 0 )
     1358            if ( xcu == NULL )
    13191359            {         
    13201360                _puts("\n[BOOT ERROR] No ICU / XCU component in cluster[");
    … …  
    13261366            }
    13271367
    1328             // loop on schedulers for default values initialisation
    1329             unsigned int lpid;
     1368            // loop on processors for sechedulers default values
     1369            // initialisation, including WTI and PTI vectors
    13301370            for ( lpid = 0 ; lpid < cluster[cluster_id].procs ; lpid++ )
    13311371            {
    … …  
    13491389                psched[lpid].current = IDLE_TASK_INDEX;
    13501390
    1351                 // initialise HWI / PTI / SWI vectors (valid bit = 0)
     1391                // default values for HWI / PTI / SWI vectors (valid bit = 0)
    13521392                unsigned int slot;
    13531393                for (slot = 0; slot < 32; slot++)
    … …  
    13571397                    psched[lpid].wti_vector[slot] = 0;
    13581398                }
     1399
     1400                // WTI[lpid] <= ISR_WAKUP / PTI[lpid] <= ISR_TICK
     1401                psched[lpid].wti_vector[lpid] = ISR_WAKUP | 0x80000000;
     1402                psched[lpid].pti_vector[lpid] = ISR_TICK  | 0x80000000;
    13591403
    13601404                // initializes the idle_task context in scheduler:
    … …  
    13731417                psched[lpid].context[IDLE_TASK_INDEX][CTX_VSID_ID]  = 0;
    13741418                psched[lpid].context[IDLE_TASK_INDEX][CTX_RUN_ID]   = 1;
    1375             }
    1376 
    1377            
    1378             // loop on irqs in ICU for actual HWI / PTI / WTI vectors initialisation     
    1379             for ( irq_id = periph[periph_id].irq_offset ;
    1380                   irq_id < periph[periph_id].irq_offset + periph[periph_id].irqs ;
     1419            }  // end for processors
     1420
     1421            // scan HWIs connected to local XCU
     1422            // for round-robin allocation to processors
     1423            lpid = 0;
     1424            for ( irq_id = xcu->irq_offset ;
     1425                  irq_id < xcu->irq_offset + xcu->irqs ;
    13811426                  irq_id++ )
    13821427            {
    1383                 unsigned int lpid    = irq[irq_id].dstid;
    1384                 if ( lpid >= cluster[cluster_id].procs )
    1385                 {
    1386                     _puts("\n[BOOT ERROR] Bad IRQ processor index in cluster[");
     1428                unsigned int type    = irq[irq_id].srctype;
     1429                unsigned int srcid   = irq[irq_id].srcid;
     1430                unsigned int isr     = irq[irq_id].isr & 0xFFFF;
     1431                unsigned int channel = irq[irq_id].channel << 16;
     1432
     1433                if ( (type != IRQ_TYPE_HWI) || (srcid > 31) )
     1434                {
     1435                    _puts("\n[BOOT ERROR] Bad IRQ in XCU of cluster[");
    13871436                    _putd( x );
    13881437                    _puts(",");
    … …  
    13911440                    _exit();
    13921441                }
    1393                 unsigned int type    = irq[irq_id].srctype;
    1394                 unsigned int index   = irq[irq_id].srcid;
    1395                 unsigned int isr     = irq[irq_id].isr;
    1396                 unsigned int channel = irq[irq_id].channel;
    1397 
    1398                 unsigned int entry = ((isr & 0xFFFF)          ) |
    1399                                      ((channel & 0x7FFF) << 16) |
    1400                                      0x80000000;                    // Valid entry
    1401 
    1402                 if      (type == IRQ_TYPE_HWI) psched[lpid].hwi_vector[index] = entry;
    1403                 else if (type == IRQ_TYPE_PTI) psched[lpid].pti_vector[index] = entry;
    1404                 else if (type == IRQ_TYPE_WTI) psched[lpid].wti_vector[index] = entry;
    1405 
    1406 #if BOOT_DEBUG_SCHED
    1407 _puts("- IRQ : type = ");
    1408 _putd( type );
    1409 _puts(" / index = ");
    1410 _putd( index );
    1411 _puts(" / isr = ");
    1412 _putd( isr );
    1413 _puts(" / channel = ");
    1414 _putd( channel );
    1415 _puts("\n");
    1416 #endif
     1442
     1443                psched[lpid].hwi_vector[srcid] = isr | channel | 0x80000000;
     1444                lpid = (lpid + 1) % cluster[cluster_id].procs;
    14171445
    14181446            } // end for irqs
    14191447        } // end if nprocs > 0
    14201448    } // end for clusters
     1449
     1450    // If there is an external PIC component, we scan HWIs connected to PIC
     1451    // for Round Robin allocation (as WTI) to processors.
     1452    // We allocate one WTI per processor, starting from proc[0,0,0],
     1453    // and we increment (cluster_id, lpid) as required.
     1454    if ( pic != NULL )
     1455    {   
     1456        unsigned int cluster_id = 0;   // index in clusters array
     1457        unsigned int lpid       = 0;   // processor local index
     1458
     1459        // scan IRQS defined in PIC
     1460        for ( irq_id = pic->irq_offset ;
     1461              irq_id < pic->irq_offset + pic->irqs ;
     1462              irq_id++ )
     1463        {
     1464            // compute next values for (cluster_id,lpid)
     1465            // if no more procesor available in current cluster
     1466            unsigned int overflow = 0;
     1467            while ( (lpid >= cluster[cluster_id].procs) ||
     1468                    (alloc_wti_channel[cluster_id] >= xcu->arg) )
     1469            {
     1470                overflow++;
     1471                cluster_id = (cluster_id + 1) % (X_SIZE*Y_SIZE);
     1472                lpid       = 0;
     1473
     1474                // overflow detection
     1475                if ( overflow > (X_SIZE*Y_SIZE*NB_PROCS_MAX*32) )
     1476                {
     1477                    _puts("\n[BOOT ERROR] Not enough processors for external IRQs\n");
     1478                    _exit();
     1479                }
     1480            }
     1481
     1482            unsigned int type    = irq[irq_id].srctype;
     1483            unsigned int srcid   = irq[irq_id].srcid;
     1484            unsigned int isr     = irq[irq_id].isr & 0xFFFF;
     1485            unsigned int channel = irq[irq_id].channel << 16;
     1486
     1487            if ( (type != IRQ_TYPE_HWI) || (srcid > 31) )
     1488            {
     1489                _puts("\n[BOOT ERROR] Bad IRQ in PIC component\n");
     1490                _exit();
     1491            }
     1492
     1493            // get scheduler[cluster_id] address
     1494            unsigned int x          = cluster[cluster_id].x;
     1495            unsigned int y          = cluster[cluster_id].y;
     1496            unsigned int cluster_xy = (x<<Y_WIDTH) + y;
     1497            psched                  = _schedulers[cluster_xy * NB_PROCS_MAX];
     1498
     1499            // update WTI vector for scheduler[cluster_id][lpid]
     1500            unsigned int index = alloc_wti_channel[cluster_id];
     1501            psched[lpid].wti_vector[index] = isr | channel | 0x80000000;
     1502            alloc_wti_channel[cluster_id] = index + 1;
     1503            lpid = lpid + 1;
     1504
     1505            // update IRQ fields in mapping for PIC initialisation
     1506            irq[irq_id].dest_id = index;
     1507            irq[irq_id].dest_xy = cluster_xy;
     1508
     1509        }  // end for IRQs
     1510    } // end if PIC
     1511               
     1512#if BOOT_DEBUG_SCHED
     1513for ( cluster_id = 0 ; cluster_id < (X_SIZE*Y_SIZE) ; cluster_id++ )
     1514{
     1515    unsigned int x          = cluster[cluster_id].x;
     1516    unsigned int y          = cluster[cluster_id].y;
     1517    unsigned int cluster_xy = (x<<Y_WIDTH) + y;
     1518    psched                  = _schedulers[cluster_xy * NB_PROCS_MAX];
     1519    unsigned int slot;
     1520    unsigned int entry;
     1521    for ( lpid = 0 ; lpid < cluster[cluster_id].procs ; lpid++ )
     1522    {
     1523        _puts("\n*** IRQS for proc[");
     1524        _putd( x );
     1525        _puts(",");
     1526        _putd( y );
     1527        _puts(",[");
     1528        _putd( lpid );
     1529        _puts("]\n");
     1530        for ( slot = 0 ; slot < 32 ; slot++ )
     1531        {
     1532            entry = psched[lpid].hwi_vector[slot];
     1533            if ( entry & 0x80000000 )
     1534            {
     1535                _puts(" - HWI ");
     1536                _putd( slot );
     1537                _puts(" / isrtype = ");
     1538                _putd( entry & 0xFFFF );
     1539                _puts(" / channel = ");
     1540                _putd( (entry >> 16) & 0x7FFF );
     1541                _puts("\n");
     1542            }
     1543        }
     1544        for ( slot = 0 ; slot < 32 ; slot++ )
     1545        {
     1546            entry = psched[lpid].wti_vector[slot];
     1547            if ( entry & 0x80000000 )
     1548            {
     1549                _puts(" - WTI ");
     1550                _putd( slot );
     1551                _puts(" / isrtype = ");
     1552                _putd( entry & 0xFFFF );
     1553                _puts(" / channel = ");
     1554                _putd( (entry >> 16) & 0x7FFF );
     1555                _puts("\n");
     1556            }
     1557        }
     1558        for ( slot = 0 ; slot < 32 ; slot++ )
     1559        {
     1560            entry = psched[lpid].pti_vector[slot];
     1561            if ( entry & 0x80000000 )
     1562            {
     1563                _puts(" - PTI ");
     1564                _putd( slot );
     1565                _puts(" / isrtype = ");
     1566                _putd( entry & 0xFFFF );
     1567                _puts(" / channel = ");
     1568                _putd( (entry >> 16) & 0x7FFF );
     1569                _puts("\n");
     1570            }
     1571        }
     1572    }
     1573}
     1574#endif
    14211575
    14221576    ///////////////////////////////////////////////////////////////////
    … …  
    14501604            // compute gpid (global processor index) and scheduler base address
    14511605            unsigned int gpid = cluster_xy * NB_PROCS_MAX + lpid;
    1452             static_scheduler_t* psched = _schedulers[gpid];
     1606            psched            = _schedulers[gpid];
    14531607
    14541608            // ctx_sr : value required before an eret instruction
    … …  
    15581712            // the task entry point : the start_vector is stored by GCC in the seg_data
    15591713            // segment and we must wait the .elf loading to get the entry point value...
    1560             mapping_vobj_t* pvobj = &vobj[vspace[vspace_id].vobj_offset +
    1561                                      vspace[vspace_id].start_offset];
    1562             unsigned int ctx_epc = pvobj->vaddr + (task[task_id].startid)*4;
     1714            vobj_id = vspace[vspace_id].start_vobj_id;     
     1715            unsigned int ctx_epc = vobj[vobj_id].vaddr + (task[task_id].startid)*4;
    15631716
    15641717            // ctx_sp :  Get the vobj containing the stack
    1565             unsigned int vobj_id = task[task_id].stack_vobjid + vspace[vspace_id].vobj_offset;
     1718            vobj_id = task[task_id].stack_vobj_id;
    15661719            unsigned int ctx_sp = vobj[vobj_id].vaddr + vobj[vobj_id].length;
    15671720
    … …  
    16831836    unsigned int ok = _fat_read( IOC_BOOT_MODE,
    16841837                                 fd_id,
    1685                                  (unsigned int*)( &seg_boot_mapping_base),
     1838                                 (unsigned int*)SEG_BOOT_MAPPING_BASE,
    16861839                                 nblocks,       
    16871840                                 0 );      // offset
    … …  
    17161869
    17171870    // get boot buffer address and size
    1718     char*             boot_buffer      = (char*)(&seg_boot_buffer_base);
    1719     unsigned int      boot_buffer_size = (unsigned int)(&seg_boot_buffer_size);
     1871    char*             boot_buffer      = (char*)SEG_BOOT_BUFFER_BASE;
     1872    unsigned int      boot_buffer_size = SEG_BOOT_BUFFER_SIZE;
    17201873
    17211874#if BOOT_DEBUG_ELF
    … …  
    18822035void boot_elf_load()
    18832036{
    1884     mapping_header_t* header = (mapping_header_t *) & seg_boot_mapping_base;
     2037    mapping_header_t* header = (mapping_header_t *)SEG_BOOT_MAPPING_BASE;
    18852038    mapping_vspace_t* vspace = _get_vspace_base( header );
    18862039    mapping_vobj_t*   vobj   = _get_vobj_base( header );
    … …  
    19702123void boot_peripherals_init()
    19712124{
    1972     mapping_header_t * header   = (mapping_header_t *) & seg_boot_mapping_base;
     2125    mapping_header_t * header   = (mapping_header_t *)SEG_BOOT_MAPPING_BASE;
    19732126    mapping_cluster_t * cluster = _get_cluster_base(header);
    19742127    mapping_periph_t * periph   = _get_periph_base(header);
    19752128    mapping_vobj_t * vobj       = _get_vobj_base(header);
    1976     mapping_vspace_t * vspace   = _get_vspace_base(header);
    19772129    mapping_coproc_t * coproc   = _get_coproc_base(header);
    19782130    mapping_cp_port_t * cp_port = _get_cp_port_base(header);
    … …  
    20662218#if 0
    20672219                    // initialize r_xicu_base & r_xicu_size registers
    2068                     unsigned int base = (unsigned int)&seg_xcu_base;
     2220                    unsigned int base = (unsigned int)SEG_XCU_BASE;
    20692221
    20702222#if BOOT_DEBUG_PERI
    … …  
    21082260                          channel_id++ )
    21092261                    {
    2110                         unsigned int hwi_id     = irq[channel_id].srcid;  // HWI index in PIC
    2111                         unsigned int wti_id     = irq[channel_id].dstid;  // WTI index in XCU
    2112                         unsigned int x          = irq[channel_id].dstx;   // XCU X coordinate
    2113                         unsigned int y          = irq[channel_id].dsty;   // XCU Y coordinate
    2114                         unsigned int cluster_xy = (x<<Y_WIDTH) + y;       // XCU cluster
     2262                        unsigned int hwi_id     = irq[channel_id].srcid;   // HWI index in PIC
     2263                        unsigned int wti_id     = irq[channel_id].dest_id; // WTI index in XCU
     2264                        unsigned int cluster_xy = irq[channel_id].dest_xy; // XCU coordinates
    21152265                        unsigned int vaddr;
    21162266
    … …  
    21262276_putx( vaddr );
    21272277_puts(" in cluster[");
    2128 _putd( x );
     2278_putd( cluster_xy >> Y_WIDTH );
    21292279_puts(",");
    2130 _putd( y );
     2280_putd( cluster_xy & ((1<<Y_WIDTH)-1) );
    21312281_puts("]\n");
    21322282#endif
    … …  
    21632313                  cp_port_id++ )
    21642314            {
    2165                 unsigned int vspace_id = cp_port[cp_port_id].vspaceid;
    2166                 unsigned int vobj_id   = cp_port[cp_port_id].mwmr_vobjid +
    2167                                                 vspace[vspace_id].vobj_offset;
     2315                // Get global index of associted vobj
     2316                unsigned int vobj_id   = cp_port[cp_port_id].mwmr_vobj_id;
    21682317
    21692318                // Get MWMR channel base address
    … …  
    21812330_puts(" / name = ");
    21822331_puts(vobj[vobj_id].name);
    2183 _puts(" / in vspace ");
    2184 _puts(vspace[vspace_id].name);
    21852332_puts("\n");
    21862333#endif
    … …  
    21962343void boot_init()
    21972344{
    2198     mapping_header_t*  header     = (mapping_header_t *) & seg_boot_mapping_base;
     2345    mapping_header_t*  header     = (mapping_header_t *)SEG_BOOT_MAPPING_BASE;
    21992346    mapping_cluster_t* cluster    = _get_cluster_base(header);
    22002347    unsigned int       gpid       = _get_procid();
    … …  
    22882435    }
    22892436
    2290     // all processors jump to kernel_init
    2291     unsigned int kernel_entry = (unsigned int)&seg_kernel_init_base;
     2437    // all processors jump to kernel_init (address defined in giet_vsegs.ld)
     2438    unsigned int kernel_entry = (unsigned int)&kernel_init_vbase;
    22922439    asm volatile( "jr   %0" ::"r"(kernel_entry) );
    22932440

  • soft/giet_vm/giet_boot/boot.ld

    r258 r321  
    99/* Definition of the entry point for the BOOT code.                         */
    1010/* The address of the boot_init function is stored in the .elf header,      */
    11 /* and is used by the préloader to jump into the boot code.                 */
     11/* and is used by the preloader to jump into the boot code.                 */
    1212/****************************************************************************/
    1313
    … …  
    1919SECTIONS
    2020{
    21     . = seg_boot_code_base;
     21    . = boot_code_vbase;
    2222    seg_boot_code :
    2323    {
    … …  
    2727    }
    2828
    29     . = seg_boot_data_base;
     29    . = boot_data_vbase;
    3030    seg_boot_data :
    3131    {
Note: See TracChangeset for help on using the changeset viewer.