// Copyright (c) 2002-2010 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "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:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// e32test\heap\t_heaphybridstress.cpp

// Overview:

// Tests RHybridHeap class: stress test

// API Information:

// RHybridHeap/RHeap

// Details:

// - Stress test heap implementation that allocates, frees

//   and reallocates cells in random patterns, and checks the heap.

// - Allocated/reallocated buffer content is verified, when buffer is freed/reallocated.

// - Stress test with a single thread

// - Stress test with two threads that run concurrently.

// - Tests configured for slab, doug lea, paged and hybrid allocators

// Platforms/Drives/Compatibility:

// All

// Assumptions/Requirement/Pre-requisites:

// Failures and causes:

// Base Port information:

// 

//

#include <e32test.h>

#include <e32hal.h>

#include <e32def.h>

#include <e32def_private.h>

#include "dla.h"

#include "slab.h"

#include "page_alloc.h"

#include "heap_hybrid.h"

// Needed for KHeapShrinkHysRatio which is now ROM 'patchdata'

#include "TestRHeapShrink.h"

//-------------------------------------------

//#define TSTDBG_PRINTMETA(a) a

#define TSTDBG_PRINTMETA(a)

//-------------------------------------------

#ifdef __EABI__

       IMPORT_D extern const TInt KHeapMinCellSize;

#else

       const TInt KHeapMinCellSize = 0;

#endif

RTest test(_L("T_HEAPSTRESS"));

#define TEST_ALIGN(p,a)     test((TLinAddr(p)&((a)-1))==0)

#define TST_HEAP_MAX_LTH 0x4000000 // 64M

#define MAX_CELL_COUNT 0x100000 // 0x100 0x1000 0x10000 0x100000

#define MAX_THREAD_COUNT 2

LOCAL_D TUint8* HeapStressCell[MAX_THREAD_COUNT][MAX_CELL_COUNT];

LOCAL_D TInt HeapStressLen[MAX_THREAD_COUNT][MAX_CELL_COUNT];

enum TTestHybridHeapFunc {ETstOnlySlab, ETstOnlyDl, ETstOnlyPaged, ETstHybrid};

enum TTestType {ETestE32Test, ETestForeverOne, ETestForeverAll};

LOCAL_D TTimeIntervalMicroSeconds32 TickPeriod;

//--------- config parameters - begin

LOCAL_D TTestType TestType;

LOCAL_D TInt TestTimeAsSeconds;

LOCAL_D TBool TestForeverMultiThreadTest;

LOCAL_D TTestHybridHeapFunc TestHybridHeapFunc;

LOCAL_D TInt CurrMaxCellCount;

LOCAL_D TInt HeapMaxLength;

//--------- config parameters - end

LOCAL_D TBool DlOnly;

LOCAL_D TInt SlabThreshold;

LOCAL_D TInt PageThreshold;

struct TMetaData

    {

    TBool           iDLOnly;

    RFastLock*      iLock;

    TInt            iChunkSize;

    TInt            iSlabThreshold;

    TInt            iPageThreshold;

    TInt            iSlabInitThreshold;

    TUint32         iSlabConfigBits;

    slab*           iPartialPage;

    slab*           iFullSlab;

    page*           iSparePage;

    TUint8*         iMemBase;

    TUint8          iSizeMap[(MAXSLABSIZE>>2)+1];

    slabset         iSlabAlloc[MAXSLABSIZE>>2];

    slab**          iSlabAllocRealRootAddress[MAXSLABSIZE>>2];

    };

class TestHybridHeap

    {

public:

    static void GetHeapMetaData(RHeap& aHeap, TMetaData& aMeta);

    };

void TestHybridHeap::GetHeapMetaData(RHeap& aHeap, TMetaData& aMeta)

{

    RHybridHeap::STestCommand cmd;

    cmd.iCommand = RHybridHeap::EHeapMetaData;

    TInt ret = aHeap.DebugFunction(RHeap::EHybridHeap, &cmd, 0);

    test(ret == KErrNone);

    RHybridHeap* hybridHeap = (RHybridHeap*)cmd.iData;

    aMeta.iDLOnly              = hybridHeap->iDLOnly;

    aMeta.iLock                = &hybridHeap->iLock;

    aMeta.iChunkSize           = hybridHeap->iChunkSize;

    aMeta.iSlabThreshold       = hybridHeap->iSlabThreshold;

    aMeta.iPageThreshold       = hybridHeap->iPageThreshold;

    aMeta.iSlabInitThreshold   = hybridHeap->iSlabInitThreshold;

    aMeta.iSlabConfigBits      = hybridHeap->iSlabConfigBits;

    aMeta.iPartialPage         = hybridHeap->iPartialPage;

    aMeta.iFullSlab            = hybridHeap->iFullSlab;

    aMeta.iSparePage           = hybridHeap->iSparePage;

    aMeta.iMemBase             = hybridHeap->iMemBase;

    TInt i;

    TInt count;

    count = sizeof(aMeta.iSizeMap)/sizeof(unsigned char);

    for (i=0; i<count; ++i)

        {

        aMeta.iSizeMap[i] = hybridHeap->iSizeMap[i];

        }

    count = sizeof(aMeta.iSlabAlloc)/sizeof(slabset);

    for (i=0; i<count; ++i)

        {

        aMeta.iSlabAlloc[i].iPartial = hybridHeap->iSlabAlloc[i].iPartial;

        aMeta.iSlabAllocRealRootAddress[i] = &hybridHeap->iSlabAlloc[i].iPartial;

        }

}

LOCAL_C void GetMeta(RHeap& aHeap, TMetaData& aMeta)

{

    TestHybridHeap::GetHeapMetaData(aHeap, aMeta);

}

TSTDBG_PRINTMETA(

LOCAL_C void PrintMeta(const char* aText, TMetaData& aMeta)

{

    RDebug::Printf("=========== HeapMetaData (local) - begin: %s", aText);

    RDebug::Printf("iDLOnly: 0x%08x", aMeta.iDLOnly);

    RDebug::Printf("iChunkSize: 0x%08x", aMeta.iChunkSize);

    RDebug::Printf("iSlabThreshold: 0x%08x / %d", aMeta.iSlabThreshold, aMeta.iSlabThreshold);

    RDebug::Printf("iPageThreshold: 0x%08x / %d", aMeta.iPageThreshold, aMeta.iPageThreshold);

    RDebug::Printf("iSlabInitThreshold: 0x%08x / %d", aMeta.iSlabInitThreshold, aMeta.iSlabInitThreshold);

    RDebug::Printf("iSlabConfigBits: 0x%08x", aMeta.iSlabConfigBits);

    RDebug::Printf("iPartialPage: 0x%08x", aMeta.iPartialPage);

    RDebug::Printf("iFullSlab: 0x%08x", aMeta.iFullSlab);

    RDebug::Printf("iSparePage: 0x%08x", aMeta.iSparePage);

    RDebug::Printf("iMemBase: 0x%08x", aMeta.iMemBase);

    TInt i;

    TInt count;

    count = sizeof(aMeta.iSizeMap)/sizeof(unsigned char);

    for (i=0; i<count; ++i)

        {

        RDebug::Printf("iSizeMap[%d]: %d", i, aMeta.iSizeMap[i]);

        }

    count = sizeof(aMeta.iSlabAlloc)/sizeof(slabset);

    for (i=0; i<count; ++i)

        {

        RDebug::Printf("iSlabAlloc[%d].iPartial: 0x%08x", i, aMeta.iSlabAlloc[i].iPartial);

        }

    for (i=0; i<count; ++i)

        {

        RDebug::Printf("iSlabAllocRealRootAddress[%d]: 0x%08x", i, aMeta.iSlabAllocRealRootAddress[i]);

        }

    RDebug::Printf("=========== HeapMetaData (local) - end");

}

)

LOCAL_C void ConfHeap(RHeap* aHeap)

{

    RHybridHeap::STestCommand cmd;

    if (TestHybridHeapFunc == ETstOnlySlab)

        {

        cmd.iCommand = RHybridHeap::ESetConfig;

        cmd.iConfig.iSlabBits = 0xabe;

        cmd.iConfig.iDelayedSlabThreshold = 0;            // 0 -> use slab at once from the beginning

        cmd.iConfig.iPagePower = 0;                       // 0 -> no page allocator

        }

    else if (TestHybridHeapFunc == ETstOnlyDl)

        {

        cmd.iCommand = RHybridHeap::ESetConfig;

        cmd.iConfig.iSlabBits = 0xabe;

        cmd.iConfig.iDelayedSlabThreshold = 0x40000000;   // 1G -> slab never used

        cmd.iConfig.iPagePower = 0;                       // 0 -> no page allocator

        }

    else if (TestHybridHeapFunc == ETstOnlyPaged)

        {

        cmd.iCommand = RHybridHeap::ESetConfig;

        cmd.iConfig.iSlabBits = 0xabe;

        cmd.iConfig.iDelayedSlabThreshold = 0x40000000;   // 1G -> slab never used

        cmd.iConfig.iPagePower = 14;                      // min page 14 -> 16K

        }

    else if (TestHybridHeapFunc == ETstHybrid)

        {

        cmd.iCommand = RHybridHeap::ESetConfig;

        cmd.iConfig.iSlabBits = 0xabe;

        cmd.iConfig.iDelayedSlabThreshold = 0;            // 0 -> use slab at once from the beginning

        cmd.iConfig.iPagePower = 14;                      // min page 14 -> 16K

        }

    else

        {

        test(0);

        }

    TInt ret = aHeap->DebugFunction(RHeap::EHybridHeap, &cmd, 0);

    test(ret == KErrNone);

}

LOCAL_C TInt MinPagedAllocLength(void)

{

    return (1 << PageThreshold);

}

LOCAL_C TUint32 RandomPagedLength(TUint32 aRandom)

{

    TUint32 ret;

    ret = aRandom;

    ret <<= PageThreshold;

    if (TestHybridHeapFunc == ETstOnlyPaged)

        {

        //ret &= 0xfffff; // below 1M

        ret &= 0x7ffff; // below 512K

        }

    else

        {

        ret &= 0x1ffff; // below 128K

        }

    if (ret == 0)

        {

        ret = MinPagedAllocLength();

        }

    return ret;

}

#if 0            

LOCAL_C TUint TicksAsMilliSeconds(TUint aTicks)

{

    TUint time = TUint((TUint64)aTicks*(TUint64)TickPeriod.Int()/(TUint64)1000);

    return time;

}

#endif

LOCAL_C TBool IsDlOnly(void)

{

    TestHybridHeapFunc = ETstHybrid;

    RHeap* heap;

    heap = UserHeap::ChunkHeap(&KNullDesC(), 0x1000, 0x4000, 0x1000, 4);

    test(heap != NULL);

    ConfHeap(heap);

    TMetaData metaData;

    GetMeta(*heap, metaData);

    heap->Close();

    return metaData.iDLOnly;

}

LOCAL_C RHeap* CreateTestHeap(TInt aAlign)

{

    if (HeapMaxLength > TST_HEAP_MAX_LTH)

        {

        HeapMaxLength = TST_HEAP_MAX_LTH;

        }

    if (CurrMaxCellCount > MAX_CELL_COUNT)

        {

        CurrMaxCellCount = MAX_CELL_COUNT;

        }

    RHeap* heap;

    heap = UserHeap::ChunkHeap(&KNullDesC(), 0x1000, HeapMaxLength, 0x1000, aAlign);

    test(heap != NULL);

    ConfHeap(heap);

    TMetaData metaData;

    GetMeta(*heap, metaData);

    if (TestHybridHeapFunc == ETstOnlySlab)

        {

        SlabThreshold = metaData.iSlabThreshold;

        test(SlabThreshold != 0);

        }

    else if (TestHybridHeapFunc == ETstOnlyDl)

        {

        }

    else if (TestHybridHeapFunc == ETstOnlyPaged)

        {

        PageThreshold = metaData.iPageThreshold;

        test(PageThreshold >= 14);

        }

    else if (TestHybridHeapFunc == ETstHybrid)

        {

        }

    else

        {

        test(0);

        }

    return heap;

}

//-------------------------------------------------------------------

struct STestCell

    {

    enum {EMagic = 0xb8aa3b29};

    TUint32 iLength;

    TUint32 iData[1];

    void Set(TInt aLength);

    void Verify(TInt aLength);

    void Verify(const TAny* aInitPtr, TInt aInitLength, TInt aLength);

    };

void STestCell::Set(TInt aLength)

    {

    TInt i;

    TUint32 x = (TUint32)this ^ (TUint32)aLength ^ (TUint32)EMagic;

    if (aLength < (TInt) sizeof(iLength))

        {

        return;

        }

    iLength = x;

    aLength /= sizeof(TUint32);

    for (i=0; i<aLength-1; ++i)

        {

        x *= 69069;

        x += 41;

        iData[i] = x;

        }

    }

void STestCell::Verify(TInt aLength)

    {

    Verify(this, aLength, aLength);

    }

void STestCell::Verify(const TAny* aInitPtr, TInt aInitLength, TInt aLength)

    {

    TInt i;

    TUint32 x = (TUint32)aInitPtr ^ (TUint32)aInitLength ^ (TUint32)EMagic;

    if (aLength < (TInt) sizeof(iLength))

        {

        return;

        }

    test(iLength == x);

    aLength /= sizeof(TUint32);

    for (i=0; i<aLength-1; ++i)

        {

        x *= 69069;

        x += 41;

        test(iData[i] == x);

        }

    }

class RTestHeap : public RHeap

    {

public:

    TInt CheckAllocatedCell(const TAny* aCell) const;

    void FullCheckAllocatedCell(const TAny* aCell) const;

    TAny* TestAlloc(TInt aSize);

    void TestFree(TAny* aPtr);

    TAny* TestReAlloc(TAny* aPtr, TInt aSize, TInt aMode=0);

    void FullCheck();

    static void WalkFullCheckCell(TAny* aPtr, TCellType aType, TAny* aCell, TInt aLen);

    };

TInt RTestHeap::CheckAllocatedCell(const TAny* aCell) const

    {

    TInt len = AllocLen(aCell);

    return len;

    }

void RTestHeap::FullCheckAllocatedCell(const TAny* aCell) const

    {

    ((STestCell*)aCell)->Verify(CheckAllocatedCell(aCell));

    }

TAny* RTestHeap::TestAlloc(TInt aSize)

    {

    TAny* p = Alloc(aSize);

    if (p)

        {

        TInt len = CheckAllocatedCell(p);

        test(len>=aSize);       

        ((STestCell*)p)->Set(len);

        }

    return p;

    }

void RTestHeap::TestFree(TAny* aPtr)

    {

    if (aPtr)

        {

        FullCheckAllocatedCell(aPtr);

        }

    Free(aPtr);

    }

TAny* RTestHeap::TestReAlloc(TAny* aPtr, TInt aSize, TInt aMode)

    {

    TInt old_len = aPtr ? CheckAllocatedCell(aPtr) : 0;

    if (aPtr)

        ((STestCell*)aPtr)->Verify(old_len);

    TAny* p = ReAlloc(aPtr, aSize, aMode);

    if (!p)

        {

        ((STestCell*)aPtr)->Verify(old_len);

        return p;

        }

    TInt new_len = CheckAllocatedCell(p);

    test(new_len>=aSize);       

    if (p == aPtr)

        {

        ((STestCell*)p)->Verify(p, old_len, Min(old_len, new_len));

        if (new_len != old_len)

            ((STestCell*)p)->Set(new_len);

        return p;

        }

    test(!(aMode & ENeverMove));

    test((new_len > old_len) || (aMode & EAllowMoveOnShrink));

    if (old_len)

        ((STestCell*)p)->Verify(aPtr, old_len, Min(old_len, aSize));

    ((STestCell*)p)->Set(new_len);

    return p;

    }

struct SHeapCellInfo

    {

    RTestHeap* iHeap;

    TInt iTotalAlloc;

    TInt iTotalAllocSize;

    TInt iTotalFree;

    TUint8* iNextCell;

    };

void RTestHeap::WalkFullCheckCell(TAny* aPtr, TCellType aType, TAny* aCell, TInt aLen)

    {

    (void)aCell;

    ::SHeapCellInfo& info = *(::SHeapCellInfo*)aPtr;

    switch(aType)

        {

        case EGoodAllocatedCell:

            {

            TInt len = aLen;

            info.iTotalAllocSize += len;

            STestCell* pT = (STestCell*)aCell;

            ++info.iTotalAlloc;

            pT->Verify(len);

            break;

            }

        case EGoodFreeCell:

            {

            ++info.iTotalFree;

            break;

            }

        default:

            test.Printf(_L("TYPE=%d ??\n"),aType);

            test(0);

            break;

        }

    }

void RTestHeap::FullCheck()

    {

    ::SHeapCellInfo info;

    Mem::FillZ(&info, sizeof(info));

    info.iHeap = this;

    DebugFunction(EWalk, (TAny*)&WalkFullCheckCell, &info);

    TInt count = AllocSize(iTotalAllocSize);

    test(info.iTotalAlloc == count);

    test(info.iTotalAllocSize == iTotalAllocSize);

    }

struct STestStress

    {

    RThread iThread;

    volatile TBool iStop;

    TInt iAllocs;

    TInt iFailedAllocs;

    TInt iFrees;

    TInt iReAllocs;

    TInt iFailedReAllocs;

    TInt iChecks;

    TUint32 iSeed;

    RAllocator* iAllocator;

    TInt iThreadIndex;

    TUint32 Random();

    };

TUint32 FirstSeed(TInt aThreadIndex)

    {

    static TUint32 seed0 = 0xb504f334;

    static TUint32 seed1 = 0xddb3d743;

    static TBool first = ETrue;

    TUint32 ret;