| <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> |
| <html> |
| <head> |
| <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> |
| <title>Memory Slices</title> |
| <meta name="generator" content="DocBook XSL Stylesheets V1.75.2"> |
| <link rel="home" href="index.html" title="GLib Reference Manual"> |
| <link rel="up" href="glib-data-types.html" title="GLib Data Types"> |
| <link rel="prev" href="glib-data-types.html" title="GLib Data Types"> |
| <link rel="next" href="glib-Memory-Chunks.html" title="Memory Chunks"> |
| <meta name="generator" content="GTK-Doc V1.14 (XML mode)"> |
| <link rel="stylesheet" href="style.css" type="text/css"> |
| </head> |
| <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> |
| <table class="navigation" id="top" width="100%" summary="Navigation header" cellpadding="2" cellspacing="2"> |
| <tr valign="middle"> |
| <td><a accesskey="p" href="glib-data-types.html"><img src="left.png" width="24" height="24" border="0" alt="Prev"></a></td> |
| <td><a accesskey="u" href="glib-data-types.html"><img src="up.png" width="24" height="24" border="0" alt="Up"></a></td> |
| <td><a accesskey="h" href="index.html"><img src="home.png" width="24" height="24" border="0" alt="Home"></a></td> |
| <th width="100%" align="center">GLib Reference Manual</th> |
| <td><a accesskey="n" href="glib-Memory-Chunks.html"><img src="right.png" width="24" height="24" border="0" alt="Next"></a></td> |
| </tr> |
| <tr><td colspan="5" class="shortcuts"> |
| <a href="#glib-Memory-Slices.synopsis" class="shortcut">Top</a> |
| | |
| <a href="#glib-Memory-Slices.description" class="shortcut">Description</a> |
| </td></tr> |
| </table> |
| <div class="refentry" title="Memory Slices"> |
| <a name="glib-Memory-Slices"></a><div class="titlepage"></div> |
| <div class="refnamediv"><table width="100%"><tr> |
| <td valign="top"> |
| <h2><span class="refentrytitle"><a name="glib-Memory-Slices.top_of_page"></a>Memory Slices</span></h2> |
| <p>Memory Slices — efficient way to allocate groups of equal-sized chunks of memory</p> |
| </td> |
| <td valign="top" align="right"></td> |
| </tr></table></div> |
| <div class="refsynopsisdiv" title="Synopsis"> |
| <a name="glib-Memory-Slices.synopsis"></a><h2>Synopsis</h2> |
| <pre class="synopsis"> |
| #include <glib.h> |
| |
| <a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a> <a class="link" href="glib-Memory-Slices.html#g-slice-alloc" title="g_slice_alloc ()">g_slice_alloc</a> (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> block_size</code></em>); |
| <a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a> <a class="link" href="glib-Memory-Slices.html#g-slice-alloc0" title="g_slice_alloc0 ()">g_slice_alloc0</a> (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> block_size</code></em>); |
| <a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a> <a class="link" href="glib-Memory-Slices.html#g-slice-copy" title="g_slice_copy ()">g_slice_copy</a> (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> block_size</code></em>, |
| <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gconstpointer" title="gconstpointer"><span class="type">gconstpointer</span></a> mem_block</code></em>); |
| <span class="returnvalue">void</span> <a class="link" href="glib-Memory-Slices.html#g-slice-free1" title="g_slice_free1 ()">g_slice_free1</a> (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> block_size</code></em>, |
| <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="type">gpointer</span></a> mem_block</code></em>); |
| <span class="returnvalue">void</span> <a class="link" href="glib-Memory-Slices.html#g-slice-free-chain-with-offset" title="g_slice_free_chain_with_offset ()">g_slice_free_chain_with_offset</a> (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> block_size</code></em>, |
| <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="type">gpointer</span></a> mem_chain</code></em>, |
| <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> next_offset</code></em>); |
| |
| #define <a class="link" href="glib-Memory-Slices.html#g-slice-new" title="g_slice_new()">g_slice_new</a> (type) |
| #define <a class="link" href="glib-Memory-Slices.html#g-slice-new0" title="g_slice_new0()">g_slice_new0</a> (type) |
| #define <a class="link" href="glib-Memory-Slices.html#g-slice-dup" title="g_slice_dup()">g_slice_dup</a> (type, |
| mem) |
| #define <a class="link" href="glib-Memory-Slices.html#g-slice-free" title="g_slice_free()">g_slice_free</a> (type, |
| mem) |
| #define <a class="link" href="glib-Memory-Slices.html#g-slice-free-chain" title="g_slice_free_chain()">g_slice_free_chain</a> (type, |
| mem_chain, |
| next) |
| </pre> |
| </div> |
| <div class="refsect1" title="Description"> |
| <a name="glib-Memory-Slices.description"></a><h2>Description</h2> |
| <p> |
| Memory slices provide a space-efficient and multi-processing scalable |
| way to allocate equal-sized pieces of memory, just like the original |
| <a href="glib-Memory-Chunks.html#GMemChunk"><span class="type">GMemChunks</span></a> (from GLib <= 2.8), while avoiding their excessive |
| memory-waste, scalability and performance problems. |
| </p> |
| <p> |
| To achieve these goals, the slice allocator uses a sophisticated, |
| layered design that has been inspired by Bonwick's slab allocator |
| <sup>[<a name="id437774" href="#ftn.id437774" class="footnote">6</a>]</sup>. |
| It uses <code class="function">posix_memalign()</code> to optimize allocations of many equally-sized |
| chunks, and has per-thread free lists (the so-called magazine layer) |
| to quickly satisfy allocation requests of already known structure sizes. |
| This is accompanied by extra caching logic to keep freed memory around |
| for some time before returning it to the system. Memory that is unused |
| due to alignment constraints is used for cache colorization (random |
| distribution of chunk addresses) to improve CPU cache utilization. The |
| caching layer of the slice allocator adapts itself to high lock contention |
| to improve scalability. |
| </p> |
| <p> |
| The slice allocator can allocate blocks as small as two pointers, and |
| unlike <code class="function">malloc()</code>, it does not reserve extra space per block. For large block |
| sizes, <a class="link" href="glib-Memory-Slices.html#g-slice-new" title="g_slice_new()"><code class="function">g_slice_new()</code></a> and <a class="link" href="glib-Memory-Slices.html#g-slice-alloc" title="g_slice_alloc ()"><code class="function">g_slice_alloc()</code></a> will automatically delegate to the |
| system <code class="function">malloc()</code> implementation. For newly written code it is recommended |
| to use the new <code class="literal">g_slice</code> API instead of <a class="link" href="glib-Memory-Allocation.html#g-malloc" title="g_malloc ()"><code class="function">g_malloc()</code></a> and |
| friends, as long as objects are not resized during their lifetime and the |
| object size used at allocation time is still available when freeing. |
| </p> |
| <div class="example"> |
| <a name="id657376"></a><p class="title"><b>Example 15. Using the slice allocator</b></p> |
| <div class="example-contents"> |
| <table class="listing_frame" border="0" cellpadding="0" cellspacing="0"> |
| <tbody> |
| <tr> |
| <td class="listing_lines" align="right"><pre>1 |
| 2 |
| 3 |
| 4 |
| 5 |
| 6 |
| 7 |
| 8 |
| 9 |
| 10 |
| 11 |
| 12 |
| 13 |
| 14 |
| 15</pre></td> |
| <td class="listing_code"><pre class="programlisting"><span class="normal"><a href="glib-Basic-Types.html#gchar">gchar</a> </span><span class="symbol">*</span><span class="normal">mem</span><span class="symbol">[</span><span class="number">10000</span><span class="symbol">];</span> |
| <span class="normal"><a href="glib-Basic-Types.html#gint">gint</a> i</span><span class="symbol">;</span> |
| <span class="comment">/* Allocate 10000 blocks. */</span> |
| <span class="keyword">for</span><span class="normal"> </span><span class="symbol">(</span><span class="normal">i </span><span class="symbol">=</span><span class="normal"> </span><span class="number">0</span><span class="symbol">;</span><span class="normal"> i </span><span class="symbol"><</span><span class="normal"> </span><span class="number">10000</span><span class="symbol">;</span><span class="normal"> i</span><span class="symbol">++)</span> |
| <span class="normal"> </span><span class="cbracket">{</span> |
| <span class="normal"> mem</span><span class="symbol">[</span><span class="normal">i</span><span class="symbol">]</span><span class="normal"> </span><span class="symbol">=</span><span class="normal"> </span><span class="function"><a href="glib-Memory-Slices.html#g-slice-alloc">g_slice_alloc</a></span><span class="normal"> </span><span class="symbol">(</span><span class="number">50</span><span class="symbol">);</span> |
| <span class="normal"> </span><span class="comment">/* Fill in the memory with some junk. */</span> |
| <span class="normal"> </span><span class="keyword">for</span><span class="normal"> </span><span class="symbol">(</span><span class="normal">j </span><span class="symbol">=</span><span class="normal"> </span><span class="number">0</span><span class="symbol">;</span><span class="normal"> j </span><span class="symbol"><</span><span class="normal"> </span><span class="number">50</span><span class="symbol">;</span><span class="normal"> j</span><span class="symbol">++)</span> |
| <span class="normal"> mem</span><span class="symbol">[</span><span class="normal">i</span><span class="symbol">][</span><span class="normal">j</span><span class="symbol">]</span><span class="normal"> </span><span class="symbol">=</span><span class="normal"> i </span><span class="symbol">*</span><span class="normal"> j</span><span class="symbol">;</span> |
| <span class="normal"> </span><span class="cbracket">}</span> |
| <span class="comment">/* Now free all of the blocks. */</span> |
| <span class="keyword">for</span><span class="normal"> </span><span class="symbol">(</span><span class="normal">i </span><span class="symbol">=</span><span class="normal"> </span><span class="number">0</span><span class="symbol">;</span><span class="normal"> i </span><span class="symbol"><</span><span class="normal"> </span><span class="number">10000</span><span class="symbol">;</span><span class="normal"> i</span><span class="symbol">++)</span> |
| <span class="normal"> </span><span class="cbracket">{</span> |
| <span class="normal"> </span><span class="function"><a href="glib-Memory-Slices.html#g-slice-free1">g_slice_free1</a></span><span class="normal"> </span><span class="symbol">(</span><span class="number">50</span><span class="symbol">,</span><span class="normal"> mem</span><span class="symbol">[</span><span class="normal">i</span><span class="symbol">]);</span> |
| <span class="normal"> </span><span class="cbracket">}</span></pre></td> |
| </tr> |
| </tbody> |
| </table> |
| </div> |
| |
| </div> |
| <br class="example-break"><div class="example"> |
| <a name="id580062"></a><p class="title"><b>Example 16. Using the slice allocator with data structures</b></p> |
| <div class="example-contents"> |
| <table class="listing_frame" border="0" cellpadding="0" cellspacing="0"> |
| <tbody> |
| <tr> |
| <td class="listing_lines" align="right"><pre>1 |
| 2 |
| 3 |
| 4 |
| 5 |
| 6 |
| 7 |
| 8 |
| 9 |
| 10 |
| 11 |
| 12</pre></td> |
| <td class="listing_code"><pre class="programlisting"><span class="normal">GRealArray </span><span class="symbol">*</span><span class="normal">array</span><span class="symbol">;</span> |
| <span class="comment">/* Allocate one block, using the g_slice_new() macro. */</span> |
| <span class="normal">array </span><span class="symbol">=</span><span class="normal"> </span><span class="function"><a href="glib-Memory-Slices.html#g-slice-new">g_slice_new</a></span><span class="normal"> </span><span class="symbol">(</span><span class="normal">GRealArray</span><span class="symbol">);</span> |
| <span class="comment">/* We can now use array just like a normal pointer to a structure. */</span> |
| <span class="normal">array</span><span class="symbol">-></span><span class="normal">data </span><span class="symbol">=</span><span class="normal"> <a href="glib-Standard-Macros.html#NULL:CAPS">NULL</a></span><span class="symbol">;</span> |
| <span class="normal">array</span><span class="symbol">-></span><span class="normal">len </span><span class="symbol">=</span><span class="normal"> </span><span class="number">0</span><span class="symbol">;</span> |
| <span class="normal">array</span><span class="symbol">-></span><span class="normal">alloc </span><span class="symbol">=</span><span class="normal"> </span><span class="number">0</span><span class="symbol">;</span> |
| <span class="normal">array</span><span class="symbol">-></span><span class="normal">zero_terminated </span><span class="symbol">=</span><span class="normal"> </span><span class="symbol">(</span><span class="normal">zero_terminated </span><span class="symbol">?</span><span class="normal"> </span><span class="number">1</span><span class="normal"> </span><span class="symbol">:</span><span class="normal"> </span><span class="number">0</span><span class="symbol">);</span> |
| <span class="normal">array</span><span class="symbol">-></span><span class="normal">clear </span><span class="symbol">=</span><span class="normal"> </span><span class="symbol">(</span><span class="normal">clear </span><span class="symbol">?</span><span class="normal"> </span><span class="number">1</span><span class="normal"> </span><span class="symbol">:</span><span class="normal"> </span><span class="number">0</span><span class="symbol">);</span> |
| <span class="normal">array</span><span class="symbol">-></span><span class="normal">elt_size </span><span class="symbol">=</span><span class="normal"> elt_size</span><span class="symbol">;</span> |
| <span class="comment">/* We can free the block, so it can be reused. */</span> |
| <span class="function"><a href="glib-Memory-Slices.html#g-slice-free">g_slice_free</a></span><span class="normal"> </span><span class="symbol">(</span><span class="normal">GRealArray</span><span class="symbol">,</span><span class="normal"> array</span><span class="symbol">);</span></pre></td> |
| </tr> |
| </tbody> |
| </table> |
| </div> |
| |
| </div> |
| <br class="example-break"> |
| </div> |
| <div class="refsect1" title="Details"> |
| <a name="glib-Memory-Slices.details"></a><h2>Details</h2> |
| <div class="refsect2" title="g_slice_alloc ()"> |
| <a name="g-slice-alloc"></a><h3>g_slice_alloc ()</h3> |
| <pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a> g_slice_alloc (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> block_size</code></em>);</pre> |
| <p> |
| Allocates a block of memory from the slice allocator. |
| The block adress handed out can be expected to be aligned |
| to at least <code class="literal">1 * sizeof (void*)</code>, |
| though in general slices are 2 * sizeof (void*) bytes aligned, |
| if a <code class="function">malloc()</code> fallback implementation is used instead, |
| the alignment may be reduced in a libc dependent fashion. |
| Note that the underlying slice allocation mechanism can |
| be changed with the <a class="link" href="glib-running.html#G_SLICE" title="G_SLICE">G_SLICE=always-malloc</a> |
| environment variable. |
| </p> |
| <div class="variablelist"><table border="0"> |
| <col align="left" valign="top"> |
| <tbody> |
| <tr> |
| <td><p><span class="term"><em class="parameter"><code>block_size</code></em> :</span></p></td> |
| <td>the number of bytes to allocate |
| </td> |
| </tr> |
| <tr> |
| <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td> |
| <td>a pointer to the allocated memory block |
| </td> |
| </tr> |
| </tbody> |
| </table></div> |
| <p class="since">Since 2.10</p> |
| </div> |
| <hr> |
| <div class="refsect2" title="g_slice_alloc0 ()"> |
| <a name="g-slice-alloc0"></a><h3>g_slice_alloc0 ()</h3> |
| <pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a> g_slice_alloc0 (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> block_size</code></em>);</pre> |
| <p> |
| Allocates a block of memory via <a class="link" href="glib-Memory-Slices.html#g-slice-alloc" title="g_slice_alloc ()"><code class="function">g_slice_alloc()</code></a> |
| and initialize the returned memory to 0. |
| Note that the underlying slice allocation mechanism can |
| be changed with the <a class="link" href="glib-running.html#G_SLICE" title="G_SLICE">G_SLICE=always-malloc</a> |
| environment variable. |
| </p> |
| <div class="variablelist"><table border="0"> |
| <col align="left" valign="top"> |
| <tbody> |
| <tr> |
| <td><p><span class="term"><em class="parameter"><code>block_size</code></em> :</span></p></td> |
| <td>the number of bytes to allocate |
| </td> |
| </tr> |
| <tr> |
| <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td> |
| <td>a pointer to the allocated block |
| </td> |
| </tr> |
| </tbody> |
| </table></div> |
| <p class="since">Since 2.10</p> |
| </div> |
| <hr> |
| <div class="refsect2" title="g_slice_copy ()"> |
| <a name="g-slice-copy"></a><h3>g_slice_copy ()</h3> |
| <pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a> g_slice_copy (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> block_size</code></em>, |
| <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gconstpointer" title="gconstpointer"><span class="type">gconstpointer</span></a> mem_block</code></em>);</pre> |
| <p> |
| Allocates a block of memory from the slice allocator and copies |
| <em class="parameter"><code>block_size</code></em> bytes into it from <em class="parameter"><code>mem_block</code></em>. |
| </p> |
| <div class="variablelist"><table border="0"> |
| <col align="left" valign="top"> |
| <tbody> |
| <tr> |
| <td><p><span class="term"><em class="parameter"><code>block_size</code></em> :</span></p></td> |
| <td>the number of bytes to allocate |
| </td> |
| </tr> |
| <tr> |
| <td><p><span class="term"><em class="parameter"><code>mem_block</code></em> :</span></p></td> |
| <td>the memory to copy |
| </td> |
| </tr> |
| <tr> |
| <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td> |
| <td>a pointer to the allocated memory block |
| </td> |
| </tr> |
| </tbody> |
| </table></div> |
| <p class="since">Since 2.14</p> |
| </div> |
| <hr> |
| <div class="refsect2" title="g_slice_free1 ()"> |
| <a name="g-slice-free1"></a><h3>g_slice_free1 ()</h3> |
| <pre class="programlisting"><span class="returnvalue">void</span> g_slice_free1 (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> block_size</code></em>, |
| <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="type">gpointer</span></a> mem_block</code></em>);</pre> |
| <p> |
| Frees a block of memory. The memory must have been allocated via |
| <a class="link" href="glib-Memory-Slices.html#g-slice-alloc" title="g_slice_alloc ()"><code class="function">g_slice_alloc()</code></a> or <a class="link" href="glib-Memory-Slices.html#g-slice-alloc0" title="g_slice_alloc0 ()"><code class="function">g_slice_alloc0()</code></a> |
| and the <em class="parameter"><code>block_size</code></em> has to match the size specified upon allocation. |
| Note that the exact release behaviour can be changed with the |
| <a class="link" href="glib-running.html#G_DEBUG" title="G_DEBUG">G_DEBUG=gc-friendly</a> environment variable, |
| also see <a class="link" href="glib-running.html#G_SLICE" title="G_SLICE">G_SLICE</a> for related debugging options. |
| </p> |
| <div class="variablelist"><table border="0"> |
| <col align="left" valign="top"> |
| <tbody> |
| <tr> |
| <td><p><span class="term"><em class="parameter"><code>block_size</code></em> :</span></p></td> |
| <td>the size of the block |
| </td> |
| </tr> |
| <tr> |
| <td><p><span class="term"><em class="parameter"><code>mem_block</code></em> :</span></p></td> |
| <td>a pointer to the block to free |
| </td> |
| </tr> |
| </tbody> |
| </table></div> |
| <p class="since">Since 2.10</p> |
| </div> |
| <hr> |
| <div class="refsect2" title="g_slice_free_chain_with_offset ()"> |
| <a name="g-slice-free-chain-with-offset"></a><h3>g_slice_free_chain_with_offset ()</h3> |
| <pre class="programlisting"><span class="returnvalue">void</span> g_slice_free_chain_with_offset (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> block_size</code></em>, |
| <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="type">gpointer</span></a> mem_chain</code></em>, |
| <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> next_offset</code></em>);</pre> |
| <p> |
| Frees a linked list of memory blocks of structure type <em class="parameter"><code>type</code></em>. |
| The memory blocks must be equal-sized, allocated via |
| <a class="link" href="glib-Memory-Slices.html#g-slice-alloc" title="g_slice_alloc ()"><code class="function">g_slice_alloc()</code></a> or <a class="link" href="glib-Memory-Slices.html#g-slice-alloc0" title="g_slice_alloc0 ()"><code class="function">g_slice_alloc0()</code></a> |
| and linked together by a <em class="parameter"><code>next</code></em> pointer (similar to <a class="link" href="glib-Singly-Linked-Lists.html#GSList" title="GSList"><span class="type">GSList</span></a>). The offset |
| of the <em class="parameter"><code>next</code></em> field in each block is passed as third argument. |
| Note that the exact release behaviour can be changed with the |
| <a class="link" href="glib-running.html#G_DEBUG" title="G_DEBUG">G_DEBUG=gc-friendly</a> environment variable, |
| also see <a class="link" href="glib-running.html#G_SLICE" title="G_SLICE">G_SLICE</a> for related debugging options. |
| </p> |
| <div class="variablelist"><table border="0"> |
| <col align="left" valign="top"> |
| <tbody> |
| <tr> |
| <td><p><span class="term"><em class="parameter"><code>block_size</code></em> :</span></p></td> |
| <td>the size of the blocks |
| </td> |
| </tr> |
| <tr> |
| <td><p><span class="term"><em class="parameter"><code>mem_chain</code></em> :</span></p></td> |
| <td> a pointer to the first block of the chain |
| </td> |
| </tr> |
| <tr> |
| <td><p><span class="term"><em class="parameter"><code>next_offset</code></em> :</span></p></td> |
| <td>the offset of the <em class="parameter"><code>next</code></em> field in the blocks |
| </td> |
| </tr> |
| </tbody> |
| </table></div> |
| <p class="since">Since 2.10</p> |
| </div> |
| <hr> |
| <div class="refsect2" title="g_slice_new()"> |
| <a name="g-slice-new"></a><h3>g_slice_new()</h3> |
| <pre class="programlisting">#define g_slice_new(type)</pre> |
| <p> |
| A convenience macro to allocate a block of memory from the slice allocator. |
| It calls <a class="link" href="glib-Memory-Slices.html#g-slice-alloc" title="g_slice_alloc ()"><code class="function">g_slice_alloc()</code></a> with <code class="literal">sizeof (<em class="parameter"><code>type</code></em>)</code> and casts |
| the returned pointer to a pointer of the given type, avoiding a type cast |
| in the source code. |
| Note that the underlying slice allocation mechanism can |
| be changed with the <a class="link" href="glib-running.html#G_SLICE" title="G_SLICE">G_SLICE=always-malloc</a> |
| environment variable. |
| </p> |
| <div class="variablelist"><table border="0"> |
| <col align="left" valign="top"> |
| <tbody> |
| <tr> |
| <td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td> |
| <td>the type to allocate, typically a structure name |
| </td> |
| </tr> |
| <tr> |
| <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td> |
| <td>a pointer to the allocated block, cast to a pointer to <em class="parameter"><code>type</code></em>. |
| </td> |
| </tr> |
| </tbody> |
| </table></div> |
| <p class="since">Since 2.10</p> |
| </div> |
| <hr> |
| <div class="refsect2" title="g_slice_new0()"> |
| <a name="g-slice-new0"></a><h3>g_slice_new0()</h3> |
| <pre class="programlisting">#define g_slice_new0(type)</pre> |
| <p> |
| A convenience macro to allocate a block of memory from the slice allocator |
| and set the memory to 0. It calls <a class="link" href="glib-Memory-Slices.html#g-slice-alloc0" title="g_slice_alloc0 ()"><code class="function">g_slice_alloc0()</code></a> with |
| <code class="literal">sizeof (<em class="parameter"><code>type</code></em>)</code> and casts the returned pointer to a pointer |
| of the given type, avoiding a type cast in the source code. |
| Note that the underlying slice allocation mechanism can |
| be changed with the <a class="link" href="glib-running.html#G_SLICE" title="G_SLICE">G_SLICE=always-malloc</a> |
| environment variable. |
| </p> |
| <div class="variablelist"><table border="0"> |
| <col align="left" valign="top"> |
| <tbody> |
| <tr> |
| <td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td> |
| <td>the type to allocate, typically a structure name |
| </td> |
| </tr> |
| <tr> |
| <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td> |
| <td>a pointer to the allocated block, cast to a pointer to <em class="parameter"><code>type</code></em>. |
| </td> |
| </tr> |
| </tbody> |
| </table></div> |
| <p class="since">Since 2.10</p> |
| </div> |
| <hr> |
| <div class="refsect2" title="g_slice_dup()"> |
| <a name="g-slice-dup"></a><h3>g_slice_dup()</h3> |
| <pre class="programlisting">#define g_slice_dup(type, mem)</pre> |
| <p> |
| A convenience macro to duplicate a block of memory using the slice allocator. |
| It calls <a class="link" href="glib-Memory-Slices.html#g-slice-copy" title="g_slice_copy ()"><code class="function">g_slice_copy()</code></a> with <code class="literal">sizeof (<em class="parameter"><code>type</code></em>)</code> and casts |
| the returned pointer to a pointer of the given type, avoiding a type cast |
| in the source code. |
| Note that the underlying slice allocation mechanism can |
| be changed with the <a class="link" href="glib-running.html#G_SLICE" title="G_SLICE">G_SLICE=always-malloc</a> |
| environment variable. |
| </p> |
| <div class="variablelist"><table border="0"> |
| <col align="left" valign="top"> |
| <tbody> |
| <tr> |
| <td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td> |
| <td>the type to duplicate, typically a structure name |
| </td> |
| </tr> |
| <tr> |
| <td><p><span class="term"><em class="parameter"><code>mem</code></em> :</span></p></td> |
| <td>the memory to copy into the allocated block |
| </td> |
| </tr> |
| <tr> |
| <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td> |
| <td>a pointer to the allocated block, cast to a pointer to <em class="parameter"><code>type</code></em>. |
| </td> |
| </tr> |
| </tbody> |
| </table></div> |
| <p class="since">Since 2.14</p> |
| </div> |
| <hr> |
| <div class="refsect2" title="g_slice_free()"> |
| <a name="g-slice-free"></a><h3>g_slice_free()</h3> |
| <pre class="programlisting">#define g_slice_free(type, mem)</pre> |
| <p> |
| A convenience macro to free a block of memory that has been allocated |
| from the slice allocator. It calls <a class="link" href="glib-Memory-Slices.html#g-slice-free1" title="g_slice_free1 ()"><code class="function">g_slice_free1()</code></a> using |
| <code class="literal">sizeof (type)</code> as the block size. |
| Note that the exact release behaviour can be changed with the |
| <a class="link" href="glib-running.html#G_DEBUG" title="G_DEBUG">G_DEBUG=gc-friendly</a> environment variable, |
| also see <a class="link" href="glib-running.html#G_SLICE" title="G_SLICE">G_SLICE</a> for related debugging options. |
| </p> |
| <div class="variablelist"><table border="0"> |
| <col align="left" valign="top"> |
| <tbody> |
| <tr> |
| <td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td> |
| <td>the type of the block to free, typically a structure name |
| </td> |
| </tr> |
| <tr> |
| <td><p><span class="term"><em class="parameter"><code>mem</code></em> :</span></p></td> |
| <td>a pointer to the block to free |
| </td> |
| </tr> |
| </tbody> |
| </table></div> |
| <p class="since">Since 2.10</p> |
| </div> |
| <hr> |
| <div class="refsect2" title="g_slice_free_chain()"> |
| <a name="g-slice-free-chain"></a><h3>g_slice_free_chain()</h3> |
| <pre class="programlisting">#define g_slice_free_chain(type, mem_chain, next)</pre> |
| <p> |
| Frees a linked list of memory blocks of structure type <em class="parameter"><code>type</code></em>. |
| The memory blocks must be equal-sized, allocated via |
| <a class="link" href="glib-Memory-Slices.html#g-slice-alloc" title="g_slice_alloc ()"><code class="function">g_slice_alloc()</code></a> or <a class="link" href="glib-Memory-Slices.html#g-slice-alloc0" title="g_slice_alloc0 ()"><code class="function">g_slice_alloc0()</code></a> and linked together by a |
| <em class="parameter"><code>next</code></em> pointer (similar to <a class="link" href="glib-Singly-Linked-Lists.html#GSList" title="GSList"><span class="type">GSList</span></a>). The name of the |
| <em class="parameter"><code>next</code></em> field in <em class="parameter"><code>type</code></em> is passed as third argument. |
| Note that the exact release behaviour can be changed with the |
| <a class="link" href="glib-running.html#G_DEBUG" title="G_DEBUG">G_DEBUG=gc-friendly</a> environment variable, |
| also see <a class="link" href="glib-running.html#G_SLICE" title="G_SLICE">G_SLICE</a> for related debugging options. |
| </p> |
| <div class="variablelist"><table border="0"> |
| <col align="left" valign="top"> |
| <tbody> |
| <tr> |
| <td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td> |
| <td> the type of the <em class="parameter"><code>mem_chain</code></em> blocks |
| </td> |
| </tr> |
| <tr> |
| <td><p><span class="term"><em class="parameter"><code>mem_chain</code></em> :</span></p></td> |
| <td> a pointer to the first block of the chain |
| </td> |
| </tr> |
| <tr> |
| <td><p><span class="term"><em class="parameter"><code>next</code></em> :</span></p></td> |
| <td> the field name of the next pointer in <em class="parameter"><code>type</code></em> |
| </td> |
| </tr> |
| </tbody> |
| </table></div> |
| <p class="since">Since 2.10</p> |
| </div> |
| </div> |
| <div class="footnotes"> |
| <br><hr width="100" align="left"> |
| <div class="footnote"><p><sup>[<a name="ftn.id437774" href="#id437774" class="para">6</a>] </sup> |
| <a class="ulink" href="http://citeseer.ist.psu.edu/bonwick94slab.html" target="_top">[Bonwick94]</a> Jeff Bonwick, The slab allocator: An object-caching kernel |
| memory allocator. USENIX 1994, and |
| <a class="ulink" href="http://citeseer.ist.psu.edu/bonwick01magazines.html" target="_top">[Bonwick01]</a> Bonwick and Jonathan Adams, Magazines and vmem: Extending the |
| slab allocator to many cpu's and arbitrary resources. USENIX 2001 |
| </p></div> |
| </div> |
| </div> |
| <div class="footer"> |
| <hr> |
| Generated by GTK-Doc V1.14</div> |
| </body> |
| </html> |
