// Copyright (c) 1995-2009 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_heapslab.cpp

// Overview:

// Tests RHybridHeap class: slab allocator

// API Information:

// RHybridHeap/RHeap

// Details:

//- Starts with empty allocator configured to use slab allocation

//  on all cell sizes less than slab threshold (49).

//- Allocate enough cells of the same size to fill 128 slabs.

//- Check the number of pages used corresponds to the number of slabs.

//- Check that a new slab is taken from a partially filled page if available.

//- Check that a partially filled slab is used if available.

//- Check that if all four slabs in a page are free, the page is freed.

//- Free cells to give empty slab.

//- Free cells to give partial slab.

//- Reallocate cells.

//- RAllocator::Check() is used to check internal consistency.

// 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"

#define MAX_THREADS 4

#define MAX_ALLOCS 20000 // 16128, if slab count is 128 and alloc size is 8

//#define TSTSLAB_DBG(a) a

#define TSTSLAB_DBG(a)

struct TSlabTestThreadParm

    {

    RHeap*  iHeap;

    TInt    iAllocSize;

    TInt    iInitSlabCount;

    TBool   iUseRandomSize;

    TInt    iThreadCount;

    TInt    iThreadIndex;

    };

struct TMetaData

    {

    TBool           iDLOnly;

    RFastLock*      iLock;

    TInt            iChunkSize;

    TInt            iSlabThreshold;

    unsigned        iSlabInitThreshold;

    unsigned        iSlabConfigBits;

    slab*           iPartialPage;

    slab*           iFullSlab;

    page*           iSparePage;

    TUint8*         iMemBase;

    unsigned char   iSizeMap[(MAXSLABSIZE>>2)+1];

    slabset         iSlabAlloc[MAXSLABSIZE>>2];

    slab**          iSlabAllocRealRootAddress[MAXSLABSIZE>>2];

    };

class TestHybridHeap

    {

public:

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

    };

LOCAL_D RTest test(_L("T_HEAPSLAB"));

LOCAL_D TInt PageSize;

LOCAL_D TAny* PtrBuf[MAX_THREADS][MAX_ALLOCS];

LOCAL_D TSlabTestThreadParm ThreadParm[MAX_THREADS];

enum TTestWalkFunc {ETestWalk, ETestFindSlab};

static unsigned SlabHeaderPagemap(unsigned h) {return (h&0x00000f00)>>8;}

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.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);

}

/*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("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 GetAndPrintMeta(RHeap& aHeap, const char* aText, TMetaData& aMeta)

{

    (void)aText;

    GetMeta(aHeap, aMeta);

    TSTSLAB_DBG(PrintMeta(aText, aMeta));

}

#ifndef __KERNEL_MODE__

LOCAL_C void Lock(TMetaData& aMeta)

   {((RFastLock&)*aMeta.iLock).Wait();}

LOCAL_C void Unlock(TMetaData& aMeta)

   {((RFastLock&)*aMeta.iLock).Signal();}

#else

LOCAL_C void Lock(TMetaData& aMeta)

   {;}

LOCAL_C void Unlock(TMetaData& aMeta)

   {;}

#endif

*/

LOCAL_C  page* PageFor(slab* s)

    {

        return reinterpret_cast<page*>(Floor(s, PAGESIZE));

    }

LOCAL_C slab* SlabFor(const void* p)

{

    return (slab*)(Floor(p, SLABSIZE));

}

LOCAL_C TInt TreeWalk(slab** aRealRootAddress, slab* const* aRoot, TTestWalkFunc aFunc, TAny* aParm, TInt& aOutParm)

{

    TInt count = 0;

    aOutParm = 0;

    slab* s = *aRoot;

    if (!s)

        return count;

    for (;;)

        {

        slab* c;

        while ((c = s->iChild1) != 0)

            s = c;      // walk down left side to end

        for (;;)

            {

            count++;

            TSTSLAB_DBG(RDebug::Printf("TreeWalk - slab: 0x%08x", s));

            (void)aParm;

            if (aFunc == ETestWalk)

                {

                ;

                }

            else if (aFunc == ETestFindSlab)

                {

                if ((slab*)aParm == s)

                    {

                    aOutParm = 1;

                    return 0;

                    }

                }

            c = s->iChild2;

            if (c)

                {   // one step down right side, now try and walk down left

                s = c;

                break;

                }

            for (;;)

                {   // loop to walk up right side

                slab** pp = s->iParent;

                if (pp == aRealRootAddress)

                    return count;

                s = SlabFor(pp);

                if (pp == &s->iChild1)

                    break;

                }

            }

        }

}

LOCAL_C TInt WalkSlabSet(TInt aSlabsetIndex, TMetaData& aMeta, TTestWalkFunc aFunc, TAny* aParm, TInt& aOutParm)

{

    if (aSlabsetIndex >= (MAXSLABSIZE>>2))

        {

        return 0;

        }

    return TreeWalk(aMeta.iSlabAllocRealRootAddress[aSlabsetIndex], &aMeta.iSlabAlloc[aSlabsetIndex].iPartial, aFunc, aParm, aOutParm);

}

/*LOCAL_C void DebugPrintSlabs(TInt aSlabsetIndex, TMetaData& aMeta)

    {

    //RDebug::Printf("=========== DebugPrintSlabs: %s", aText);

    RDebug::Printf("=========== DebugPrintSlabs");

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

    slab* fullSlab = aMeta.iFullSlab;

    TInt fullSlabCount = 0;

    while (fullSlab)

        {

        RDebug::Printf("fullSlab: 0x%08x", fullSlab);

        fullSlabCount++;

        fullSlab = fullSlab->iChild1;

        }

    TInt outParm;

    TInt partialTreeSlabCount = 0;

    partialTreeSlabCount += WalkSlabSet(aSlabsetIndex, aMeta, ETestWalk, 0, outParm);

    slab* partialPageSlab = aMeta.iPartialPage;

    TInt partialPageSlabCount = 0;

    while (partialPageSlab)

        {

        RDebug::Printf("partialPageSlab (empty): 0x%08x", partialPageSlab);

        partialPageSlabCount++;

        partialPageSlab = partialPageSlab->iChild1;

        }

    }*/

LOCAL_C void TestSlabFixedSizeManyThreads(TSlabTestThreadParm& aParm)

    {

    RHeap* heap = aParm.iHeap;

    TInt allocSize = aParm.iAllocSize;

    TInt initSlabCount = aParm.iInitSlabCount;

    //TBool useRandomSize = aParm.iUseRandomSize;

    //TInt threadCount = aParm.iThreadCount;

    TInt threadIndex = aParm.iThreadIndex;

    TInt slabsPerPage = PageSize/SLABSIZE;

    test(initSlabCount % slabsPerPage == 0); // for this test

#ifdef _DEBUG

    TInt allocRealCellSize = allocSize + RHeap::EDebugHdrSize;

#else

    TInt allocRealCellSize = allocSize;

#endif

    TMetaData metaData;

    GetMeta(*heap, metaData);

    if (allocRealCellSize >= metaData.iSlabThreshold)

        {

        allocRealCellSize = metaData.iSlabThreshold - 1;

#ifdef _DEBUG

        allocSize = allocRealCellSize - RHeap::EDebugHdrSize;

#else

        allocSize = allocRealCellSize;

#endif

        }

    TAny** pBuf = &PtrBuf[threadIndex][0];

    TInt i;

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

        {

        pBuf[i] = 0;

        }

    //Allocate enough cells of the same size to fill initSlabCount (128) slabs

    TInt slabsetIndex = metaData.iSizeMap[(allocRealCellSize+3)>>2];

    test(slabsetIndex != 0xff);

    TInt slabCellSize = 4 + (slabsetIndex * 4);

    TInt slabPayloadSize = SLABSIZE - sizeof(slabhdr);

    TInt cellCountPerSlab = slabPayloadSize / slabCellSize;

    TInt initCellCount = initSlabCount * cellCountPerSlab;

    TSTSLAB_DBG(RDebug::Printf("=========== Allocate enough cells of the same size to fill %d slabs", initSlabCount));

    TSTSLAB_DBG(RDebug::Printf("=========== counts: %d %d %d", cellCountPerSlab, initCellCount, slabCellSize));

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

        {

        pBuf[i] = heap->Alloc(allocSize);

        test(pBuf[i] != 0);

        }

    heap->Check();

    TInt maxI5 = initCellCount + (cellCountPerSlab*(slabsPerPage+1));

    for (i=initCellCount; i<maxI5; ++i)

        {

        pBuf[i] = heap->Alloc(allocSize);

        test(pBuf[i] != 0);

        }

    heap->Check();

    TAny* p2 = heap->Alloc(allocSize);

    test(p2 != 0);

    heap->Check();

    heap->Free(p2);

    heap->Check();

    TInt page2pBufIndexFirst = cellCountPerSlab * slabsPerPage;

    //TInt page2pBufIndexLast = page2pBufIndexFirst + (cellCountPerSlab * slabsPerPage);

    slab* partialTreeSlabX1 = SlabFor(pBuf[page2pBufIndexFirst]);

    page* partialTreeSlabPageX1 = PageFor(partialTreeSlabX1);

    heap->Free(pBuf[page2pBufIndexFirst]);

    pBuf[page2pBufIndexFirst] = 0;

    heap->Check();

    TAny* p3 = heap->Alloc(allocSize);

    test(p3 != 0);

    heap->Check();

    heap->Free(p3);

    heap->Check();

    TInt size2 = metaData.iChunkSize;

    TSTSLAB_DBG(RDebug::Printf("---- size2: 0x%08x", size2));

    if (metaData.iSparePage)

        {

        size2 -= PageSize;

        }

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

        {

        if (pBuf[i]) {

            page* page1 = PageFor(SlabFor(pBuf[i]));

            if (partialTreeSlabPageX1 == page1)

                {

                heap->Free(pBuf[i]);

                pBuf[i] = 0;

                }

            }

        }

    heap->Check();

    TInt size3 = metaData.iChunkSize;

    if (metaData.iSparePage)

        {

        size3 -= PageSize;

        }

    TInt bufIndexFirst = cellCountPerSlab;

    TInt maxI = bufIndexFirst + cellCountPerSlab;

    for (i=bufIndexFirst; i<=maxI; ++i)

        {

        if (pBuf[i])

            {

            heap->Free(pBuf[i]);

            pBuf[i] = 0;

            }

        }

    heap->Check();

    TInt firstI = cellCountPerSlab * 3;

    maxI = firstI + cellCountPerSlab;

    for (i=firstI; i<=maxI; ++i)

        {

        if (i % 3 == 0)

            {

            if (pBuf[i])

                {

                heap->Free(pBuf[i]);

                pBuf[i] = 0;

                }

            }

        }

    heap->Check();

    //Reallocate cells.

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

        {

        if (pBuf[i] != 0)

            {

            pBuf[i] = heap->ReAlloc(pBuf[i], allocSize);

            test(pBuf[i] != 0);

            }

        }

    heap->Check();

    //Allocate cells.

    for (i=0; i<(MAX_ALLOCS/4); ++i)

        {

        if (pBuf[i] == 0)

            {

            pBuf[i] = heap->Alloc(allocSize);

            test(pBuf[i] != 0);

            }

        }

    heap->Check();

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

        {

        if (pBuf[i])

            {

            heap->Free(pBuf[i]);

            pBuf[i] = 0;

            }

        }

    heap->Check();

    TSTSLAB_DBG(RDebug::Printf("=========== TestSlabFixedSizeManyThreads end"));

    }

LOCAL_C void TestSlabFixedSizeOneThread(TSlabTestThreadParm& aParm)

    {

    RHeap* heap = aParm.iHeap;

    TInt allocSize = aParm.iAllocSize;

    TInt initSlabCount = aParm.iInitSlabCount;

    //TBool useRandomSize = aParm.iUseRandomSize;

    //TInt threadCount = aParm.iThreadCount;

    TInt threadIndex = aParm.iThreadIndex;

    TInt slabsPerPage = PageSize/SLABSIZE;

    test(initSlabCount % slabsPerPage == 0); // for this test

#ifdef _DEBUG

    TInt allocRealCellSize = allocSize + RHeap::EDebugHdrSize;

#else

    TInt allocRealCellSize = allocSize;

#endif

    TMetaData metaData;

    GetMeta(*heap, metaData);

    TSTSLAB_DBG(PrintMeta(" --- TestSlabFixedSizeOneThread start", metaData));

    if (allocRealCellSize >= metaData.iSlabThreshold)

        {

        allocRealCellSize = metaData.iSlabThreshold - 1;

#ifdef _DEBUG

        allocSize = allocRealCellSize - RHeap::EDebugHdrSize;

#else

        allocSize = allocRealCellSize;

#endif

        }

    TAny** pBuf = &PtrBuf[threadIndex][0];

    TInt i;

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

        {

        pBuf[i] = 0;

        }

    //Allocate enough cells of the same size to fill initSlabCount (128) slabs

    TInt slabsetIndex = metaData.iSizeMap[(allocRealCellSize+3)>>2];

    test(slabsetIndex != 0xff);

    TInt slabCellSize = 4 + (slabsetIndex * 4);