diff -r c1f20ce4abcf -r 3e88ff8f41d5 kernel/eka/include/e32cmn.h --- a/kernel/eka/include/e32cmn.h Tue Aug 31 16:34:26 2010 +0300 +++ b/kernel/eka/include/e32cmn.h Wed Sep 01 12:34:56 2010 +0100 @@ -1102,15 +1102,6 @@ IMPORT_C TCjkWidth GetCjkWidth() const; IMPORT_C static TBool Compose(TUint& aResult,const TDesC16& aSource); IMPORT_C TBool Decompose(TPtrC16& aResult) const; - - // surrogate specific ones - inline static TBool IsSupplementary(TUint aChar); - inline static TBool IsSurrogate(TText16 aInt16); - inline static TBool IsHighSurrogate(TText16 aInt16); - inline static TBool IsLowSurrogate(TText16 aInt16); - inline static TUint JoinSurrogate(TText16 aHighSurrogate, TText16 aLowSurrogate); - inline static TText16 GetHighSurrogate(TUint aChar); - inline static TText16 GetLowSurrogate(TUint aChar); protected: inline void SetChar(TUint aChar); @@ -1971,10 +1962,6 @@ Structure for compile-time definition of a secure ID @internalComponent */ -#if defined(__ARMCC__) && __ARMCC_VERSION >= 400000 -#pragma push -#pragma diag_suppress 430 -#endif class SSecureId { public: @@ -1985,9 +1972,7 @@ public: TUint32 iId; }; -#if defined(__ARMCC__) && __ARMCC_VERSION >= 400000 -#pragma pop -#endif + @@ -1995,10 +1980,6 @@ Structure for compile-time definition of a vendor ID @internalComponent */ -#if defined(__ARMCC__) && __ARMCC_VERSION >= 400000 -#pragma push -#pragma diag_suppress 430 -#endif class SVendorId { public: @@ -2009,9 +1990,7 @@ public: TUint32 iId; }; -#if defined(__ARMCC__) && __ARMCC_VERSION >= 400000 -#pragma pop -#endif + @@ -2488,7 +2467,6 @@ IMPORT_C TInt Open(TInt aArgumentIndex, TOwnerType aType=EOwnerProcess); IMPORT_C void Wait(); IMPORT_C TInt Wait(TInt aTimeout); // timeout in microseconds - IMPORT_C TInt Poll(); // acquire the semaphore if possible, but don't block IMPORT_C void Signal(); IMPORT_C void Signal(TInt aCount); #endif @@ -2512,8 +2490,6 @@ inline RFastLock(); IMPORT_C TInt CreateLocal(TOwnerType aType=EOwnerProcess); IMPORT_C void Wait(); - IMPORT_C TInt Wait(TInt aTimeout); // timeout in microseconds - IMPORT_C TInt Poll(); // acquire the lock if possible, but don't block IMPORT_C void Signal(); private: TInt iCount; @@ -2654,130 +2630,135 @@ class RAllocator : public MAllocator { public: - /** - A set of heap allocation failure flags. - - This enumeration indicates how to simulate heap allocation failure. - - @see RAllocator::__DbgSetAllocFail() - */ - enum TAllocFail - { - /** - Attempts to allocate from this heap fail at a random rate; - however, the interval pattern between failures is the same - every time simulation is started. - */ - ERandom, - - /** - Attempts to allocate from this heap fail at a random rate. - The interval pattern between failures may be different every - time the simulation is started. - */ - ETrueRandom, - - /** - Attempts to allocate from this heap fail at a rate aRate; - for example, if aRate is 3, allocation fails at every - third attempt. - */ - EDeterministic, - - /** - Cancels simulated heap allocation failure. - */ - ENone, - - /** - An allocation from this heap will fail after the next aRate - 1 - allocation attempts. For example, if aRate = 1 then the next - attempt to allocate from this heap will fail. - */ - EFailNext, - - /** - Cancels simulated heap allocation failure, and sets - the nesting level for all allocated cells to zero. - */ - EReset, - - /** - aBurst allocations from this heap fail at a random rate; - however, the interval pattern between failures is the same - every time the simulation is started. - */ - EBurstRandom, - - /** - aBurst allocations from this heap fail at a random rate. - The interval pattern between failures may be different every - time the simulation is started. - */ - EBurstTrueRandom, - - /** - aBurst allocations from this heap fail at a rate aRate. - For example, if aRate is 10 and aBurst is 2, then 2 allocations - will fail at every tenth attempt. - */ - EBurstDeterministic, - - /** - aBurst allocations from this heap will fail after the next aRate - 1 - allocation attempts have occurred. For example, if aRate = 1 and - aBurst = 3 then the next 3 attempts to allocate from this heap will fail. - */ - EBurstFailNext, - - /** - Use this to determine how many times the current debug - failure mode has failed so far. - @see RAllocator::__DbgCheckFailure() - */ - ECheckFailure, - }; - - /** - Heap debug checking type flag. - */ - enum TDbgHeapType - { - /** - The heap is a user heap. - */ - EUser, - - /** - The heap is the Kernel heap. - */ - EKernel - }; - - enum TAllocDebugOp - { - ECount, EMarkStart, EMarkEnd, ECheck, ESetFail, ECopyDebugInfo, ESetBurstFail, EGetFail, - EGetSize=48, EGetMaxLength, EGetBase, EAlignInteger, EAlignAddr - }; - + + + /** + A set of heap allocation failure flags. + + This enumeration indicates how to simulate heap allocation failure. + + @see RAllocator::__DbgSetAllocFail() + */ + enum TAllocFail { + /** + Attempts to allocate from this heap fail at a random rate; + however, the interval pattern between failures is the same + every time simulation is started. + */ + ERandom, + + + /** + Attempts to allocate from this heap fail at a random rate. + The interval pattern between failures may be different every + time the simulation is started. + */ + ETrueRandom, + + + /** + Attempts to allocate from this heap fail at a rate aRate; + for example, if aRate is 3, allocation fails at every + third attempt. + */ + EDeterministic, + + + /** + Cancels simulated heap allocation failure. + */ + ENone, + + + /** + An allocation from this heap will fail after the next aRate - 1 + allocation attempts. For example, if aRate = 1 then the next + attempt to allocate from this heap will fail. + */ + EFailNext, + + /** + Cancels simulated heap allocation failure, and sets + the nesting level for all allocated cells to zero. + */ + EReset, + + /** + aBurst allocations from this heap fail at a random rate; + however, the interval pattern between failures is the same + every time the simulation is started. + */ + EBurstRandom, + + + /** + aBurst allocations from this heap fail at a random rate. + The interval pattern between failures may be different every + time the simulation is started. + */ + EBurstTrueRandom, + + + /** + aBurst allocations from this heap fail at a rate aRate. + For example, if aRate is 10 and aBurst is 2, then 2 allocations + will fail at every tenth attempt. + */ + EBurstDeterministic, + + /** + aBurst allocations from this heap will fail after the next aRate - 1 + allocation attempts have occurred. For example, if aRate = 1 and + aBurst = 3 then the next 3 attempts to allocate from this heap will fail. + */ + EBurstFailNext, + + /** + Use this to determine how many times the current debug + failure mode has failed so far. + @see RAllocator::__DbgCheckFailure() + */ + ECheckFailure, + }; + + + /** + Heap debug checking type flag. + */ + enum TDbgHeapType { + /** + The heap is a user heap. + */ + EUser, + + /** + The heap is the Kernel heap. + */ + EKernel + }; + + + enum TAllocDebugOp {ECount, EMarkStart, EMarkEnd, ECheck, ESetFail, ECopyDebugInfo, ESetBurstFail}; + + /** Flags controlling reallocation. */ - enum TReAllocMode - { - /** - A reallocation of a cell must not change - the start address of the cell. - */ - ENeverMove=1, - - /** - Allows the start address of the cell to change - if the cell shrinks in size. - */ - EAllowMoveOnShrink=2 - }; - + enum TReAllocMode { + /** + A reallocation of a cell must not change + the start address of the cell. + */ + ENeverMove=1, + + /** + Allows the start address of the cell to change + if the cell shrinks in size. + */ + EAllowMoveOnShrink=2 + }; + + enum TFlags {ESingleThreaded=1, EFixedSize=2, ETraceAllocs=4, EMonitorMemory=8,}; struct SCheckInfo {TBool iAll; TInt iCount; const TDesC8* iFileName; TInt iLineNum;}; #ifndef SYMBIAN_ENABLE_SPLIT_HEADERS @@ -2805,37 +2786,26 @@ UIMPORT_C TInt __DbgMarkCheck(TBool aCountAll, TInt aCount, const TDesC8& aFileName, TInt aLineNum); inline void __DbgMarkCheck(TBool aCountAll, TInt aCount, const TUint8* aFileName, TInt aLineNum); UIMPORT_C void __DbgSetAllocFail(TAllocFail aType, TInt aRate); - UIMPORT_C TAllocFail __DbgGetAllocFail(); UIMPORT_C void __DbgSetBurstAllocFail(TAllocFail aType, TUint aRate, TUint aBurst); UIMPORT_C TUint __DbgCheckFailure(); - UIMPORT_C TInt Size() const; - UIMPORT_C TInt MaxLength() const; - UIMPORT_C TUint8* Base() const; - UIMPORT_C TInt Align(TInt a) const; - UIMPORT_C TAny* Align(TAny* a) const; - protected: UIMPORT_C virtual TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1); #ifndef __KERNEL_MODE__ IMPORT_C virtual void DoClose(); #endif - protected: - TInt iAccessCount; // Value of the allocator's access count (ie. Number of times RAllocator::Open() has been called) - TInt iHandleCount; // Number of handles in the iHandles array - TInt* iHandles; // Array of handles to chunks used by the heap implementation - TUint32 iFlags; // Flags describing attributes of the heap; see RAllocator::TFlags - TInt iCellCount; // Internal debugger use only; use MAllocator::AllocSize() instead - TInt iTotalAllocSize; // Internal debugger use only; use MAllocator::AllocSize() instead + TInt iAccessCount; + TInt iHandleCount; + TInt* iHandles; + TUint32 iFlags; + TInt iCellCount; + TInt iTotalAllocSize; }; + + + class UserHeap; - -// This #define is for tools such as MemSpy that need to work across different versions of -// Symbian and need to know whether they are working with the new or old heap - -#define __SYMBIAN_KERNEL_HYBRID_HEAP__ - /** @publishedAll @released @@ -2844,20 +2814,127 @@ The default implementation uses an address-ordered first fit type algorithm. -The heap itself is contained in a chunk and may be the only occupant of the +The heap itself is contained in a chunk and may be the only occupant of the chunk or may share the chunk with the program stack. -The class contains member functions for allocating, adjusting, freeing individual +The class contains member functions for allocating, adjusting, freeing individual cells and generally managing the heap. -The class is not a handle in the same sense that RChunk is a handle; i.e. +The class is not a handle in the same sense that RChunk is a handle; i.e. there is no Kernel object which corresponds to the heap. */ - class RHeap : public RAllocator { public: - + /** + The structure of a heap cell header for a heap cell on the free list. + */ + struct SCell { + /** + The length of the cell, which includes the length of + this header. + */ + TInt len; + + + /** + A pointer to the next cell in the free list. + */ + SCell* next; + }; + + + /** + The structure of a heap cell header for an allocated heap cell in a debug build. + */ + struct SDebugCell { + /** + The length of the cell, which includes the length of + this header. + */ + TInt len; + + + /** + The nested level. + */ + TInt nestingLevel; + + + /** + The cumulative number of allocated cells + */ + TInt allocCount; + }; + + /** + @internalComponent + */ + struct SHeapCellInfo { RHeap* iHeap; TInt iTotalAlloc; TInt iTotalAllocSize; TInt iTotalFree; TInt iLevelAlloc; SDebugCell* iStranded; }; + + /** + @internalComponent + */ + struct _s_align {char c; double d;}; + + /** + The default cell alignment. + */ + enum {ECellAlignment = sizeof(_s_align)-sizeof(double)}; + + /** + Size of a free cell header. + */ + enum {EFreeCellSize = sizeof(SCell)}; + + +#ifdef _DEBUG + /** + Size of an allocated cell header in a debug build. + */ + enum {EAllocCellSize = sizeof(SDebugCell)}; +#else + /** + Size of an allocated cell header in a release build. + */ + enum {EAllocCellSize = sizeof(SCell*)}; +#endif + + + /** + @internalComponent + */ + enum TDebugOp {EWalk=128}; + + + /** + @internalComponent + */ + enum TCellType + {EGoodAllocatedCell, EGoodFreeCell, EBadAllocatedCellSize, EBadAllocatedCellAddress, + EBadFreeCellAddress, EBadFreeCellSize}; + + + /** + @internalComponent + */ + enum TDebugHeapId {EUser=0, EKernel=1}; + + /** + @internalComponent + */ + enum TDefaultShrinkRatios {EShrinkRatio1=256, EShrinkRatioDflt=512}; + +#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS + /** + @internalComponent + */ +#else +private: +#endif + typedef void (*TWalkFunc)(TAny*, TCellType, TAny*, TInt); + +public: UIMPORT_C virtual TAny* Alloc(TInt aSize); UIMPORT_C virtual void Free(TAny* aPtr); UIMPORT_C virtual TAny* ReAlloc(TAny* aPtr, TInt aSize, TInt aMode=0); @@ -2871,120 +2948,72 @@ UIMPORT_C virtual TInt DebugFunction(TInt aFunc, TAny* a1=NULL, TAny* a2=NULL); protected: UIMPORT_C virtual TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1); - inline RHeap() { } - public: - - /** - @internalComponent - - The structure of a heap cell header for an allocated heap cell in a debug build. - */ - struct SDebugCell - { - /** - The nested level. - */ - TInt nestingLevel; - - /** - The cumulative number of allocated cells - */ - TInt allocCount; - }; - - /** - @internalComponent - */ - struct SHeapCellInfo { RHeap* iHeap; TInt iTotalAlloc; TInt iTotalAllocSize; TInt iTotalFree; TInt iLevelAlloc; SDebugCell* iStranded; }; - - /** - Size of a free cell header. - */ - enum { EDebugHdrSize = sizeof(SDebugCell) }; - - /** - The default cell alignment. - */ - enum { ECellAlignment = 8 }; - - /** - Size of a free cell header. - */ - enum { EFreeCellSize = 4 }; - -#ifdef _DEBUG - /** - Size of an allocated cell header in a debug build. - */ - enum { EAllocCellSize = (4 + EDebugHdrSize) }; -#else - /** - Size of an allocated cell header in a release build. - */ - enum { EAllocCellSize = 4 }; -#endif - - /** - @internalComponent - */ - enum TDebugOp { EWalk = 128, EHybridHeap }; - - /** - @internalComponent - */ - enum TCellType - { - EGoodAllocatedCell, EGoodFreeCell, EBadAllocatedCellSize, EBadAllocatedCellAddress, - EBadFreeCellAddress, EBadFreeCellSize - }; - - /** - @internalComponent - */ - enum TDebugHeapId { EUser = 0, EKernel = 1 }; - - /** - @internalComponent - */ - enum TDefaultShrinkRatios { EShrinkRatio1 = 256, EShrinkRatioDflt = 512 }; - - /** - @internalComponent - */ - typedef void (*TWalkFunc)(TAny*, TCellType, TAny*, TInt); - + UIMPORT_C RHeap(TInt aMaxLength, TInt aAlign=0, TBool aSingleThread=ETrue); + UIMPORT_C RHeap(TInt aChunkHandle, TInt aOffset, TInt aMinLength, TInt aMaxLength, TInt aGrowBy, TInt aAlign=0, TBool aSingleThread=EFalse); + UIMPORT_C TAny* operator new(TUint aSize, TAny* aBase) __NO_THROW; + inline void operator delete(TAny* aPtr, TAny* aBase); + inline TUint8* Base() const; + inline TInt Size() const; + inline TInt MaxLength() const; + inline TInt Align(TInt a) const; + inline const TAny* Align(const TAny* a) const; + inline TBool IsLastCell(const SCell* aCell) const; + inline void Lock() const; + inline void Unlock() const; + inline TInt ChunkHandle() const; protected: - - // These variables are present only for downwards binary compatibility. Most are unused, - // but some must be present so that previously inline functions continue to work. These - // old inline functions are now replaced with non inline versions so recompiling existing - // code will automatically switch to the new versions and you should no longer access any - // of the variables in here. - // - // These variables should now all be considered private and should NOT be accessed directly! - // - TInt iUnused1; // Present for binary compatibility reasons only - TInt iMaxLength; // Use RAllocator::MaxLength() to get this information now - TInt iUnused2; // Present for binary compatibility reasons only - TInt iUnused3; // Present for binary compatibility reasons only - // These next two variables must remain in this order for correct object destruction - TInt iChunkHandle; // Do not use; consider undocumented - RFastLock iLock; // Do not use; consider undocumented - TUint8* iBase; // Use RAllocator::Base() to get this information now - TUint8* iTop; // Do not use; consider undocumented - TInt iAlign; // Use RAllocator::Align() to get this information now - - // These variables are temporary to prevent source breaks from req417-52840. They are deprecated in - // favour of non hacky ways of determining this information but are required during the switchover to - // this method - TAllocFail iFailType; // Use RAllocator::__DbgGetAllocFail() to get this information now - TInt iNestingLevel; // Do not use; consider undocumented - TAny* iTestData; // Do not use; consider undocumented + inline RHeap(); + void Initialise(); + SCell* DoAlloc(TInt aSize, SCell*& aLastFree); + void DoFree(SCell* pC); + TInt TryToGrowHeap(TInt aSize, SCell* aLastFree); + inline void FindFollowingFreeCell(SCell* aCell, SCell*& pPrev, SCell*& aNext); + TInt TryToGrowCell(SCell* pC, SCell* pP, SCell* pE, TInt aSize); + TInt Reduce(SCell* aCell); + UIMPORT_C SCell* GetAddress(const TAny* aCell) const; + void CheckCell(const SCell* aCell) const; + void Walk(TWalkFunc aFunc, TAny* aPtr); + static void WalkCheckCell(TAny* aPtr, TCellType aType, TAny* aCell, TInt aLen); + TInt DoCountAllocFree(TInt& aFree); + TInt DoCheckHeap(SCheckInfo* aInfo); + void DoMarkStart(); + TUint32 DoMarkEnd(TInt aExpected); + void DoSetAllocFail(TAllocFail aType, TInt aRate); + TBool CheckForSimulatedAllocFail(); + inline TInt SetBrk(TInt aBrk); + inline TAny* ReAllocImpl(TAny* aPtr, TInt aSize, TInt aMode); + void DoSetAllocFail(TAllocFail aType, TInt aRate, TUint aBurst); +protected: + TInt iMinLength; + TInt iMaxLength; + TInt iOffset; + TInt iGrowBy; + TInt iChunkHandle; + RFastLock iLock; + TUint8* iBase; + TUint8* iTop; + TInt iAlign; + TInt iMinCell; + TInt iPageSize; + SCell iFree; +protected: + TInt iNestingLevel; + TInt iAllocCount; + TAllocFail iFailType; + TInt iFailRate; + TBool iFailed; + TInt iFailAllocCount; + TInt iRand; + TAny* iTestData; friend class UserHeap; }; + + + + class OnlyCreateWithNull; /** @internalTechnology */ @@ -3848,12 +3877,12 @@ @param i4 The fourth TUint8 @internalComponent */ -#define FOUR_TUINT8(i1,i2,i3,i4) \ - ( \ - (TUint32)((i1) & 0xFF) | \ - (TUint32)((i2) & 0xFF) << 8 | \ - (TUint32)((i3) & 0xFF) << 16 | \ - (TUint32)((i4) & 0xFF) << 24 \ +#define FOUR_TUINT8(i1,i2,i3,i4) \ + (TUint32)( \ + (TUint8)i1 | \ + (TUint8)i2 << 8 | \ + (TUint8)i3 << 16 | \ + (TUint8)i4 << 24 \ )