クラス Onikiri::MemOrderOperations

#include <MemOrderOperations.h>

すべてのメンバ一覧

Public メソッド

u64 CorrectEndian (u64 src, int size)
bool IsInnerAccess (u64 inner, int innerSize, u64 outer, int outerSize) const
bool IsInnerAccess (const MemAccess &inner, const MemAccess &outer) const
bool IsOverlapped (u64 addr1, int size1, u64 addr2, int size2) const
bool IsOverlapped (const MemAccess &access1, const MemAccess &access2) const
bool IsOverlappedInAligned (u64 addr1, int size1, u64 addr2, int size2) const
bool IsOverlappedInAligned (const MemAccess &access1, const MemAccess &access2) const
 MemOrderOperations ()
u64 MergePartialAccess (const MemAccess &base, const MemAccess &store)
u64 ReadPreviousAccess (const MemAccess &load, const MemAccess &store)
void SetAlignment (int alignment)
void SetTargetEndian (bool targetIsLittleEndian)

Protected 変数

int m_memoryAlignment
u64 m_memoryAlignmentMask
bool m_targetIsLittleEndian


説明

MemOrderOperations.h40 行で定義されています。


コンストラクタとデストラクタ

MemOrderOperations::MemOrderOperations (  ) 

MemOrderOperations.cpp42 行で定義されています。

00042                                        :
00043     m_targetIsLittleEndian(false),
00044     m_memoryAlignment(1),
00045     m_memoryAlignmentMask(~((u64)0))
00046 {
00047 }


関数

u64 MemOrderOperations::CorrectEndian ( u64  src,
int  size 
)

MemOrderOperations.cpp141 行で定義されています。

参照先 Onikiri::ConvertEndian()m_targetIsLittleEndianTHROW_RUNTIME_ERROR.

参照元 MergePartialAccess()ReadPreviousAccess().

00142 {
00143     if( m_targetIsLittleEndian )
00144         return src; // Do not need conversion.
00145 
00146     switch( size ){
00147     case 1:
00148         return (u64)ConvertEndian((u8)src);
00149     case 2:
00150         return (u64)ConvertEndian((u16)src);
00151     case 4:
00152         return (u64)ConvertEndian((u32)src);
00153     case 8:
00154         return (u64)ConvertEndian((u64)src);
00155     default:
00156         THROW_RUNTIME_ERROR( "Invalid size." );
00157         return 0;
00158     }
00159 
00160 }

関数の呼び出しグラフ:

Here is the caller graph for this function:

bool MemOrderOperations::IsInnerAccess ( u64  inner,
int  innerSize,
u64  outer,
int  outerSize 
) const

MemOrderOperations.cpp191 行で定義されています。

00192 {
00193     //             inner   inner+size
00194     // inner:        <------->
00195     // outer:     <------------->
00196     //          outer       outer+size
00197     return (outer <= inner) && ((inner + innerSize) <= (outer + outerSize));
00198 }

bool MemOrderOperations::IsInnerAccess ( const MemAccess inner,
const MemAccess outer 
) const

MemOrderOperations.cpp186 行で定義されています。

参照先 Onikiri::Addr::addressOnikiri::MemAccess::addressOnikiri::MemAccess::size.

参照元 Onikiri::ForwardEmulator::Read()Onikiri::MemOrderManager::Read().

00187 {
00188     return IsInnerAccess(inner.address.address, inner.size, outer.address.address, outer.size);
00189 }

Here is the caller graph for this function:

bool MemOrderOperations::IsOverlapped ( u64  addr1,
int  size1,
u64  addr2,
int  size2 
) const

MemOrderOperations.cpp168 行で定義されています。

00169 {
00170     return
00171         (addr1 <= addr2 && addr2 < addr1+size1) ||
00172         (addr2 <= addr1 && addr1 < addr2+size2);
00173 }

bool MemOrderOperations::IsOverlapped ( const MemAccess access1,
const MemAccess access2 
) const

MemOrderOperations.cpp163 行で定義されています。

参照先 Onikiri::Addr::addressOnikiri::MemAccess::addressOnikiri::MemAccess::size.

参照元 Onikiri::MemOrderManager::GetConsumerLoad()Onikiri::ForwardEmulator::GetProducerStore()Onikiri::MemOrderManager::GetProducerStore()Onikiri::ForwardEmulator::Read()Onikiri::MemOrderManager::Read()Onikiri::PerfectMemDepPred::Resolve().

00164 {
00165     return IsOverlapped(access1.address.address, access1.size, access2.address.address, access2.size);
00166 }

Here is the caller graph for this function:

bool MemOrderOperations::IsOverlappedInAligned ( u64  addr1,
int  size1,
u64  addr2,
int  size2 
) const

MemOrderOperations.cpp180 行で定義されています。

参照先 m_memoryAlignmentMask.

00181 {
00182     return (addr1 & m_memoryAlignmentMask) == (addr2 & m_memoryAlignmentMask);
00183 }

bool MemOrderOperations::IsOverlappedInAligned ( const MemAccess access1,
const MemAccess access2 
) const

MemOrderOperations.cpp175 行で定義されています。

参照先 Onikiri::Addr::addressOnikiri::MemAccess::addressOnikiri::MemAccess::size.

参照元 Onikiri::PerfectMemDepPred::Resolve().

00176 {
00177     return IsOverlappedInAligned(access1.address.address, access1.size, access2.address.address, access2.size);
00178 }

Here is the caller graph for this function:

u64 MemOrderOperations::MergePartialAccess ( const MemAccess base,
const MemAccess store 
)

MemOrderOperations.cpp98 行で定義されています。

参照先 Onikiri::Addr::addressOnikiri::MemAccess::addressCorrectEndian()Onikiri::MemAccess::signOnikiri::MemAccess::sizeOnikiri::MemAccess::value.

参照元 Onikiri::ForwardEmulator::Read()Onikiri::MemOrderManager::Read().

00099 {
00100     u64 baseAddr   = base.address.address;
00101     u64 storeAddr  = store.address.address;
00102     u64 storeValue = CorrectEndian( store.value, store.sign );
00103     s64 storeSize  = store.size;
00104 
00105     u64 merged = base.value;
00106 
00107     if( baseAddr < storeAddr ){
00108         // base   <----->
00109         // store      <------>
00110         // start      ^
00111         s64 start = storeAddr - baseAddr;
00112         for( int i = 0; i < storeSize; ++i ){
00113             s64 baseOffset  = i + start;
00114             if( baseOffset >= base.size )
00115                 break;
00116             merged = 
00117                 shttl::deposit( merged, baseOffset*8, 8, (storeValue >> (i*8)) & 0xff );
00118         }
00119     }
00120     else{
00121         // base       <----->
00122         // store  <------>
00123         // start      ^
00124         s64 start = baseAddr - storeAddr;
00125         for( int i = 0; i < storeSize; ++i ){
00126             s64 baseOffset  = i - start;
00127             if( baseOffset < 0 )
00128                 continue;
00129             if( baseOffset >= base.size )
00130                 break;
00131             merged = 
00132                 shttl::deposit( merged, baseOffset*8, 8, (storeValue >> (i*8)) & 0xff );
00133         }
00134 
00135     }
00136 
00137     return merged;
00138 }

関数の呼び出しグラフ:

Here is the caller graph for this function:

u64 MemOrderOperations::ReadPreviousAccess ( const MemAccess load,
const MemAccess store 
)

MemOrderOperations.cpp67 行で定義されています。

参照先 Onikiri::Addr::addressOnikiri::MemAccess::addressCorrectEndian()Onikiri::MemAccess::sizeOnikiri::MemAccess::value.

参照元 Onikiri::ForwardEmulator::Read()Onikiri::MemOrderManager::Read().

00069 {
00070     //
00071     // ** load access area is sure to be inner of store area.
00072     //
00073     //      store addr               
00074     //           |
00075     // store:    |<----------store-size----------->|
00076     // load :    |<--sh-->|<--load-size-->|
00077     //                    |
00078     //                load-addr       
00079     //
00080     // If a target architecture is big endian, 
00081     // a store value is converted to memory image of the store value (little endian), and 
00082     // load a part of the converted store value and convert it again.
00083     //
00084     //
00085 
00086     u64 storeRegValue = store.value;
00087     u64 storeMemValue = CorrectEndian( storeRegValue, store.size );
00088 
00089     u64 sh   = 8 * (load.address.address - store.address.address);
00090     u64 mask = shttl::mask(0, load.size * 8);
00091 
00092     u64 loadMemValue = (storeMemValue >> sh) & mask;
00093     u64 loadRegValue = CorrectEndian( loadMemValue, load.size );
00094 
00095     return loadRegValue;    
00096 }

関数の呼び出しグラフ:

Here is the caller graph for this function:

void MemOrderOperations::SetAlignment ( int  alignment  ) 

MemOrderOperations.cpp49 行で定義されています。

参照先 ASSERTm_memoryAlignmentm_memoryAlignmentMask.

参照元 Onikiri::PerfectMemDepPred::Initialize().

00050 {
00051     ASSERT( alignment > 0 );
00052     m_memoryAlignment = alignment;
00053 
00054     int bits = 0;
00055     for( u64 a = alignment; a != 0; a >>= 1 ){
00056         bits++;
00057     }
00058     bits--;
00059     m_memoryAlignmentMask = shttl::mask( bits, 64-bits );
00060 }

Here is the caller graph for this function:

void Onikiri::MemOrderOperations::SetTargetEndian ( bool  targetIsLittleEndian  )  [inline]

MemOrderOperations.h45 行で定義されています。

参照先 m_targetIsLittleEndian.

参照元 Onikiri::ForwardEmulator::Initialize()Onikiri::PerfectMemDepPred::Initialize()Onikiri::MemOrderManager::Initialize().

00046         {
00047             m_targetIsLittleEndian = targetIsLittleEndian;
00048         }

Here is the caller graph for this function:


変数

int Onikiri::MemOrderOperations::m_memoryAlignment [protected]

MemOrderOperations.h74 行で定義されています。

参照元 SetAlignment().

u64 Onikiri::MemOrderOperations::m_memoryAlignmentMask [protected]

MemOrderOperations.h75 行で定義されています。

参照元 IsOverlappedInAligned()SetAlignment().

bool Onikiri::MemOrderOperations::m_targetIsLittleEndian [protected]

MemOrderOperations.h73 行で定義されています。

参照元 CorrectEndian()SetTargetEndian().


このクラスの説明は次のファイルから生成されました:
Onikiri2に対してTue Jun 18 15:05:10 2013に生成されました。  doxygen 1.4.7