Collapse all Symbian^3 Product Developer Library

Writable Data Paging Overview

Overview of data paging, the next phase in Symbian's implementation of demand paging.

Purpose

Writable data paging allows the demand paging of any user-side data (for example thread stacks and heaps). Writable data paging makes use of a fixed size backing store to page out data. The backing store may use a NAND flash partition or an embedded MMC (eMMC).

The aim of data paging is to enable more memory-hungry use cases without increasing the amount of physical RAM present in the device.

For example, data paging enables:

running applications that are not designed with the memory constraints of embedded devices in mind, for example applications ported from other environments with writable data paging (such as a PC).
running multiple applications at the same time where previously there would not have been enough memory.

Note: Data paging offers no performance increase, unlike code paging which can speed up application loading by reading only the necessary pages into RAM.

However, writable data paging does have the following limitations:

It is only possible to page the following types of memory:
- user heaps,
- user thread stacks,
- private chunks,
- global chunks,
- static data.
A single memory object (e.g. a heap, stack, DLL or chunk) is the smallest granularity at which paging can be configured
No attempt will be made to page kernel-side data
No attempt will be made to implement memory mapped files (e.g. posix's mmap)
No attempt will be made to implement any kind of paging on the emulator.

Required background

This document assumes that the reader is familiar with the concept of Demand Paging, and the existing implementation of ROM and code paging in Symbian platform.

Key concepts and terms

Page: Memory is managed in fixed size units called pages. The size of a page is usually determined by the hardware, and for ARM architectures this is 4K.
Paged in or Paged out: If a given page of memory is present in RAM it is said to be paged in (or just 'present'), as opposed to paged out.
Paging in: The process of moving a page of memory from being paged out to being paged in.
Paging out: The process of moving a page of memory from being paged in to being paged out.
backing store: The external media used to hold paged out pages is referred to as the swap area. This area may be much larger than physical RAM, although a factor of around twice as large is considered normal in existing systems.
Working set: The term working set is defined as the memory accessed during a given time period.
Pinning: Pinning pages refers to paging in demand-paged memory and forcing it to remain in RAM until it is unpinned at a later time.

Classes

The following classes are affected by the use of writable data demand paging:

The following classes are involved in the use of threads and processes:

Class	Description
RThread	This class is used to handle threads.
RProcess	This class is used to handle processes.
TThreadCreateInfo	Used to specify the attributes of a new thread.

These classes are used in handling memory:

Class	Description
RChunk	Handle a chunk.
TChunkCreateInfo	A structure that specifies the type and properties of the chunk that is to be created.
TChunkHeapCreateInfo	A structure that specifies the type and properties of a chunk with a heap within it.
UserHeap	A set of functions that are used to create heaps.

The following classes are used in client/server communication:

Class	Description
CServer2	The abstract base class for servers.
TIpcArgs	A client/server class that clients use to package arguments that are to be sent to a sever.

Parent topic: Writable Data Paging

Related information

Flexible Memory Model Overview