Ignore:
Timestamp:
Dec 19, 2013, 9:36:48 AM (11 years ago)
Author:
alain
Message:

Introducing support for TSAR fixed format cluster index (cluster_xy)
We have now 4 parameters defined in map.xml:

  • X_WIDTH, Y_WIDTH define the fixed format (typically X_WIDTH = 4 / Y_WIDTH = 4)
  • X_SIZE, Y_SIZE define the actual TSAR 2D mesh variable size (from 1 to 16)
File:
1 edited

Legend:

Unmodified
Added
Removed

  • soft/giet_vm/giet_boot/boot.c

    r262 r263  
    1111// physicals addresses can have up to 40 bits, and use the  (unsigned long long) type.
    1212// It natively supports clusterised shared mmemory multi-processors architectures,
    13 // where each processor is identified by a composite index (cluster_id, local_id),
     13// where each processor is identified by a composite index (cluster_xy, local_id),
    1414// and where there is one physical memory bank per cluster.
    1515//
    … …  
    6161//    Each PT2 contains 512 PTE2 of 8bytes => 4K bytes.
    6262//    The total size of a page table is finally = 8K + (GIET_NB_PT2_MAX)*4K bytes.
    63 ////////////////////////////////////////////////////////////////////////////////////
     63///////////////////////////////////////////////////////////////////////////////////////
     64// Implementation Notes:
     65//
     66// 1) The cluster_id variable is a linear index in the mapping_info array of clusters.
     67//    We use the cluster_xy variable for the tological index = x << Y_WIDTH + y
     68///////////////////////////////////////////////////////////////////////////////////////
    6469
    6570// for vobjs initialisation
     71#include <giet_config.h>
    6672#include <mwmr_channel.h>
    6773#include <barrier.h>
    … …  
    8793#include <stdarg.h>
    8894
    89 #if !defined(NB_CLUSTERS)
    90 # error The NB_CLUSTERS value must be defined in the 'giet_config.h' file !
     95#if !defined(X_SIZE)
     96# error The X_SIZE value must be defined in the 'hard_config.h' file !
     97#endif
     98
     99#if !defined(Y_SIZE)
     100# error The Y_SIZE value must be defined in the 'hard_config.h' file !
     101#endif
     102
     103#if !defined(X_WIDTH)
     104# error The X_WIDTH value must be defined in the 'hard_config.h' file !
     105#endif
     106
     107#if !defined(Y_WIDTH)
     108# error The Y_WIDTH value must be defined in the 'hard_config.h' file !
    91109#endif
    92110
    93111#if !defined(NB_PROCS_MAX)
    94 # error The NB_PROCS_MAX value must be defined in the 'giet_config.h' file !
     112# error The NB_PROCS_MAX value must be defined in the 'hard_config.h' file !
    95113#endif
    96114
    … …  
    116134unsigned int _ptabs_vaddr[GIET_NB_VSPACE_MAX];
    117135
    118 // Scheduler pointers array (virtual addresses)
    119 __attribute__((section (".bootdata")))
    120 static_scheduler_t* _schedulers[NB_CLUSTERS * NB_PROCS_MAX];
    121 
    122136// Next free PT2 index array
    123137__attribute__((section (".bootdata")))
    … …  
    129143unsigned int _max_pt2[GIET_NB_VSPACE_MAX] =
    130144{ [0 ... GIET_NB_VSPACE_MAX - 1] = 0 };
     145
     146// Scheduler pointers array (virtual addresses)
     147// indexed by (x,y,lpid) : ((x << Y_WIDTH) + y)*NB_PROCS_MAX + lpid
     148__attribute__((section (".bootdata")))
     149static_scheduler_t* _schedulers[NB_PROCS_MAX<<(X_WIDTH+Y_WIDTH)];
    131150
    132151
    … …  
    147166        _exit();
    148167    }
     168
    149169    // checking number of clusters
    150     if (header->clusters != NB_CLUSTERS)
    151     {
    152         _puts("\n[BOOT ERROR] Incoherent NB_CLUSTERS");
    153         _puts("\n             - In giet_config,  value = ");
    154         _putd(NB_CLUSTERS);
    155         _puts("\n             - In mapping_info, value = ");
    156         _putd(header->clusters);
     170    if ( (header->x_size  != X_SIZE)  ||
     171         (header->y_size  != Y_SIZE)  ||
     172         (header->x_width != X_WIDTH) ||
     173         (header->y_width != Y_WIDTH) )
     174    {
     175        _puts("\n[BOOT ERROR] Incoherent X_SIZE or Y_SIZE ");
     176        _puts("\n             - In hard_config:  X_SIZE = ");
     177        _putd( X_SIZE );
     178        _puts(" / Y_SIZE = ");
     179        _putd( Y_SIZE );
     180        _puts(" / X_WIDTH = ");
     181        _putd( X_WIDTH );
     182        _puts(" / Y_WIDTH = ");
     183        _putd( Y_WIDTH );
     184        _puts("\n             - In mapping_info: x_size = ");
     185        _putd( header->x_size );
     186        _puts(" / y_size = ");
     187        _putd( header->y_size );
     188        _puts(" / x_width = ");
     189        _putd( header->x_width );
     190        _puts(" / y_width = ");
     191        _putd( header->y_width );
    157192        _puts("\n");
    158193        _exit();
    … …  
    167202
    168203#if BOOT_DEBUG_MAPPING
    169 _puts("\n - clusters  = ");
    170 _putd( header->clusters );
     204_puts("\n - x_size    = ");
     205_putd( header->x_size );
     206_puts("\n - y_size    = ");
     207_putd( header->y_size );
    171208_puts("\n - procs     = ");
    172209_putd( header->procs );
    … …  
    196233_puts("\n");
    197234
    198 unsigned int        cluster_id;
     235unsigned int cluster_id;
    199236mapping_cluster_t * cluster = _get_cluster_base(header);
    200 for (cluster_id = 0; cluster_id < NB_CLUSTERS; cluster_id++)
     237for( cluster_id = 0; cluster_id < X_SIZE*Y_SIZE ; cluster_id++)
    201238{
    202 _puts("\n cluster = ");
    203 _putd( cluster_id );
    204 _puts("\n procs   = ");
    205 _putd( cluster[cluster_id].procs );
    206 _puts("\n psegs   = ");
    207 _putd( cluster[cluster_id].psegs );
    208 _puts("\n periphs = ");
    209 _putd( cluster[cluster_id].periphs );
    210 _puts("\n");
     239    _puts("\n - cluster[");
     240    _putd( cluster[cluster_id].x );
     241    _puts(",");
     242    _putd( cluster[cluster_id].y );
     243    _puts("]\n   procs   = ");
     244    _putd( cluster[cluster_id].procs );
     245    _puts("\n   psegs   = ");
     246    _putd( cluster[cluster_id].psegs );
     247    _puts("\n   periphs = ");
     248    _putd( cluster[cluster_id].periphs );
     249    _puts("\n");
    211250}
    212251#endif
    … …  
    10691108    {
    10701109        if ( (vobj[vseg[vseg_id].vobj_offset].type == VOBJ_TYPE_SCHED) &&
    1071              (pseg[vseg[vseg_id].psegid].cluster == cluster_id ) )
     1110             (pseg[vseg[vseg_id].psegid].clusterid == cluster_id ) )
    10721111        {
    10731112            *vbase  = vseg[vseg_id].vbase;
    … …  
    10781117    if ( found == 0 )
    10791118    {
    1080         _puts("\n[BOOT ERROR] No vobj of type SCHED in cluster ");
    1081         _putd(cluster_id);
    1082         _puts("\n");
     1119        mapping_cluster_t* cluster = _get_cluster_base(header);
     1120        _puts("\n[BOOT ERROR] No vobj of type SCHED in cluster [");
     1121        _putd( cluster[cluster_id].x );
     1122        _puts(",");
     1123        _putd( cluster[cluster_id].y );
     1124        _puts("]\n");
    10831125        _exit();
    10841126    }
    … …  
    11191161    unsigned int alloc_cma_channel = 0;            // CMA channel allocator
    11201162    unsigned int alloc_hba_channel = 0;            // IOC channel allocator
    1121     unsigned int alloc_tim_channel[NB_CLUSTERS];  // user TIMER allocators
     1163    unsigned int alloc_tim_channel[X_SIZE*Y_SIZE]; // user TIMER allocators
    11221164
    11231165    /////////////////////////////////////////////////////////////////////////
    … …  
    11291171    // and lpid to access the schedulers array.
    11301172    // - the _schedulers[] array of pointers can contain "holes", because
    1131     //   it is indexed by the global pid = cluster_id*NB_PROCS_MAX + lpid
     1173    //   it is indexed by the global pid = cluster_xy*NB_PROCS_MAX + lpid
    11321174    // - the mapping info array of processors is contiguous, it is indexed
    11331175    //   by proc_id, and use an offset specific in each cluster.
    11341176
    1135     for (cluster_id = 0; cluster_id < header->clusters; cluster_id++)
    1136     {
     1177    for (cluster_id = 0 ; cluster_id < X_SIZE*Y_SIZE ; cluster_id++)
     1178    {
     1179        unsigned int x          = cluster[cluster_id].x;
     1180        unsigned int y          = cluster[cluster_id].y;
     1181        unsigned int cluster_xy = (x<<Y_WIDTH) + y;
    11371182
    11381183#if BOOT_DEBUG_SCHED
    1139 _puts("\n[BOOT DEBUG] Initialise schedulers in cluster ");
    1140 _putd(cluster_id);
    1141 _puts("\n");
    1142 #endif
    1143 
     1184_puts("\n[BOOT DEBUG] Initialise schedulers in cluster[");
     1185_putd( x );
     1186_puts(",");
     1187_putd( y );
     1188_puts("]\n");
     1189#endif
    11441190        alloc_tim_channel[cluster_id] = NB_PROCS_MAX;
    11451191
    … …  
    11541200        if ( nprocs > NB_PROCS_MAX )
    11551201        {
    1156             _puts("\n[BOOT ERROR] Too much processors in cluster ");
    1157             _putd(cluster_id);
    1158             _puts("\n");
     1202            _puts("\n[BOOT ERROR] Too much processors in cluster[");
     1203            _putd( x );
     1204            _puts(",");
     1205            _putd( y );
     1206            _puts("]\n");
    11591207            _exit();
    11601208        }
    … …  
    11661214        if ( sched_length < (nprocs<<12) )
    11671215        {
    1168             _puts("\n[BOOT ERROR] Schedulers segment too small in cluster ");
    1169             _putd(cluster_id);
    1170             _puts("\n");
     1216            _puts("\n[BOOT ERROR] Schedulers segment too small in cluster[");
     1217            _putd( x );
     1218            _puts(",");
     1219            _putd( y );
     1220            _puts("]\n");
    11711221            _exit();
    11721222        }
    … …  
    11771227              proc_id++, lpid++ )
    11781228        {
     1229            // current processor scheduler pointer : psched
     1230            static_scheduler_t* psched = (static_scheduler_t*)(sched_vbase+(lpid<<12));
     1231
    11791232            // set the schedulers pointers array
    1180             _schedulers[cluster_id * NB_PROCS_MAX + lpid] =
    1181                (static_scheduler_t*)( sched_vbase + (lpid<<12) );
     1233            _schedulers[cluster_xy * NB_PROCS_MAX + lpid] = psched;
    11821234
    11831235#if BOOT_DEBUG_SCHED
    11841236_puts("\nProc_");
    1185 _putd(lpid);
     1237_putd( x );
    11861238_puts("_");
    1187 _putd(cluster_id);
     1239_putd( y );
     1240_puts("_");
     1241_putd( lpid );
    11881242_puts(" : scheduler virtual base address = ");
    11891243_putx( sched_vbase + (lpid<<12) );
    11901244_puts("\n");
    11911245#endif
    1192             // current processor scheduler pointer : psched
    1193             static_scheduler_t* psched = (static_scheduler_t*)(sched_vbase+(lpid<<12));
    11941246
    11951247            // initialise the "tasks" variable : default value is 0
    … …  
    12691321        {
    12701322
     1323            // compute the cluster coordinates
     1324            unsigned int x          = cluster[task[task_id].clusterid].x;
     1325            unsigned int y          = cluster[task[task_id].clusterid].y;
     1326            unsigned int cluster_xy = (x<<Y_WIDTH) + y;
     1327
    12711328#if BOOT_DEBUG_SCHED
    12721329_puts("\n[BOOT DEBUG] Initialise context for task ");
    … …  
    12741331_puts(" in vspace ");
    12751332_puts( vspace[vspace_id].name );
    1276 _puts("\n");
     1333_puts(" running on cluster[");
     1334_putd( x );
     1335_puts(",");
     1336_putd( y );
     1337_puts("]\n");
    12771338#endif
    12781339            // compute gpid (global processor index) and scheduler base address
    1279             unsigned int gpid = task[task_id].clusterid * NB_PROCS_MAX +
    1280                                 task[task_id].proclocid;
     1340            unsigned int gpid = cluster_xy * NB_PROCS_MAX + task[task_id].proclocid;
    12811341            static_scheduler_t* psched = _schedulers[gpid];
    12821342
    … …  
    18271887    unsigned int channel_id;
    18281888
    1829     for (cluster_id = 0; cluster_id < header->clusters; cluster_id++)
    1830     {
     1889    // loop on all physical clusters
     1890    for (cluster_id = 0; cluster_id < X_SIZE*Y_SIZE; cluster_id++)
     1891    {
     1892        // computes cluster coordinates
     1893        unsigned int x          = cluster[cluster_id].x;
     1894        unsigned int y          = cluster[cluster_id].y;
     1895        unsigned int cluster_xy = (x<<Y_WIDTH) + y;
    18311896
    18321897#if BOOT_DEBUG_PERI
    1833 _puts("\n[BOOT DEBUG] ****** peripherals initialisation in cluster ");
    1834 _putd(cluster_id);
    1835 _puts(" ******\n");
    1836 #endif
    1837 
     1898_puts("\n[BOOT DEBUG] ****** peripherals initialisation in cluster[");
     1899_putd( x );
     1900_puts(",");
     1901_putd( y );
     1902_puts("] ******\n");
     1903#endif
     1904
     1905        // loop on peripherals
    18381906        for (periph_id = cluster[cluster_id].periph_offset;
    18391907             periph_id < cluster[cluster_id].periph_offset +
    … …  
    18431911            unsigned int channels   = periph[periph_id].channels;
    18441912
    1845 #if BOOT_DEBUG_PERI
    1846 _puts("- peripheral type : ");
    1847 _putd(type);
    1848 _puts(" / channels = ");
    1849 _putd(channels);
    1850 _puts("\n");
    1851 #endif
    18521913            switch (type)
    18531914            {
    … …  
    18561917                    _ioc_init();
    18571918#if BOOT_DEBUG_PERI
    1858 _puts("- IOC initialised\n");
     1919_puts("- IOC / channels = ");
     1920_putd(channels);
     1921_puts("\n");
    18591922#endif
    18601923                    break;
    … …  
    18641927                    for (channel_id = 0; channel_id < channels; channel_id++)
    18651928                    {
    1866                         _dma_init( cluster_id, channel_id );
     1929                        _dma_init( cluster_xy, channel_id );
    18671930                    }
    18681931#if BOOT_DEBUG_PERI
    1869 _puts("- DMA initialised\n");
     1932_puts("- DMA / channels = ");
     1933_putd(channels);
     1934_puts("\n");
    18701935#endif
    18711936                    break;
    18721937                }
    1873                 case PERIPH_TYPE_NIC:    // vci_multi_nic component
     1938                case PERIPH_TYPE_FBF:    // vci_block_device component
     1939                {
     1940                    // nothing to do
     1941#if BOOT_DEBUG_PERI
     1942_puts("- FBF / channels = ");
     1943_putd(channels);
     1944_puts("\n");
     1945#endif
     1946                    break;
     1947                }
     1948                case PERIPH_TYPE_HBA:    // vci_multi_ahci component
    18741949                {
    18751950                    for (channel_id = 0; channel_id < channels; channel_id++)
    … …  
    18781953                    }
    18791954#if BOOT_DEBUG_PERI
    1880 _puts("- NIC initialised\n");
     1955_puts("- HBA / channels = ");
     1956_putd(channels);
     1957_puts("\n");
    18811958#endif
    18821959                    break;
    18831960                }
     1961                case PERIPH_TYPE_CMA:    // vci_chbuf_dma component
     1962                {
     1963                    for (channel_id = 0; channel_id < channels; channel_id++)
     1964                    {
     1965                        // TODO
     1966                    }
     1967#if BOOT_DEBUG_PERI
     1968_puts("- CMA / channels = ");
     1969_putd(channels);
     1970_puts("\n");
     1971#endif
     1972                    break;
     1973                }
     1974                case PERIPH_TYPE_NIC:    // vci_multi_nic component
     1975                {
     1976                    for (channel_id = 0; channel_id < channels; channel_id++)
     1977                    {
     1978                        // TODO
     1979                    }
     1980#if BOOT_DEBUG_PERI
     1981_puts("- NIC / channels = ");
     1982_putd(channels);
     1983_puts("\n");
     1984#endif
     1985                    break;
     1986                }
     1987                case PERIPH_TYPE_XCU:    // vci_xicu component
     1988                {
     1989                    // nothing to do
     1990#if BOOT_DEBUG_PERI
     1991_puts("- XCU / channels = ");
     1992_putd(channels);
     1993_puts("\n");
     1994#endif
     1995                    break;
     1996                }
     1997                case PERIPH_TYPE_MMC:    // vci_memcache config
     1998                {
     1999                    // nothing to do
     2000#if BOOT_DEBUG_PERI
     2001_puts("- MMC / channels = ");
     2002_putd(channels);
     2003_puts("\n");
     2004#endif
     2005                    break;
     2006                }
    18842007                case PERIPH_TYPE_TTY:    // vci_multi_tty component
    18852008                {
    18862009#if BOOT_DEBUG_PERI
    1887 _puts("- TTY initialised\n");
     2010_puts("- TTY / channels = ");
     2011_putd(channels);
     2012_puts("\n");
    18882013#endif
    18892014                    break;
    … …  
    19022027                    }
    19032028#if BOOT_DEBUG_PERI
    1904 _puts("- IOB initialised\n");
     2029_puts("- IOB / channels = ");
     2030_putd(channels);
     2031_puts("\n");
    19052032#endif
    19062033                    break;
    … …  
    19102037
    19112038#if BOOT_DEBUG_PERI
    1912 _puts("\n[BOOT DEBUG] ****** coprocessors initialisation in cluster ");
    1913 _putd(cluster_id);
    1914 _puts(" ******\n");
    1915 #endif
    1916 
     2039_puts("\n[BOOT DEBUG] ****** coprocessors initialisation in cluster[");
     2040_putd( x );
     2041_puts(",");
     2042_putd( y );
     2043_puts("] ******\n");
     2044#endif
     2045
     2046        // loop on coprocessors
    19172047        for ( coproc_id = cluster[cluster_id].coproc_offset;
    19182048              coproc_id < cluster[cluster_id].coproc_offset +
    … …  
    19392069                paddr_t mwmr_channel_pbase = vobj[vobj_id].paddr;
    19402070
    1941                 _mwmr_hw_init( cluster_id,
    1942                                cp_port_id,
    1943                                cp_port[cp_port_id].direction,
    1944                                mwmr_channel_pbase );
     2071                _mwr_hw_init( cluster_xy,
     2072                              cp_port_id,
     2073                              cp_port[cp_port_id].direction,
     2074                              mwmr_channel_pbase );
    19452075#if BOOT_DEBUG_PERI
    19462076_puts("     port direction: ");
    … …  
    19592089} // end boot_peripherals_init()
    19602090
    1961 
    1962 //////////////////////////////////////////////////////////////////////////////
    1963 // This function is executed by all processors to jump into kernel:
    1964 // - Each processor initialises its CP0_SCHED register from the value
    1965 //   contained in the _schedulers[] array (previously initialised
    1966 //   by proc0 in the _schedulers_init() function).
    1967 // - Each processor (but proc 0) initialise the CP2_PTPR register with
    1968 //   the default value (i.e. PTPR corresponding to vspace_0 page table),
    1969 //   and write into CP2 MODE register to activate their MMU.
    1970 // - All processors jump to the kernel entry point (seg_kernel_init_base).
    1971 //////////////////////////////////////////////////////////////////////////////
    1972 void boot_to_kernel()
    1973 {
    1974     // CP0 SCHED register initialisation
    1975     unsigned int procid = _get_procid();
    1976     _set_sched( (unsigned int)_schedulers[procid] );
    1977 
    1978     // MMU Activation
    1979     if ( procid != 0 )
    1980     {
    1981         _set_mmu_ptpr( (unsigned int)(_ptabs_paddr[0]>>13) );
    1982         _set_mmu_mode( 0xF );
    1983 
    1984         _tty_get_lock( 0 );
    1985         _puts("\n[BOOT] Proc ");
    1986         _putd( procid );
    1987         _puts(" MMU activation at cycle ");
    1988         _putd(_get_proctime());
    1989         _puts("\n");
    1990         _tty_release_lock( 0 );
    1991 
    1992     }
    1993 
    1994     // jump to kernel_init
    1995     unsigned int kernel_entry = (unsigned int)&seg_kernel_init_base;
    1996 
    1997     _tty_get_lock( 0 );
    1998     _puts("\n[BOOT] Processor ");
    1999     _putd( procid );
    2000     _puts(" jumps to kernel (");
    2001     _putx( kernel_entry );
    2002     _puts(") at cycle ");
    2003     _putd( _get_proctime() );
    2004     _puts("\n");
    2005     _tty_release_lock( 0 );
    2006 
    2007     asm volatile( "jr   %0" ::"r"(kernel_entry) );
    2008 }
    2009 
    20102091/////////////////////////////////////////////////////////////////////////
    20112092// This function is the entry point of the boot code for all processors.
    … …  
    20142095void boot_init()
    20152096{
    2016     mapping_header_t* header = (mapping_header_t *) & seg_boot_mapping_base;
    2017     unsigned int      procid = _get_procid();
     2097    mapping_header_t* header     = (mapping_header_t *) & seg_boot_mapping_base;
     2098    unsigned int      gpid       = _get_procid();
     2099    unsigned int      cluster_xy = gpid / NB_PROCS_MAX;
     2100    unsigned int      lpid       = gpid % NB_PROCS_MAX;
    20182101 
    2019     if ( procid == 0 )    // only Processor 0 does it
     2102    if ( gpid == 0 )    // only Processor 0 does it
    20202103    {
    20212104        _puts("\n[BOOT] boot_init start at cycle ");
    … …  
    20432126        _set_mmu_mode( 0xF );
    20442127
    2045         _puts("\n[BOOT] Processor 0 MMU activation at cycle ");
     2128        _puts("\n[BOOT] Processor[0,0,0] : MMU activation at cycle ");
    20462129        _putd(_get_proctime());
    20472130        _puts("\n");
    … …  
    20642147        _set_sched( (unsigned int)_schedulers[0] );
    20652148
    2066         _puts("\n[BOOT] Proc 0 CPO_SCHED register initialised at cycle ");
    2067         _putd(_get_proctime());
    2068         _puts("\n");
    2069 
    2070         // Initializing external peripherals
     2149        // Initializing peripherals
    20712150        boot_peripherals_init();
    20722151
    2073         _puts("\n[BOOT] External peripherals initialised at cycle ");
     2152        _puts("\n[BOOT] All peripherals initialised at cycle ");
    20742153        _putd(_get_proctime());
    20752154        _puts("\n");
    … …  
    20832162
    20842163        // P0 starts all other processors
    2085         unsigned int cluster_id;
    2086         unsigned int local_id;
    2087         for (cluster_id = 0; cluster_id < NB_CLUSTERS; cluster_id++)
    2088         {
    2089             for(local_id = 0; local_id < NB_PROCS_MAX; local_id++)
     2164        unsigned int x,y,p;
     2165        for (x = 0 ; x < X_SIZE ; x++)
     2166        {
     2167            for (y = 0 ; y < Y_SIZE ; y++)
    20902168            {
    2091                 if ((cluster_id != 0) || (local_id != 0))
    2092                 {
    2093                     _xcu_send_ipi( cluster_id,
    2094                                    local_id,
    2095                                    (unsigned int)boot_init );
     2169                for(p = 0; p < NB_PROCS_MAX; p++)
     2170                {
     2171                    if ( (x != 0) || (y != 0) || (p != 0) )
     2172                    {
     2173                        _xcu_send_ipi( (x<<Y_WIDTH) + y,
     2174                                       p,
     2175                                       (unsigned int)boot_init );
     2176                    }
    20962177                }
    20972178            }
    … …  
    21042185
    21052186    // all processor initialise SCHED register
    2106     _set_sched( (unsigned int)_schedulers[procid] );
     2187    _set_sched( (unsigned int)_schedulers[gpid] );
    21072188
    21082189    // all processors (but Proc 0) activate MMU
    2109     if ( procid != 0 )
     2190    if ( gpid != 0 )
    21102191    {
    21112192        _set_mmu_ptpr( (unsigned int)(_ptabs_paddr[0]>>13) );
    … …  
    21132194
    21142195        _tty_get_lock( 0 );
    2115         _puts("\n[BOOT] Processor ");
    2116         _putd( procid );
    2117         _puts(" MMU activation at cycle ");
     2196        _puts("\n[BOOT] Processor[");
     2197        _putd( cluster_xy >> Y_WIDTH );
     2198        _puts(",");
     2199        _putd( cluster_xy & ((1<<Y_WIDTH)-1) );
     2200        _puts(",");
     2201        _putd( lpid );
     2202        _puts("] : MMU activation at cycle ");
    21182203        _putd(_get_proctime());
    21192204        _puts("\n");
    21202205        _tty_release_lock( 0 );
    2121 
    21222206    }
    21232207
    … …  
    21262210
    21272211    _tty_get_lock( 0 );
    2128     _puts("\n[BOOT] Processor ");
    2129     _putd( procid );
    2130     _puts(" enters kernel at cycle ");
     2212    _puts("\n[BOOT] Processor[");
     2213    _putd( cluster_xy >> Y_WIDTH );
     2214    _puts(",");
     2215    _putd( cluster_xy & ((1<<Y_WIDTH)-1) );
     2216    _puts(",");
     2217    _putd( lpid );
     2218    _puts("] enters kernel at cycle ");
    21312219    _putd( _get_proctime() );
    21322220    _puts(" / kernel entry = ");
Note: See TracChangeset for help on using the changeset viewer.