| 1 |
\hypertarget{group__mem__pool}{ |
| 2 |
\section{Memory pool} |
| 3 |
\label{group__mem__pool}\index{Memory pool@{Memory pool}} |
| 4 |
} |
| 5 |
|
| 6 |
|
| 7 |
\subsection{Detailed Description} |
| 8 |
\begin{Desc} |
| 9 |
\item[]Memory pool allocator for objects of same size. This interface offers an allocator \hyperlink{group__mem__pool_ga9}{peak\_\-mem\_\-pool\_\-new()} which is O(1) except in some rare cases when the pool is growing (at worst log2({\tt n}) times for {\tt n} allocations). However, if you know its size in advance, you can precise it in the {\tt peak\_\-mem\_\-pool} creation method \hyperlink{group__mem__pool_ga7}{peak\_\-mem\_\-pool\_\-create()}. You can create as many memory pools you want as interface and implementation are object oriented (like most of peak stuffs). \end{Desc} |
| 10 |
|
| 11 |
|
| 12 |
\subsection*{Typedefs} |
| 13 |
\begin{CompactItemize} |
| 14 |
\item |
| 15 |
\hypertarget{group__mem__pool_ga0}{ |
| 16 |
typedef \_\-\_\-peak\_\-mem\_\-pool $\ast$ \hyperlink{group__mem__pool_ga0}{peak\_\-mem\_\-pool}} |
| 17 |
\label{group__mem__pool_ga0} |
| 18 |
|
| 19 |
\begin{CompactList}\small\item\em Opaque mem\_\-pool pointer type. \item\end{CompactList}\end{CompactItemize} |
| 20 |
\subsection*{Functions} |
| 21 |
\begin{CompactItemize} |
| 22 |
\item |
| 23 |
\hyperlink{group__mem__pool_ga0}{peak\_\-mem\_\-pool} \hyperlink{group__mem__pool_ga1}{peak\_\-mem\_\-pool\_\-create} (int object\_\-size, int log\_\-size) |
| 24 |
\begin{CompactList}\small\item\em Create a mem\_\-pool object. \item\end{CompactList}\item |
| 25 |
void $\ast$ \hyperlink{group__mem__pool_ga2}{peak\_\-mem\_\-pool\_\-new} (\hyperlink{group__mem__pool_ga0}{peak\_\-mem\_\-pool} pool) |
| 26 |
\begin{CompactList}\small\item\em Allocate an object in constant time. \item\end{CompactList}\item |
| 27 |
void \hyperlink{group__mem__pool_ga3}{peak\_\-mem\_\-pool\_\-delete} (\hyperlink{group__mem__pool_ga0}{peak\_\-mem\_\-pool} pool, void $\ast$ptr) |
| 28 |
\begin{CompactList}\small\item\em Deallocate an object in constant time. \item\end{CompactList}\item |
| 29 |
int \hyperlink{group__mem__pool_ga4}{peak\_\-mem\_\-pool\_\-get\_\-used\_\-count} (\hyperlink{group__mem__pool_ga0}{peak\_\-mem\_\-pool} pool) |
| 30 |
\begin{CompactList}\small\item\em Statistics: get used pointers count. \item\end{CompactList}\item |
| 31 |
int \hyperlink{group__mem__pool_ga5}{peak\_\-mem\_\-pool\_\-get\_\-free\_\-count} (\hyperlink{group__mem__pool_ga0}{peak\_\-mem\_\-pool} pool) |
| 32 |
\begin{CompactList}\small\item\em Statistics: get free pointers count. \item\end{CompactList}\item |
| 33 |
int \hyperlink{group__mem__pool_ga6}{peak\_\-mem\_\-pool\_\-get\_\-size} (\hyperlink{group__mem__pool_ga0}{peak\_\-mem\_\-pool} pool) |
| 34 |
\begin{CompactList}\small\item\em Statistics: get total pointers count. \item\end{CompactList}\end{CompactItemize} |
| 35 |
|
| 36 |
|
| 37 |
\subsection{Function Documentation} |
| 38 |
\hypertarget{group__mem__pool_ga1}{ |
| 39 |
\index{mem_pool@{mem\_\-pool}!peak_mem_pool_create@{peak\_\-mem\_\-pool\_\-create}} |
| 40 |
\index{peak_mem_pool_create@{peak\_\-mem\_\-pool\_\-create}!mem_pool@{mem\_\-pool}} |
| 41 |
\subsubsection[peak\_\-mem\_\-pool\_\-create]{\setlength{\rightskip}{0pt plus 5cm}\hyperlink{group__mem__pool_ga0}{peak\_\-mem\_\-pool} peak\_\-mem\_\-pool\_\-create (int {\em object\_\-size}, int {\em log\_\-size})}} |
| 42 |
\label{group__mem__pool_ga1} |
| 43 |
|
| 44 |
|
| 45 |
Create a mem\_\-pool object. |
| 46 |
|
| 47 |
\begin{Desc} |
| 48 |
\item[Parameters:] |
| 49 |
\begin{description} |
| 50 |
\item[{\em object\_\-size}]Size of each object in the memory pool. This cannot be changed later. It's commonly {\tt sizeof}(struct your\_\-object\_\-structure). \item[{\em log\_\-size}]Log base 2 of the initial size of memory pool. Use 0 if you don't know, it will use the minimum.\end{description} |
| 51 |
\end{Desc} |
| 52 |
\begin{Desc} |
| 53 |
\item[Returns:]A new allocated {\tt peak\_\-mem\_\-pool} reference or {\tt NULL} if the operation failed. \end{Desc} |
| 54 |
\hypertarget{group__mem__pool_ga3}{ |
| 55 |
\index{mem_pool@{mem\_\-pool}!peak_mem_pool_delete@{peak\_\-mem\_\-pool\_\-delete}} |
| 56 |
\index{peak_mem_pool_delete@{peak\_\-mem\_\-pool\_\-delete}!mem_pool@{mem\_\-pool}} |
| 57 |
\subsubsection[peak\_\-mem\_\-pool\_\-delete]{\setlength{\rightskip}{0pt plus 5cm}void peak\_\-mem\_\-pool\_\-delete (\hyperlink{group__mem__pool_ga0}{peak\_\-mem\_\-pool} {\em pool}, void $\ast$ {\em ptr})}} |
| 58 |
\label{group__mem__pool_ga3} |
| 59 |
|
| 60 |
|
| 61 |
Deallocate an object in constant time. |
| 62 |
|
| 63 |
This method is guaranted O(1) but in rare case it might free a chunk of memory. |
| 64 |
|
| 65 |
\begin{Desc} |
| 66 |
\item[Parameters:] |
| 67 |
\begin{description} |
| 68 |
\item[{\em pool}]The memory pool reference. \item[{\em ptr}]The pointer to a memory space to deallocate. This pointer must have been previously provided by \hyperlink{group__mem__pool_ga9}{peak\_\-mem\_\-pool\_\-new()}. \end{description} |
| 69 |
\end{Desc} |
| 70 |
\hypertarget{group__mem__pool_ga5}{ |
| 71 |
\index{mem_pool@{mem\_\-pool}!peak_mem_pool_get_free_count@{peak\_\-mem\_\-pool\_\-get\_\-free\_\-count}} |
| 72 |
\index{peak_mem_pool_get_free_count@{peak\_\-mem\_\-pool\_\-get\_\-free\_\-count}!mem_pool@{mem\_\-pool}} |
| 73 |
\subsubsection[peak\_\-mem\_\-pool\_\-get\_\-free\_\-count]{\setlength{\rightskip}{0pt plus 5cm}int peak\_\-mem\_\-pool\_\-get\_\-free\_\-count (\hyperlink{group__mem__pool_ga0}{peak\_\-mem\_\-pool} {\em pool})}} |
| 74 |
\label{group__mem__pool_ga5} |
| 75 |
|
| 76 |
|
| 77 |
Statistics: get free pointers count. |
| 78 |
|
| 79 |
This method is guaranted O(1). |
| 80 |
|
| 81 |
\begin{Desc} |
| 82 |
\item[Parameters:] |
| 83 |
\begin{description} |
| 84 |
\item[{\em pool}]The memory pool reference.\end{description} |
| 85 |
\end{Desc} |
| 86 |
\begin{Desc} |
| 87 |
\item[Returns:]Number of pointer currently unused (free for allocation). \end{Desc} |
| 88 |
\hypertarget{group__mem__pool_ga6}{ |
| 89 |
\index{mem_pool@{mem\_\-pool}!peak_mem_pool_get_size@{peak\_\-mem\_\-pool\_\-get\_\-size}} |
| 90 |
\index{peak_mem_pool_get_size@{peak\_\-mem\_\-pool\_\-get\_\-size}!mem_pool@{mem\_\-pool}} |
| 91 |
\subsubsection[peak\_\-mem\_\-pool\_\-get\_\-size]{\setlength{\rightskip}{0pt plus 5cm}int peak\_\-mem\_\-pool\_\-get\_\-size (\hyperlink{group__mem__pool_ga0}{peak\_\-mem\_\-pool} {\em pool})}} |
| 92 |
\label{group__mem__pool_ga6} |
| 93 |
|
| 94 |
|
| 95 |
Statistics: get total pointers count. |
| 96 |
|
| 97 |
This method is guaranted O(1). |
| 98 |
|
| 99 |
\begin{Desc} |
| 100 |
\item[Parameters:] |
| 101 |
\begin{description} |
| 102 |
\item[{\em pool}]The memory pool reference.\end{description} |
| 103 |
\end{Desc} |
| 104 |
\begin{Desc} |
| 105 |
\item[Returns:]Size of all pointers really allocated by the memory pool. It grows automatically when no more free pointers are available, and also might eventually decrease if needed. \end{Desc} |
| 106 |
\hypertarget{group__mem__pool_ga4}{ |
| 107 |
\index{mem_pool@{mem\_\-pool}!peak_mem_pool_get_used_count@{peak\_\-mem\_\-pool\_\-get\_\-used\_\-count}} |
| 108 |
\index{peak_mem_pool_get_used_count@{peak\_\-mem\_\-pool\_\-get\_\-used\_\-count}!mem_pool@{mem\_\-pool}} |
| 109 |
\subsubsection[peak\_\-mem\_\-pool\_\-get\_\-used\_\-count]{\setlength{\rightskip}{0pt plus 5cm}int peak\_\-mem\_\-pool\_\-get\_\-used\_\-count (\hyperlink{group__mem__pool_ga0}{peak\_\-mem\_\-pool} {\em pool})}} |
| 110 |
\label{group__mem__pool_ga4} |
| 111 |
|
| 112 |
|
| 113 |
Statistics: get used pointers count. |
| 114 |
|
| 115 |
This method is guaranted O(1). |
| 116 |
|
| 117 |
\begin{Desc} |
| 118 |
\item[Parameters:] |
| 119 |
\begin{description} |
| 120 |
\item[{\em pool}]The memory pool reference.\end{description} |
| 121 |
\end{Desc} |
| 122 |
\begin{Desc} |
| 123 |
\item[Returns:]Number of pointer currently in use (allocated). \end{Desc} |
| 124 |
\hypertarget{group__mem__pool_ga2}{ |
| 125 |
\index{mem_pool@{mem\_\-pool}!peak_mem_pool_new@{peak\_\-mem\_\-pool\_\-new}} |
| 126 |
\index{peak_mem_pool_new@{peak\_\-mem\_\-pool\_\-new}!mem_pool@{mem\_\-pool}} |
| 127 |
\subsubsection[peak\_\-mem\_\-pool\_\-new]{\setlength{\rightskip}{0pt plus 5cm}void$\ast$ peak\_\-mem\_\-pool\_\-new (\hyperlink{group__mem__pool_ga0}{peak\_\-mem\_\-pool} {\em pool})}} |
| 128 |
\label{group__mem__pool_ga2} |
| 129 |
|
| 130 |
|
| 131 |
Allocate an object in constant time. |
| 132 |
|
| 133 |
This method is guaranted O(1) almost all the time, but in rare case it might allocate a chunk of memory to let the memory pool grow. |
| 134 |
|
| 135 |
\begin{Desc} |
| 136 |
\item[Parameters:] |
| 137 |
\begin{description} |
| 138 |
\item[{\em pool}]The memory pool reference.\end{description} |
| 139 |
\end{Desc} |
| 140 |
\begin{Desc} |
| 141 |
\item[Returns:]A pointer to {\em object\_\-size\/} bytes of memory. The allocated space is suitably aligned for storage of any common type of object. Please consult libpeak's compile time options to enable storage of special object like Altivec's vector (which needs 16-bytes align). Also please note the returned memory is NOT normally initialized to zero bytes. \end{Desc} |
