Ignore:
Timestamp:
Aug 12, 2013, 11:43:13 AM (11 years ago)
Author:
devigne
Message:

generic_tlb : pte flag CC => NCC
vci_cc_vcache_wrapper : Fixing deadlock
(go to CC_CHECK only when CC_SEND is available)
vci_mem_cache : merge modification on llsc.sw(args)

File:
1 edited

Legend:

Unmodified
Added
Removed

  • branches/ODCCP/lib/generic_tlb_odccp/include/generic_tlb.h

    r452 r492  
    4444 * - bool       R           remotely accessed
    4545 * - bool       C           cachable   
    46  * - bool       CC          Coherente   
     46 * - bool       NCC         Non Coherente   
    4747 * - bool       W           writable
    4848 * - bool       X           executable
    … …  
    9494        bool r;    // remotely accessed
    9595        bool c;    // cacheable   
    96         bool cc;   // Coherent (for ODCCP)
     96        bool ncc;  // Non Coherent (for ODCCP)
    9797        bool w;    // writable   
    9898        bool x;    // executable 
    … …  
    128128        PTE_G_MASK = 0x00800000,        // global bit in PTE
    129129        PTE_D_MASK = 0x00400000,    // dirty bit in PTE
    130         PTE_CC_MASK = 0x00200000,   // Coherent bit in PTE (for ODCCP)
     130        PTE_NCC_MASK = 0x00200000,   // Non Coherent bit in PTE (for ODCCP)
    131131    };
    132132
    … …  
    143143        PTE_G_SHIFT = 23,
    144144        PTE_D_SHIFT = 22,
    145         PTE_CC_SHIFT = 21,
     145        PTE_NCC_SHIFT = 21,
    146146    };
    147147
    … …  
    178178    bool                    *m_big;
    179179    bool                    *m_recent;
    180     bool                    *m_coherent; // for ODCCP
     180    bool                    *m_non_coherent; // for ODCCP
    181181
    182182    // bypass registers
    … …  
    254254    }
    255255    //////////////////////////////////////
    256     bool get_coherent(size_t way, size_t set)
    257     {
    258         return m_coherent[(way*m_nsets)+set];
     256    bool get_non_coherent(size_t way, size_t set)
     257    {
     258        return m_non_coherent[(way*m_nsets)+set];
    259259    }
    260260    //////////////////////////////////////
    … …  
    307307        m_big               = new bool[nways * nsets];
    308308        m_recent            = new bool[nways * nsets];
    309         m_coherent          = new bool[nways * nsets];
     309        m_non_coherent  = new bool[nways * nsets];
    310310
    311311    } // end constructor
    … …  
    328328        delete [] m_big;
    329329        delete [] m_recent;
    330         delete [] m_coherent;
     330        delete [] m_non_coherent;
    331331    }
    332332
    … …  
    367367               (get_vpn(way,m_set) == (vaddress >> (PAGE_M_NBITS + m_sets_shift))) )
    368368            {
    369                 pte_info->v  = get_valid(way,m_set);
    370                 pte_info->l  = get_local(way,m_set);
    371                 pte_info->r  = get_remote(way,m_set);
    372                 pte_info->c  = get_cacheable(way,m_set);
    373                 pte_info->w  = get_writable(way,m_set);
    374                 pte_info->x  = get_executable(way,m_set);
    375                 pte_info->u  = get_unprotected(way,m_set);
    376                 pte_info->g  = get_global(way,m_set);
    377                 pte_info->d  = get_dirty(way,m_set);
    378                 pte_info->b  = get_big(way,m_set);
    379                 pte_info->z  = get_recent(way,m_set);
    380                 pte_info->cc = get_coherent(way,m_set); // coherent/not coherent bit for ODCCP
     369                pte_info->v   = get_valid(way,m_set);
     370                pte_info->l   = get_local(way,m_set);
     371                pte_info->r   = get_remote(way,m_set);
     372                pte_info->c   = get_cacheable(way,m_set);
     373                pte_info->w   = get_writable(way,m_set);
     374                pte_info->x   = get_executable(way,m_set);
     375                pte_info->u   = get_unprotected(way,m_set);
     376                pte_info->g   = get_global(way,m_set);
     377                pte_info->d   = get_dirty(way,m_set);
     378                pte_info->b   = get_big(way,m_set);
     379                pte_info->z   = get_recent(way,m_set);
     380                pte_info->ncc = get_non_coherent(way,m_set); // coherent/not coherent bit for ODCCP
    381381
    382382                *nline      = get_nline(way,m_set);
    … …  
    395395               (get_vpn(way,k_set) == (vaddress >> (PAGE_K_NBITS + m_sets_shift))) )
    396396            { 
    397                 pte_info->v  = get_valid(way,k_set);
    398                 pte_info->l  = get_local(way,k_set);
    399                 pte_info->r  = get_remote(way,k_set);
    400                 pte_info->c  = get_cacheable(way,k_set);
    401                 pte_info->w  = get_writable(way,k_set);
    402                 pte_info->x  = get_executable(way,k_set);
    403                 pte_info->u  = get_unprotected(way,k_set);
    404                 pte_info->g  = get_global(way,k_set);
    405                 pte_info->d  = get_dirty(way,k_set);
    406                 pte_info->b  = get_big(way,k_set);
    407                 pte_info->z  = get_recent(way,k_set);
    408                 pte_info->cc = get_coherent(way,k_set);// coherent/not coherent bit for ODCCP
     397                pte_info->v   = get_valid(way,k_set);
     398                pte_info->l   = get_local(way,k_set);
     399                pte_info->r   = get_remote(way,k_set);
     400                pte_info->c   = get_cacheable(way,k_set);
     401                pte_info->w   = get_writable(way,k_set);
     402                pte_info->x   = get_executable(way,k_set);
     403                pte_info->u   = get_unprotected(way,k_set);
     404                pte_info->g   = get_global(way,k_set);
     405                pte_info->d   = get_dirty(way,k_set);
     406                pte_info->b   = get_big(way,k_set);
     407                pte_info->z   = get_recent(way,k_set);
     408                pte_info->ncc = get_non_coherent(way,k_set);// coherent/not coherent bit for ODCCP
    409409
    410410                *nline      = get_nline(way,k_set);
    … …  
    489489                   paddr_t*     nline)
    490490    {
    491         flags->v  = m_valid[way*m_nsets+set];
    492         flags->l  = m_local[way*m_nsets+set];
    493         flags->r  = m_remote[way*m_nsets+set];
    494         flags->c  = m_cacheable[way*m_nsets+set];
    495         flags->w  = m_writable[way*m_nsets+set];
    496         flags->x  = m_executable[way*m_nsets+set];
    497         flags->u  = m_unprotected[way*m_nsets+set];
    498         flags->g  = m_global[way*m_nsets+set];
    499         flags->d  = m_dirty[way*m_nsets+set];
    500         flags->b  = m_big[way*m_nsets+set];
    501         flags->z  = m_recent[way*m_nsets+set];
    502         flags->cc = m_coherent[way*m_nsets+set]; // flag coherent/not coherent for ODCCP
     491        flags->v   = m_valid[way*m_nsets+set];
     492        flags->l   = m_local[way*m_nsets+set];
     493        flags->r   = m_remote[way*m_nsets+set];
     494        flags->c   = m_cacheable[way*m_nsets+set];
     495        flags->w   = m_writable[way*m_nsets+set];
     496        flags->x   = m_executable[way*m_nsets+set];
     497        flags->u   = m_unprotected[way*m_nsets+set];
     498        flags->g   = m_global[way*m_nsets+set];
     499        flags->d   = m_dirty[way*m_nsets+set];
     500        flags->b   = m_big[way*m_nsets+set];
     501        flags->z   = m_recent[way*m_nsets+set];
     502        flags->ncc = m_non_coherent[way*m_nsets+set]; // flag coherent/not coherent for ODCCP
    503503
    504504        *ppn     = m_ppn[way*m_nsets+set];
    … …  
    592592            m_big[way*m_nsets+set]     = false;
    593593        }
    594         m_nline[way*m_nsets+set]       = nline;
    595         m_valid[way*m_nsets+set]       = true;
    596         m_recent[way*m_nsets+set]      = true;
    597         m_local[way*m_nsets+set]       = (((pte_flags & PTE_L_MASK) >> PTE_L_SHIFT) == 1) ? true : false;
    598         m_remote[way*m_nsets+set]      = (((pte_flags & PTE_R_MASK) >> PTE_R_SHIFT) == 1) ? true : false;
    599         m_cacheable[way*m_nsets+set]   = (((pte_flags & PTE_C_MASK) >> PTE_C_SHIFT) == 1) ? true : false;
    600         m_writable[way*m_nsets+set]    = (((pte_flags & PTE_W_MASK) >> PTE_W_SHIFT) == 1) ? true : false;
    601         m_executable[way*m_nsets+set]  = (((pte_flags & PTE_X_MASK) >> PTE_X_SHIFT) == 1) ? true : false;
    602         m_unprotected[way*m_nsets+set] = (((pte_flags & PTE_U_MASK) >> PTE_U_SHIFT) == 1) ? true : false;
    603         m_global[way*m_nsets+set]      = (((pte_flags & PTE_G_MASK) >> PTE_G_SHIFT) == 1) ? true : false;
    604         m_dirty[way*m_nsets+set]       = (((pte_flags & PTE_D_MASK) >> PTE_D_SHIFT) == 1) ? true : false;
    605         m_coherent[way*m_nsets+set]    = (((pte_flags & PTE_CC_MASK) >> PTE_CC_SHIFT) == 1) ? true : false; // for ODCCP
     594        m_nline[way*m_nsets+set]           = nline;
     595        m_valid[way*m_nsets+set]           = true;
     596        m_recent[way*m_nsets+set]          = true;
     597        m_local[way*m_nsets+set]           = (((pte_flags & PTE_L_MASK) >> PTE_L_SHIFT) == 1) ? true : false;
     598        m_remote[way*m_nsets+set]          = (((pte_flags & PTE_R_MASK) >> PTE_R_SHIFT) == 1) ? true : false;
     599        m_cacheable[way*m_nsets+set]       = (((pte_flags & PTE_C_MASK) >> PTE_C_SHIFT) == 1) ? true : false;
     600        m_writable[way*m_nsets+set]        = (((pte_flags & PTE_W_MASK) >> PTE_W_SHIFT) == 1) ? true : false;
     601        m_executable[way*m_nsets+set]      = (((pte_flags & PTE_X_MASK) >> PTE_X_SHIFT) == 1) ? true : false;
     602        m_unprotected[way*m_nsets+set]     = (((pte_flags & PTE_U_MASK) >> PTE_U_SHIFT) == 1) ? true : false;
     603        m_global[way*m_nsets+set]          = (((pte_flags & PTE_G_MASK) >> PTE_G_SHIFT) == 1) ? true : false;
     604        m_dirty[way*m_nsets+set]           = (((pte_flags & PTE_D_MASK) >> PTE_D_SHIFT) == 1) ? true : false;
     605        m_non_coherent[way*m_nsets+set]    = (((pte_flags & PTE_NCC_MASK) >> PTE_NCC_SHIFT) == 1) ? true : false; // for ODCCP
    606606    }  // end write()
    607607
    … …  
    754754    void printTrace()
    755755    {
    756         std::cout << "     set way    V  L  R  C  W  X  U  G  D  B  Z  CC"
     756        std::cout << "     set way    V  L  R  C  W  X  U  G  D  B  Z  NCC"
    757757                  << "   TAG        PPN          NLINE" << std::endl;
    758758
    … …  
    776776                          << m_big[m_nsets*way+set] << "]["
    777777                          << m_recent[m_nsets*way+set] << "]["
    778                           << m_coherent[m_nsets*way+set] << "]["
     778                          << m_non_coherent[m_nsets*way+set] << "]["
    779779                          << std::hex << std::showbase
    780780                          << std::setw(7)  << m_vpn[m_nsets*way+set] << "]["
Note: See TracChangeset for help on using the changeset viewer.