RubyGems - atk - Versions diffs - 0.90.5-x86-mingw32 → 0.90.6-x86-mingw32 - Mend

atk 0.90.5-x86-mingw32 → 0.90.6-x86-mingw32

Files changed (765) hide show

data/vendor/local/share/gtk-doc/html/glib/glib-Memory-Slices.html DELETED Viewed

@@ -1,510 +0,0 @@
-<!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.15.1 (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">
-<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">
-<a name="glib-Memory-Slices.synopsis"></a><h2>Synopsis</h2>
-<pre class="synopsis">
-#include &lt;glib.h&gt;
-<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">
-<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 &lt;= 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="id535463" href="#ftn.id535463" 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="id698541"></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="usertype">gchar</span><span class="normal"> </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="usertype">gint</span><span class="normal"> 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">&lt;</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">&lt;</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">&lt;</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="id772761"></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="usertype">GRealArray</span><span class="normal"> </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">-&gt;</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">-&gt;</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">-&gt;</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">-&gt;</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">-&gt;</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">-&gt;</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">
-<a name="glib-Memory-Slices.details"></a><h2>Details</h2>
-<div class="refsect2">
-<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">
-<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">
-<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">
-<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">
-<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">
-<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">
-<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">
-<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">
-<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">
-<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.id535463" href="#id535463" 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.15.1</div>
-</body>
-</html>