How to share heaps

Heaps may be shared between threads within a process.

When a new thread is created:

• it can use the same heap as the thread which is doing the creating.

• it can use the heap which has been explicitly created for it by the thread which is doing the creating.

• it can use the heap automatically created for it by the operating system.

Only in the first two cases is the heap being shared.

Both are achieved by using the version of RThread::Create() prototyped as:

TInt Create(const TDesC& aName,
            TThreadFunction aFunction,
            TInt aStackSize,
            RHeap* aHeap,
            TAny* aPtr,
            TOwnerType aType=EOwnerProcess);

If aHeap is NULL, the new thread uses the same heap as the parent thread. For example:

RThread t;
_LIT(KTxtShared1,"Shared1");
... ...
TInt r=t.Create(KTxtShared1,
                threadEntryPoint,
                KDefaultStackSize,
                NULL,
                NULL);

The calling thread can create a new heap using User::ChunkHeap() or UserHeap::ChunkHeap() (this is the same function; the User class is derived from UserHeap) and pass this heap to the RThread::Create() function. For example:

_LIT(KTxtShare,"Share");
_LIT(KTxtShared1,"Shared1");
...
RHeap* pH=User::ChunkHeap(KTxtShare,0x1000,0x100000);
RThread t;
TInt r=t.Create(KTxtShared1,
                threadEntryPoint,
                KDefaultStackSize,
                pH,NULL);

The new heap is contained within its own chunk.

If the creating thread no longer has any interest in this explicitly created heap, it can close it by calling Close(). Note that the corresponding call to Open() was done automatically by User::ChunkHeap(). The function Open() should be used to re-open the heap for sharing; this increases the access count.

Note that Open() can only be called on a heap created using User::ChunkHeap().

The heaps which are created automatically for a thread should not be closed with a call to Close() since the chunk in which the heap is created contains the thread's stack as well as the heap. In this case, if Close() is called the thread is panicked.