// heaputils.h

// 

// Copyright (c) 2010 Accenture. All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

// 

// Initial Contributors:

// Accenture - Initial contribution

//

// Contributors:

// Adrian Issott (Nokia) - Updates for RHybridHeap v2

//

#ifndef FSHELL_HEAP_OFFSETS_H

#define FSHELL_HEAP_OFFSETS_H

#include <e32def.h>

#if defined(TEST_HYBRIDHEAP_V1_ASSERTS) || defined(TEST_HYBRIDHEAP_V2_ASSERTS)

#define TEST_HYBRIDHEAP_COMMON_ASSERTS

#endif

#ifdef TEST_HYBRIDHEAP_COMMON_ASSERTS

#define private public

#include <e32def.h>

#endif 

#ifdef TEST_HYBRIDHEAP_V2_ASSERTS

#include <e32panic.h>

#include <kernel/heap_hybrid.h>

#include "common.h"

#include "heap_priv_defs.h"

#include "dla.h"

#endif

#ifdef TEST_HYBRIDHEAP_COMMON_ASSERTS

#include "slab.h"

#include "page_alloc.h"

#endif

#ifdef TEST_HYBRIDHEAP_V1_ASSERTS

#include <kernel/heap_hybrid.h>

#endif

/*

 * This header provides offsets for use with three different types of heap algorithms:

 * i) The original RHeap implemenation 

 *    (RHeap v1)

 * ii) The first RHybridHeap implemenation 

 *    (RHeap v2 + RHybridHeap v1)

 * iii) The second / refactored RHybridHeap implementation 

 *      (RHeap v2 + RHybridHeap v2 + RDlAllocator + RPageAllocator + RSlabHeapAllocator)

 */

namespace LtkUtils

	{

//

// OFFSETS COMMON TO ALL THREE HEAP CLASSES

// 

class RHackAllocator : public RAllocator

    {

public:

    using RAllocator::iHandles;

    using RAllocator::iTotalAllocSize;

    using RAllocator::iCellCount;

    };

class RHackHeap : public RHeap

    {

public:

    // Careful, only allowed to use things that are in the same place for versions 1 and 2 of RHeap

    using RHeap::iMaxLength;

    using RHeap::iChunkHandle;

    using RHeap::iLock;

    using RHeap::iBase;

    using RHeap::iAlign;

    using RHeap::iTop;

    };

const TInt KChunkSizeOffset = 30*4;

//

// OFFSETS COMMON TO BOTH RHYBRIDHEAP CLASSES

// 

namespace HeapV1

    {

const TInt KUserInitialHeapMetaDataSize = 34*4;

    } // namespace HeapV1

//

// OFFSETS COMMON TO BOTH RHYBRIDHEAP CLASSES

// 

namespace HybridCom

    {

const TInt KMallocStateTopSizeOffset = 3*4;

const TInt KMallocStateTopOffset = 5*4;

const TInt KMallocStateSegOffset = 105*4;

const TInt KSlabParentOffset = 1*4;

const TInt KSlabChild1Offset = 2*4;

const TInt KSlabChild2Offset = 3*4;

const TInt KSlabPayloadOffset = 4*4;

const TInt KSlabsetSize = 4;

//const TInt KDlOnlyOffset = 33*4;

#define MAXSLABSIZE     56

#define SLABSHIFT       10

#define SLABSIZE        (1 << SLABSHIFT)

const TInt KMaxSlabPayload = SLABSIZE - KSlabPayloadOffset;

#ifdef TEST_HYBRIDHEAP_COMMON_ASSERTS

__ASSERT_COMPILE(_FOFF(RHybridHeap, iChunkSize) == KChunkSizeOffset);

__ASSERT_COMPILE(sizeof(malloc_state) == 107*4);

#endif

    } // namespace HybridCom

//

// OFFSETS SPECIFIC TO THE RHYBRIDHEAP V1 CLASSES

// 

namespace HybridV1

    {

const TInt KUserPageMapOffset = 141*4;

const TInt KMallocStateOffset = 34*4; // same for user and kernel heaps

const TInt KUserSparePageOffset = 167*4;

const TInt KUserPartialPageOffset = 165*4;

const TInt KUserFullSlabOffset = 166*4;

const TInt KUserSlabAllocOffset = 172*4;

const TInt KUserInitialHeapMetaDataSize = 186*4;

__ASSERT_COMPILE(HeapV1::KUserInitialHeapMetaDataSize < KUserInitialHeapMetaDataSize);

#ifdef TEST_HYBRIDHEAP_V1_ASSERTS

const TInt KUserHybridHeapSize = KUserInitialHeapMetaDataSize;

#ifndef __KERNEL_MODE__

__ASSERT_COMPILE(sizeof(RHybridHeap) == KUserHybridHeapSize);

__ASSERT_COMPILE(_FOFF(RHybridHeap, iPageMap) == KUserPageMapOffset);

__ASSERT_COMPILE(_FOFF(RHybridHeap, iSparePage) == KUserSparePageOffset);

__ASSERT_COMPILE(_FOFF(RHybridHeap, iPartialPage) == KUserPartialPageOffset);

__ASSERT_COMPILE(_FOFF(RHybridHeap, iSlabAlloc) == KUserSlabAllocOffset);

__ASSERT_COMPILE(_FOFF(slab, iParent) == HybridCom::KSlabParentOffset);

__ASSERT_COMPILE(_FOFF(slab, iChild1) == HybridCom::KSlabChild1Offset);

__ASSERT_COMPILE(_FOFF(slab, iChild2) == HybridCom::KSlabChild2Offset);

__ASSERT_COMPILE(_FOFF(slab, iPayload) == HybridCom::KSlabPayloadOffset);

__ASSERT_COMPILE(sizeof(slabset) == HybridCom::KSlabsetSize);

#endif

__ASSERT_COMPILE(_FOFF(RHybridHeap, iGlobalMallocState) == KMallocStateOffset);

__ASSERT_COMPILE(_FOFF(malloc_state, iTopSize) == HybridCom::KMallocStateTopSizeOffset);

__ASSERT_COMPILE(_FOFF(malloc_state, iTop) == HybridCom::KMallocStateTopOffset);

__ASSERT_COMPILE(_FOFF(malloc_state, iSeg) == HybridCom::KMallocStateSegOffset);

#endif

    } // namespace HybridV1

//

// OFFSETS SPECIFIC TO THE RHYBRIDHEAP V2 CLASSES

// 

namespace HybridV2

    {

const TInt KUserPageMapOffset = 153*4;

const TInt KUserMallocStateOffset = 45*4;

const TInt KKernelMallocStateOffset = 37*4;

const TInt KUserSparePageOffset = 175*4;

const TInt KUserPartialPageOffset = 173*4;

const TInt KUserFullSlabOffset = 174*4;

const TInt KUserSlabAllocOffset = 180*4;

const TInt KSelfReferenceOffset = 34*4; // same for user and kernel heaps

const TInt KUserInitialHeapMetaDataSize = 194 * 4;

const TInt KKernelInitialHeapMetaDataSize = 144 * 4;

__ASSERT_COMPILE(HeapV1::KUserInitialHeapMetaDataSize < KUserInitialHeapMetaDataSize);

__ASSERT_COMPILE(HeapV1::KUserInitialHeapMetaDataSize < KKernelInitialHeapMetaDataSize);

__ASSERT_COMPILE(KSelfReferenceOffset == HybridV1::KMallocStateOffset);

#ifdef TEST_HYBRIDHEAP_V2_ASSERTS

const TInt KUserHybridHeapSize = 44*4;

const TInt KUserDlAllocatorOffset = KUserHybridHeapSize;

const TInt KUserPageAllocatorOffset = 152 * 4;

const TInt KUserSlabAllocatorOffset = 172 * 4;

const TInt KKernelHybridHeapSize = 36*4;

const TInt KKernelDlAllocatorOffset = KKernelHybridHeapSize;

#ifndef __KERNEL_MODE__

__ASSERT_COMPILE(sizeof(RHybridHeap) == KUserHybridHeapSize);

__ASSERT_COMPILE(sizeof(RDlAllocator) == KUserPageAllocatorOffset - KUserDlAllocatorOffset);

__ASSERT_COMPILE(_FOFF(RDlAllocator, iDlaState) == KUserMallocStateOffset - KUserHybridHeapSize);

__ASSERT_COMPILE(sizeof(RPageAllocator) == KUserSlabAllocatorOffset - KUserPageAllocatorOffset);

__ASSERT_COMPILE(sizeof(RSlabHeapAllocator) == KUserInitialHeapMetaDataSize - KUserSlabAllocatorOffset);

__ASSERT_COMPILE(sizeof(RHybridHeap) + sizeof(RDlAllocator) + sizeof(RPageAllocator) + sizeof(RSlabHeapAllocator) == KUserInitialHeapMetaDataSize);

__ASSERT_COMPILE(_FOFF(RPageAllocator, iPageMap) == KUserPageMapOffset - KUserPageAllocatorOffset);

__ASSERT_COMPILE(_FOFF(RSlabHeapAllocator, iSparePage) == KUserSparePageOffset - KUserSlabAllocatorOffset);

__ASSERT_COMPILE(_FOFF(RSlabHeapAllocator, iPartialPage) == KUserPartialPageOffset - KUserSlabAllocatorOffset);

__ASSERT_COMPILE(_FOFF(RSlabHeapAllocator, iSlabAlloc) == KUserSlabAllocOffset - KUserSlabAllocatorOffset);

__ASSERT_COMPILE(_FOFF(TSlab, iParent) == HybridCom::KSlabParentOffset);

__ASSERT_COMPILE(_FOFF(TSlab, iChild1) == HybridCom::KSlabChild1Offset);

__ASSERT_COMPILE(_FOFF(TSlab, iChild2) == HybridCom::KSlabChild2Offset);

__ASSERT_COMPILE(_FOFF(TSlab, iPayload) == HybridCom::KSlabPayloadOffset);

__ASSERT_COMPILE(sizeof(TSlabSet) == HybridCom::KSlabsetSize);

#endif

__ASSERT_COMPILE(sizeof(RHybridHeap) == KKernelHybridHeapSize);

__ASSERT_COMPILE(_FOFF(RDlAllocator, iDlaState) == KKernelMallocStateOffset - KKernelHybridHeapSize);

__ASSERT_COMPILE(_FOFF(malloc_state, topsize) == HybridCom::KMallocStateTopSizeOffset);

__ASSERT_COMPILE(_FOFF(malloc_state, top) == HybridCom::KMallocStateTopOffset);

__ASSERT_COMPILE(_FOFF(malloc_state, seg) == HybridCom::KMallocStateSegOffset);

#endif

    } // namespace HybridV2

	} // namespace LtkUtils

#endif // FSHELL_HEAP_OFFSETS_H