sascompoundheap_8h_source.html

 /*

  * Copyright (c) 2004-2014 IBM Corporation.

  * All rights reserved. This program and the accompanying materials

  * are made available under the terms of the Eclipse Public License v1.0

  * which accompanies this distribution, and is available at

  * http://www.eclipse.org/legal/epl-v10.html

  *

  * Contributors:

  *     IBM Corporation, Steven Munroe      - initial API and implementation

  *     IBM Corporation, Adhemerval Zanella - documentation

  */


 #ifndef __SAS_COMPOUND_HEAP_H

 #define __SAS_COMPOUND_HEAP_H


 #include "sassimpleheap.h"


 typedef void *SASCompoundHeap_t;


 #ifdef __cplusplus

 #define __C__ "C"

 #else

 #define __C__

 #endif


 extern __C__ SASCompoundHeap_t

 SASCompoundHeapInit (void *heap_block, block_size_t heap_size,

                      block_size_t page_size, int expanding);


 extern __C__ SASCompoundHeap_t

 SASCompoundHeapExpandCreate (SASCompoundHeap_t heap);


 extern __C__ SASCompoundHeap_t SASCompoundHeapCreate (block_size_t heap_size);


 extern __C__ SASCompoundHeap_t

 SASCompoundHeapCreatePageSize (block_size_t heap_size,

                                block_size_t page_size);


 extern __C__ SASCompoundHeap_t

 SASCompoundFixedHeapCreate (block_size_t heap_size);


 extern __C__ void SASCompoundHeapDestroy (SASCompoundHeap_t heap);


 extern __C__ void

 SASCompoundHeapSetLoadFactor (SASCompoundHeap_t * heap, int load);


 extern __C__ int SASCompoundHeapGetLoadFactor (SASCompoundHeap_t * heap);


 extern __C__ block_size_t SASCompoundHeapAllocSize (SASCompoundHeap_t heap);


 extern __C__ block_size_t SASCompoundHeapFreeSpace (SASCompoundHeap_t heap);


 extern __C__ block_size_t SASCompoundHeapAllocSpace (SASCompoundHeap_t heap);


 extern __C__ block_size_t

 SASCompoundHeapWriteAll (SASCompoundHeap_t heap, int asyncBool);


 extern __C__ block_size_t

 SASCompoundHeapPurgeAll (SASCompoundHeap_t heap, int asyncBool);


 extern __C__ block_size_t SASCompoundHeapReleaseAll (SASCompoundHeap_t heap);


 extern __C__ block_size_t SASCompoundHeapBringAll (SASCompoundHeap_t heap);


 extern __C__ block_size_t

 SASCompoundHeapSeqAccessAll (SASCompoundHeap_t heap);


 extern __C__ block_size_t

 SASCompoundHeapRandomAccessAll (SASCompoundHeap_t heap);


 extern __C__ SASSimpleHeap_t SASCompoundHeapAlloc (SASCompoundHeap_t heap);


 extern __C__ void

 SASCompoundHeapFree (SASCompoundHeap_t heap, SASSimpleHeap_t free_block);


 extern __C__ SASSimpleHeap_t SASCompoundHeapNearAlloc (void *nearObj);


 extern __C__ void SASCompoundHeapNearDealloc (void *memAddr);


 extern __C__ void SASCompoundHeapDestroyNoLock (SASCompoundHeap_t heap);


 extern __C__ block_size_t

 SASCompoundHeapFreeSpaceNoLock (SASCompoundHeap_t heap);


 extern __C__ SASSimpleHeap_t

 SASCompoundHeapAllocNoLock (SASCompoundHeap_t heap);


 extern __C__ SASSimpleHeap_t SASCompoundHeapNearAllocNoLock (void *nearObj);


 extern __C__ void SASCompoundHeapNearDeallocNoLock (void *memAddr);


 extern __C__ void

 SASCompoundHeapFreeNoLock (SASCompoundHeap_t heap,

                            SASSimpleHeap_t free_block);


 #endif /* __SAS_COMPOUND_HEAP_H */

SASCompoundHeapNearDealloc
__C__ void SASCompoundHeapNearDealloc(void *memAddr)
Free the allocated SAS Simple Heap based on a contained memAddr.

SASCompoundHeapNearAllocNoLock
__C__ SASSimpleHeap_t SASCompoundHeapNearAllocNoLock(void *nearObj)
Allocate a new SAS Simple Heap from SAS Compound Heap nearObj.

SASCompoundHeapAllocNoLock
__C__ SASSimpleHeap_t SASCompoundHeapAllocNoLock(SASCompoundHeap_t heap)
Sub-Allocate a new SAS Simple Heap from a SAS Compound Heaps internal space.

SASCompoundHeapNearDeallocNoLock
__C__ void SASCompoundHeapNearDeallocNoLock(void *memAddr)
Free the allocated SAS Simple Heap memAddr from associated SAS Compound Heap.

SASCompoundHeapDestroyNoLock
__C__ void SASCompoundHeapDestroyNoLock(SASCompoundHeap_t heap)
Destroy the SAS Compound Heap heap.

SASCompoundHeapReleaseAll
__C__ block_size_t SASCompoundHeapReleaseAll(SASCompoundHeap_t heap)
Inform the kernel that the SAS Compound Heap memory segments can be removed from real memory...

SASCompoundHeapBringAll
__C__ block_size_t SASCompoundHeapBringAll(SASCompoundHeap_t heap)
Inform the kernel that the SAS Compound Heap memory segments pages will be needed soon...

sassimpleheap.h
Shared Address Space Simple Heap.

SASCompoundHeapNearAlloc
__C__ SASSimpleHeap_t SASCompoundHeapNearAlloc(void *nearObj)
Allocate a new SAS Simple Heap from SAS Compound Heap nearObj.

__C__
#define __C__
ignore this macro behind the curtain
Definition: sasmsync.h:32

SASCompoundHeapFreeSpace
__C__ block_size_t SASCompoundHeapFreeSpace(SASCompoundHeap_t heap)
Return the total available free space on SAS Compound heap heap.

SASCompoundHeapInit
__C__ SASCompoundHeap_t SASCompoundHeapInit(void *heap_block, block_size_t heap_size, block_size_t page_size, int expanding)
Initialize a shared storage as a compound heap.

SASCompoundHeapAllocSize
__C__ block_size_t SASCompoundHeapAllocSize(SASCompoundHeap_t heap)
Return the page size from SAS Compound Heap heap.

SASCompoundHeapFree
__C__ void SASCompoundHeapFree(SASCompoundHeap_t heap, SASSimpleHeap_t free_block)
Free the allocated SAS Simple Heap block in the SAS Compound Heap heap.

SASCompoundHeapGetLoadFactor
__C__ int SASCompoundHeapGetLoadFactor(SASCompoundHeap_t *heap)
Return the load factor from SAS Compound Heap heap.

SASCompoundHeapSeqAccessAll
__C__ block_size_t SASCompoundHeapSeqAccessAll(SASCompoundHeap_t heap)
Inform the kernel that the SAS Compound Heap memory segments pages will be needed soon and will be ac...

SASCompoundHeapExpandCreate
__C__ SASCompoundHeap_t SASCompoundHeapExpandCreate(SASCompoundHeap_t heap)
Create an expanding SAS Compound Heap based on existing heap.

SASCompoundHeapDestroy
__C__ void SASCompoundHeapDestroy(SASCompoundHeap_t heap)
Destroy the SAS Compound Heap heap.

SASCompoundHeapAlloc
__C__ SASSimpleHeap_t SASCompoundHeapAlloc(SASCompoundHeap_t heap)
Sub-Allocate a new SAS Simple Heap from a SAS Compound Heaps internal space.

SASCompoundHeapFreeNoLock
__C__ void SASCompoundHeapFreeNoLock(SASCompoundHeap_t heap, SASSimpleHeap_t free_block)
Free the allocated SAS Simple Heap free_block from SAS Compound Heap heap.

SASCompoundHeapPurgeAll
__C__ block_size_t SASCompoundHeapPurgeAll(SASCompoundHeap_t heap, int asyncBool)
Write down the SAS Compound Heap to persistent storage and inform the kernel that those pages can be ...

SASCompoundHeapCreatePageSize
__C__ SASCompoundHeap_t SASCompoundHeapCreatePageSize(block_size_t heap_size, block_size_t page_size)
Create a new SAS Compound Heap with heap_size size and page_size page size.

SASSimpleHeap_t
void * SASSimpleHeap_t
Handle to SAS Simple Space. The type is SAS_RUNTIME_SIMPLEHEAP.
Definition: sassimpleheap.h:34

SASCompoundHeapCreate
__C__ SASCompoundHeap_t SASCompoundHeapCreate(block_size_t heap_size)
Create a new SAS Compound Heap with heap_size size.

SASCompoundHeapSetLoadFactor
__C__ void SASCompoundHeapSetLoadFactor(SASCompoundHeap_t *heap, int load)
Set the SAS Compound Heap heap load factor to load.

SASCompoundHeapRandomAccessAll
__C__ block_size_t SASCompoundHeapRandomAccessAll(SASCompoundHeap_t heap)
Inform the kernel that the SAS Compound Heap memory segments pages will be needed soon and will be ac...

SASCompoundHeapFreeSpaceNoLock
__C__ block_size_t SASCompoundHeapFreeSpaceNoLock(SASCompoundHeap_t heap)
Return the total available free space on SAS Compound heap heap.

SASCompoundHeapAllocSpace
__C__ block_size_t SASCompoundHeapAllocSpace(SASCompoundHeap_t heap)
Return the total block space allocated to this SAS Compound heap heap.

SASCompoundFixedHeapCreate
__C__ SASCompoundHeap_t SASCompoundFixedHeapCreate(block_size_t heap_size)
Create a new non expanding SAS Compound heap with heap_size.

SASCompoundHeapWriteAll
__C__ block_size_t SASCompoundHeapWriteAll(SASCompoundHeap_t heap, int asyncBool)
Write down the SAS Compound Heap to persistent storage.

SASCompoundHeap_t
void * SASCompoundHeap_t
Handle to SAS Compound Heap. The type is SAS_RUNTIME_COMPOUNDHEAP.
Definition: sascompoundheap.h:119