docs/reference/glib/html/glib-Memory-Chunks.html

   1 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
   2 <html>
   3 <head>
   4 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
   5 <title>Memory Chunks</title>
   6 <meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
   7 <link rel="home" href="index.html" title="GLib Reference Manual">
   8 <link rel="up" href="glib-data-types.html" title="GLib Data Types">
   9 <link rel="prev" href="glib-Memory-Slices.html" title="Memory Slices">
  10 <link rel="next" href="glib-Doubly-Linked-Lists.html" title="Doubly-Linked Lists">
  11 <meta name="generator" content="GTK-Doc V1.13 (XML mode)">
  12 <link rel="stylesheet" href="style.css" type="text/css">
  13 <link rel="chapter" href="glib.html" title="GLib Overview">
  14 <link rel="chapter" href="glib-fundamentals.html" title="GLib Fundamentals">
  15 <link rel="chapter" href="glib-core.html" title="GLib Core Application Support">
  16 <link rel="chapter" href="glib-utilities.html" title="GLib Utilities">
  17 <link rel="chapter" href="glib-data-types.html" title="GLib Data Types">
  18 <link rel="chapter" href="tools.html" title="GLib Tools">
  19 <link rel="index" href="api-index-full.html" title="Index">
  20 <link rel="index" href="api-index-deprecated.html" title="Index of deprecated symbols">
  21 <link rel="index" href="api-index-2-2.html" title="Index of new symbols in 2.2">
  22 <link rel="index" href="api-index-2-4.html" title="Index of new symbols in 2.4">
  23 <link rel="index" href="api-index-2-6.html" title="Index of new symbols in 2.6">
  24 <link rel="index" href="api-index-2-8.html" title="Index of new symbols in 2.8">
  25 <link rel="index" href="api-index-2-10.html" title="Index of new symbols in 2.10">
  26 <link rel="index" href="api-index-2-12.html" title="Index of new symbols in 2.12">
  27 <link rel="index" href="api-index-2-14.html" title="Index of new symbols in 2.14">
  28 <link rel="index" href="api-index-2-16.html" title="Index of new symbols in 2.16">
  29 <link rel="index" href="api-index-2-18.html" title="Index of new symbols in 2.18">
  30 <link rel="index" href="api-index-2-20.html" title="Index of new symbols in 2.20">
  31 <link rel="index" href="api-index-2-22.html" title="Index of new symbols in 2.22">
  32 <link rel="index" href="api-index-2-24.html" title="Index of new symbols in 2.24">
  33 </head>
  34 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
  35 <table class="navigation" id="top" width="100%" summary="Navigation header" cellpadding="2" cellspacing="2">
  36 <tr valign="middle">
  37 <td><a accesskey="p" href="glib-Memory-Slices.html"><img src="left.png" width="24" height="24" border="0" alt="Prev"></a></td>
  38 <td><a accesskey="u" href="glib-data-types.html"><img src="up.png" width="24" height="24" border="0" alt="Up"></a></td>
  39 <td><a accesskey="h" href="index.html"><img src="home.png" width="24" height="24" border="0" alt="Home"></a></td>
  40 <th width="100%" align="center">GLib Reference Manual</th>
  41 <td><a accesskey="n" href="glib-Doubly-Linked-Lists.html"><img src="right.png" width="24" height="24" border="0" alt="Next"></a></td>
  42 </tr>
  43 <tr><td colspan="5" class="shortcuts">
  44 <a href="#glib-Memory-Chunks.synopsis" class="shortcut">Top</a>
  45                    |
  46                   <a href="#glib-Memory-Chunks.description" class="shortcut">Description</a>
  47 </td></tr>
  48 </table>
  49 <div class="refentry" title="Memory Chunks">
  50 <a name="glib-Memory-Chunks"></a><div class="titlepage"></div>
  51 <div class="refnamediv"><table width="100%"><tr>
  52 <td valign="top">
  53 <h2><span class="refentrytitle"><a name="glib-Memory-Chunks.top_of_page"></a>Memory Chunks</span></h2>
  54 <p>Memory Chunks — deprecated way to allocate groups of equal-sized
  55                     chunks of memory</p>
  56 </td>
  57 <td valign="top" align="right"></td>
  58 </tr></table></div>
  59 <div class="refsynopsisdiv" title="Synopsis">
  60 <a name="glib-Memory-Chunks.synopsis"></a><h2>Synopsis</h2>
  61 <pre class="synopsis">
  62 #include &lt;glib.h&gt;
  63
  64                     <a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk">GMemChunk</a>;
  65 #define             <a class="link" href="glib-Memory-Chunks.html#G-ALLOC-AND-FREE:CAPS" title="G_ALLOC_AND_FREE">G_ALLOC_AND_FREE</a>
  66 #define             <a class="link" href="glib-Memory-Chunks.html#G-ALLOC-ONLY:CAPS" title="G_ALLOC_ONLY">G_ALLOC_ONLY</a>
  67
  68 <a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="returnvalue">GMemChunk</span></a>*          <a class="link" href="glib-Memory-Chunks.html#g-mem-chunk-new" title="g_mem_chunk_new ()">g_mem_chunk_new</a>                     (const <a class="link" href="glib-Basic-Types.html#gchar" title="gchar"><span class="returnvalue">gchar</span></a> *name,
  69                                                          <a class="link" href="glib-Basic-Types.html#gint" title="gint"><span class="returnvalue">gint</span></a> atom_size,
  70                                                          <a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a> area_size,
  71                                                          <a class="link" href="glib-Basic-Types.html#gint" title="gint"><span class="returnvalue">gint</span></a> type);
  72 <a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            <a class="link" href="glib-Memory-Chunks.html#g-mem-chunk-alloc" title="g_mem_chunk_alloc ()">g_mem_chunk_alloc</a>                   (<a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="returnvalue">GMemChunk</span></a> *mem_chunk);
  73 <a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            <a class="link" href="glib-Memory-Chunks.html#g-mem-chunk-alloc0" title="g_mem_chunk_alloc0 ()">g_mem_chunk_alloc0</a>                  (<a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="returnvalue">GMemChunk</span></a> *mem_chunk);
  74 <span class="returnvalue">void</span>                <a class="link" href="glib-Memory-Chunks.html#g-mem-chunk-free" title="g_mem_chunk_free ()">g_mem_chunk_free</a>                    (<a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="returnvalue">GMemChunk</span></a> *mem_chunk,
  75                                                          <a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a> mem);
  76 <span class="returnvalue">void</span>                <a class="link" href="glib-Memory-Chunks.html#g-mem-chunk-destroy" title="g_mem_chunk_destroy ()">g_mem_chunk_destroy</a>                 (<a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="returnvalue">GMemChunk</span></a> *mem_chunk);
  77
  78 #define             <a class="link" href="glib-Memory-Chunks.html#g-mem-chunk-create" title="g_mem_chunk_create()">g_mem_chunk_create</a>                  (type, pre_alloc, alloc_type)
  79 #define             <a class="link" href="glib-Memory-Chunks.html#g-chunk-new" title="g_chunk_new()">g_chunk_new</a>                         (type, chunk)
  80 #define             <a class="link" href="glib-Memory-Chunks.html#g-chunk-new0" title="g_chunk_new0()">g_chunk_new0</a>                        (type, chunk)
  81 #define             <a class="link" href="glib-Memory-Chunks.html#g-chunk-free" title="g_chunk_free()">g_chunk_free</a>                        (mem, mem_chunk)
  82
  83 <span class="returnvalue">void</span>                <a class="link" href="glib-Memory-Chunks.html#g-mem-chunk-reset" title="g_mem_chunk_reset ()">g_mem_chunk_reset</a>                   (<a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="returnvalue">GMemChunk</span></a> *mem_chunk);
  84 <span class="returnvalue">void</span>                <a class="link" href="glib-Memory-Chunks.html#g-mem-chunk-clean" title="g_mem_chunk_clean ()">g_mem_chunk_clean</a>                   (<a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="returnvalue">GMemChunk</span></a> *mem_chunk);
  85 <span class="returnvalue">void</span>                <a class="link" href="glib-Memory-Chunks.html#g-blow-chunks" title="g_blow_chunks ()">g_blow_chunks</a>                       (void);
  86
  87 <span class="returnvalue">void</span>                <a class="link" href="glib-Memory-Chunks.html#g-mem-chunk-info" title="g_mem_chunk_info ()">g_mem_chunk_info</a>                    (void);
  88 <span class="returnvalue">void</span>                <a class="link" href="glib-Memory-Chunks.html#g-mem-chunk-print" title="g_mem_chunk_print ()">g_mem_chunk_print</a>                   (<a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="returnvalue">GMemChunk</span></a> *mem_chunk);
  89 </pre>
  90 </div>
  91 <div class="refsect1" title="Description">
  92 <a name="glib-Memory-Chunks.description"></a><h2>Description</h2>
  93 <p>
  94 Memory chunks provide an space-efficient way to allocate equal-sized
  95 pieces of memory, called atoms. However, due to the administrative
  96 overhead (in particular for <a class="link" href="glib-Memory-Chunks.html#G-ALLOC-AND-FREE:CAPS" title="G_ALLOC_AND_FREE"><span class="type">G_ALLOC_AND_FREE</span></a>, and when used from
  97 multiple threads), they are in practise often slower than direct use
  98 of <a class="link" href="glib-Memory-Allocation.html#g-malloc" title="g_malloc ()"><code class="function">g_malloc()</code></a>. Therefore, memory chunks have been deprecated in
  99 favor of the <a class="link" href="glib-Memory-Slices.html" title="Memory Slices">slice
 100 allocator</a>, which has been added in 2.10. All internal uses of
 101 memory chunks in GLib have been converted to the
 102 <code class="literal">g_slice</code> API.
 103 </p>
 104 <p>
 105 There are two types of memory chunks, <a class="link" href="glib-Memory-Chunks.html#G-ALLOC-ONLY:CAPS" title="G_ALLOC_ONLY"><span class="type">G_ALLOC_ONLY</span></a>, and
 106 <a class="link" href="glib-Memory-Chunks.html#G-ALLOC-AND-FREE:CAPS" title="G_ALLOC_AND_FREE"><span class="type">G_ALLOC_AND_FREE</span></a>. </p>
 107 <div class="itemizedlist"><ul class="itemizedlist" type="disc">
 108 <li class="listitem"><p> <a class="link" href="glib-Memory-Chunks.html#G-ALLOC-ONLY:CAPS" title="G_ALLOC_ONLY"><span class="type">G_ALLOC_ONLY</span></a>
 109 chunks only allow allocation of atoms. The atoms can never be freed
 110 individually. The memory chunk can only be free in its entirety.
 111 </p></li>
 112 <li class="listitem"><p> <a class="link" href="glib-Memory-Chunks.html#G-ALLOC-AND-FREE:CAPS" title="G_ALLOC_AND_FREE"><span class="type">G_ALLOC_AND_FREE</span></a> chunks do
 113 allow atoms to be freed individually. The disadvantage of this is
 114 that the memory chunk has to keep track of which atoms have been
 115 freed. This results in more memory being used and a slight
 116 degradation in performance. </p></li>
 117 </ul></div>
 118 <p>
 119 </p>
 120 <p>
 121 To create a memory chunk use <a class="link" href="glib-Memory-Chunks.html#g-mem-chunk-new" title="g_mem_chunk_new ()"><code class="function">g_mem_chunk_new()</code></a> or the convenience
 122 macro <a class="link" href="glib-Memory-Chunks.html#g-mem-chunk-create" title="g_mem_chunk_create()"><code class="function">g_mem_chunk_create()</code></a>.
 123 </p>
 124 <p>
 125 To allocate a new atom use <a class="link" href="glib-Memory-Chunks.html#g-mem-chunk-alloc" title="g_mem_chunk_alloc ()"><code class="function">g_mem_chunk_alloc()</code></a>,
 126 <a class="link" href="glib-Memory-Chunks.html#g-mem-chunk-alloc0" title="g_mem_chunk_alloc0 ()"><code class="function">g_mem_chunk_alloc0()</code></a>, or the convenience macros <a class="link" href="glib-Memory-Chunks.html#g-chunk-new" title="g_chunk_new()"><code class="function">g_chunk_new()</code></a> or
 127 <a class="link" href="glib-Memory-Chunks.html#g-chunk-new0" title="g_chunk_new0()"><code class="function">g_chunk_new0()</code></a>.
 128 </p>
 129 <p>
 130 To free an atom use <a class="link" href="glib-Memory-Chunks.html#g-mem-chunk-free" title="g_mem_chunk_free ()"><code class="function">g_mem_chunk_free()</code></a>, or the convenience macro
 131 <a class="link" href="glib-Memory-Chunks.html#g-chunk-free" title="g_chunk_free()"><code class="function">g_chunk_free()</code></a>. (Atoms can only be freed if the memory chunk is
 132 created with the type set to <a class="link" href="glib-Memory-Chunks.html#G-ALLOC-AND-FREE:CAPS" title="G_ALLOC_AND_FREE"><span class="type">G_ALLOC_AND_FREE</span></a>.)
 133 </p>
 134 <p>
 135 To free any blocks of memory which are no longer being used, use
 136 <a class="link" href="glib-Memory-Chunks.html#g-mem-chunk-clean" title="g_mem_chunk_clean ()"><code class="function">g_mem_chunk_clean()</code></a>. To clean all memory chunks, use <a class="link" href="glib-Memory-Chunks.html#g-blow-chunks" title="g_blow_chunks ()"><code class="function">g_blow_chunks()</code></a>.
 137 </p>
 138 <p>
 139 To reset the memory chunk, freeing all of the atoms, use
 140 <a class="link" href="glib-Memory-Chunks.html#g-mem-chunk-reset" title="g_mem_chunk_reset ()"><code class="function">g_mem_chunk_reset()</code></a>.
 141 </p>
 142 <p>
 143 To destroy a memory chunk, use <a class="link" href="glib-Memory-Chunks.html#g-mem-chunk-destroy" title="g_mem_chunk_destroy ()"><code class="function">g_mem_chunk_destroy()</code></a>.
 144 </p>
 145 <p>
 146 To help debug memory chunks, use <a class="link" href="glib-Memory-Chunks.html#g-mem-chunk-info" title="g_mem_chunk_info ()"><code class="function">g_mem_chunk_info()</code></a> and
 147 <a class="link" href="glib-Memory-Chunks.html#g-mem-chunk-print" title="g_mem_chunk_print ()"><code class="function">g_mem_chunk_print()</code></a>.
 148 </p>
 149 <p>
 150 </p>
 151 <div class="example">
 152 <a name="id594507"></a><p class="title"><b>Example 17. Using a <a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="type">GMemChunk</span></a></b></p>
 153 <div class="example-contents"><pre class="programlisting">
 154   GMemChunk *mem_chunk;
 155   gchar *mem[10000];
 156   gint i;
 157
 158   /* Create a GMemChunk with atoms 50 bytes long, and memory
 159      blocks holding 100 bytes. Note that this means that only 2 atoms
 160      fit into each memory block and so isn't very efficient. */
 161   mem_chunk = g_mem_chunk_new ("test mem chunk", 50, 100, G_ALLOC_AND_FREE);
 162   /* Now allocate 10000 atoms. */
 163   for (i = 0; i &lt; 10000; i++)
 164     {
 165       mem[i] = g_chunk_new (gchar, mem_chunk);
 166       /* Fill in the atom memory with some junk. */
 167       for (j = 0; j &lt; 50; j++)
 168         mem[i][j] = i * j;
 169     }
 170   /* Now free all of the atoms. Note that since we are going to
 171      destroy the GMemChunk, this wouldn't normally be used. */
 172   for (i = 0; i &lt; 10000; i++)
 173     {
 174       g_mem_chunk_free (mem_chunk, mem[i]);
 175     }
 176   /* We are finished with the GMemChunk, so we destroy it. */
 177   g_mem_chunk_destroy (mem_chunk);
 178  </pre></div>
 179 </div>
 180 <p><br class="example-break">
 181 </p>
 182 <p>
 183 </p>
 184 <div class="example">
 185 <a name="id671836"></a><p class="title"><b>Example 18. Using a <a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="type">GMemChunk</span></a> with data structures</b></p>
 186 <div class="example-contents"><pre class="programlisting">
 187    GMemChunk *array_mem_chunk;
 188    GRealArray *array;
 189    /* Create a GMemChunk to hold GRealArray structures, using
 190       the g_mem_chunk_create() convenience macro. We want 1024 atoms in each
 191       memory block, and we want to be able to free individual atoms. */
 192    array_mem_chunk = g_mem_chunk_create (GRealArray, 1024, G_ALLOC_AND_FREE);
 193    /* Allocate one atom, using the g_chunk_new() convenience macro. */
 194    array = g_chunk_new (GRealArray, array_mem_chunk);
 195    /* We can now use array just like a normal pointer to a structure. */
 196    array-&gt;data            = NULL;
 197    array-&gt;len             = 0;
 198    array-&gt;alloc           = 0;
 199    array-&gt;zero_terminated = (zero_terminated ? 1 : 0);
 200    array-&gt;clear           = (clear ? 1 : 0);
 201    array-&gt;elt_size        = elt_size;
 202    /* We can free the element, so it can be reused. */
 203    g_chunk_free (array, array_mem_chunk);
 204    /* We destroy the GMemChunk when we are finished with it. */
 205    g_mem_chunk_destroy (array_mem_chunk);
 206  </pre></div>
 207 </div>
 208 <p><br class="example-break"></p>
 209 </div>
 210 <div class="refsect1" title="Details">
 211 <a name="glib-Memory-Chunks.details"></a><h2>Details</h2>
 212 <div class="refsect2" title="GMemChunk">
 213 <a name="GMemChunk"></a><h3>GMemChunk</h3>
 214 <pre class="programlisting">typedef struct _GMemChunk GMemChunk;</pre>
 215 <div class="warning" title="Warning" style="margin-left: 0.5in; margin-right: 0.5in;">
 216 <h3 class="title">Warning</h3>
 217 <p><code class="literal">GMemChunk</code> is deprecated and should not be used in newly-written code.</p>
 218 </div>
 219 <p>
 220 The <a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="type">GMemChunk</span></a> struct is an opaque data structure representing a
 221 memory chunk. It should be accessed only through the use of the
 222 following functions.</p>
 223 </div>
 224 <hr>
 225 <div class="refsect2" title="G_ALLOC_AND_FREE">
 226 <a name="G-ALLOC-AND-FREE:CAPS"></a><h3>G_ALLOC_AND_FREE</h3>
 227 <pre class="programlisting">#define G_ALLOC_AND_FREE  2
 228 </pre>
 229 <div class="warning" title="Warning" style="margin-left: 0.5in; margin-right: 0.5in;">
 230 <h3 class="title">Warning</h3>
 231 <p><code class="literal">G_ALLOC_AND_FREE</code> is deprecated and should not be used in newly-written code.</p>
 232 </div>
 233 <p>
 234 Specifies the type of a <a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="type">GMemChunk</span></a>. Used in <a class="link" href="glib-Memory-Chunks.html#g-mem-chunk-new" title="g_mem_chunk_new ()"><code class="function">g_mem_chunk_new()</code></a> and
 235 <a class="link" href="glib-Memory-Chunks.html#g-mem-chunk-create" title="g_mem_chunk_create()"><code class="function">g_mem_chunk_create()</code></a> to specify that atoms will be freed
 236 individually.</p>
 237 </div>
 238 <hr>
 239 <div class="refsect2" title="G_ALLOC_ONLY">
 240 <a name="G-ALLOC-ONLY:CAPS"></a><h3>G_ALLOC_ONLY</h3>
 241 <pre class="programlisting">#define G_ALLOC_ONLY          1
 242 </pre>
 243 <div class="warning" title="Warning" style="margin-left: 0.5in; margin-right: 0.5in;">
 244 <h3 class="title">Warning</h3>
 245 <p><code class="literal">G_ALLOC_ONLY</code> is deprecated and should not be used in newly-written code.</p>
 246 </div>
 247 <p>
 248 Specifies the type of a <a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="type">GMemChunk</span></a>. Used in <a class="link" href="glib-Memory-Chunks.html#g-mem-chunk-new" title="g_mem_chunk_new ()"><code class="function">g_mem_chunk_new()</code></a> and
 249 <a class="link" href="glib-Memory-Chunks.html#g-mem-chunk-create" title="g_mem_chunk_create()"><code class="function">g_mem_chunk_create()</code></a> to specify that atoms will never be freed
 250 individually.</p>
 251 </div>
 252 <hr>
 253 <div class="refsect2" title="g_mem_chunk_new ()">
 254 <a name="g-mem-chunk-new"></a><h3>g_mem_chunk_new ()</h3>
 255 <pre class="programlisting"><a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="returnvalue">GMemChunk</span></a>*          g_mem_chunk_new                     (const <a class="link" href="glib-Basic-Types.html#gchar" title="gchar"><span class="returnvalue">gchar</span></a> *name,
 256                                                          <a class="link" href="glib-Basic-Types.html#gint" title="gint"><span class="returnvalue">gint</span></a> atom_size,
 257                                                          <a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a> area_size,
 258                                                          <a class="link" href="glib-Basic-Types.html#gint" title="gint"><span class="returnvalue">gint</span></a> type);</pre>
 259 <div class="warning" title="Warning" style="margin-left: 0.5in; margin-right: 0.5in;">
 260 <h3 class="title">Warning</h3>
 261 <p><code class="literal">g_mem_chunk_new</code> has been deprecated since version 2.10 and should not be used in newly-written code. Use the <a class="link" href="glib-Memory-Slices.html" title="Memory Slices">slice
 262                  allocator</a> instead</p>
 263 </div>
 264 <p>
 265 Creates a new <a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="type">GMemChunk</span></a>.</p>
 266 <div class="variablelist"><table border="0">
 267 <col align="left" valign="top">
 268 <tbody>
 269 <tr>
 270 <td><p><span class="term"><em class="parameter"><code>name</code></em> :</span></p></td>
 271 <td> a string to identify the <a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="type">GMemChunk</span></a>. It is not copied so it
 272        should be valid for the lifetime of the <a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="type">GMemChunk</span></a>. It is
 273        only used in <a class="link" href="glib-Memory-Chunks.html#g-mem-chunk-print" title="g_mem_chunk_print ()"><code class="function">g_mem_chunk_print()</code></a>, which is used for debugging.
 274 </td>
 275 </tr>
 276 <tr>
 277 <td><p><span class="term"><em class="parameter"><code>atom_size</code></em> :</span></p></td>
 278 <td> the size, in bytes, of each element in the <a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="type">GMemChunk</span></a>.
 279 </td>
 280 </tr>
 281 <tr>
 282 <td><p><span class="term"><em class="parameter"><code>area_size</code></em> :</span></p></td>
 283 <td> the size, in bytes, of each block of memory allocated to
 284             contain the atoms.
 285 </td>
 286 </tr>
 287 <tr>
 288 <td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td>
 289 <td> the type of the <a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="type">GMemChunk</span></a>.  <a class="link" href="glib-Memory-Chunks.html#G-ALLOC-AND-FREE:CAPS" title="G_ALLOC_AND_FREE"><span class="type">G_ALLOC_AND_FREE</span></a> is used if the
 290        atoms will be freed individually.  <a class="link" href="glib-Memory-Chunks.html#G-ALLOC-ONLY:CAPS" title="G_ALLOC_ONLY"><span class="type">G_ALLOC_ONLY</span></a> should be
 291        used if atoms will never be freed individually.
 292        <a class="link" href="glib-Memory-Chunks.html#G-ALLOC-ONLY:CAPS" title="G_ALLOC_ONLY"><span class="type">G_ALLOC_ONLY</span></a> is quicker, since it does not need to track
 293        free atoms, but it obviously wastes memory if you no longer
 294        need many of the atoms.
 295 </td>
 296 </tr>
 297 <tr>
 298 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
 299 <td> the new <a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="type">GMemChunk</span></a>.
 300 </td>
 301 </tr>
 302 </tbody>
 303 </table></div>
 304 </div>
 305 <hr>
 306 <div class="refsect2" title="g_mem_chunk_alloc ()">
 307 <a name="g-mem-chunk-alloc"></a><h3>g_mem_chunk_alloc ()</h3>
 308 <pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            g_mem_chunk_alloc                   (<a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="returnvalue">GMemChunk</span></a> *mem_chunk);</pre>
 309 <div class="warning" title="Warning" style="margin-left: 0.5in; margin-right: 0.5in;">
 310 <h3 class="title">Warning</h3>
 311 <p><code class="literal">g_mem_chunk_alloc</code> has been deprecated since version 2.10 and should not be used in newly-written code. Use <a class="link" href="glib-Memory-Slices.html#g-slice-alloc" title="g_slice_alloc ()"><code class="function">g_slice_alloc()</code></a> instead</p>
 312 </div>
 313 <p>
 314 Allocates an atom of memory from a <a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="type">GMemChunk</span></a>.</p>
 315 <div class="variablelist"><table border="0">
 316 <col align="left" valign="top">
 317 <tbody>
 318 <tr>
 319 <td><p><span class="term"><em class="parameter"><code>mem_chunk</code></em> :</span></p></td>
 320 <td> a <a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="type">GMemChunk</span></a>.
 321 </td>
 322 </tr>
 323 <tr>
 324 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
 325 <td> a pointer to the allocated atom.
 326 </td>
 327 </tr>
 328 </tbody>
 329 </table></div>
 330 </div>
 331 <hr>
 332 <div class="refsect2" title="g_mem_chunk_alloc0 ()">
 333 <a name="g-mem-chunk-alloc0"></a><h3>g_mem_chunk_alloc0 ()</h3>
 334 <pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            g_mem_chunk_alloc0                  (<a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="returnvalue">GMemChunk</span></a> *mem_chunk);</pre>
 335 <div class="warning" title="Warning" style="margin-left: 0.5in; margin-right: 0.5in;">
 336 <h3 class="title">Warning</h3>
 337 <p><code class="literal">g_mem_chunk_alloc0</code> has been deprecated since version 2.10 and should not be used in newly-written code. Use <a class="link" href="glib-Memory-Slices.html#g-slice-alloc0" title="g_slice_alloc0 ()"><code class="function">g_slice_alloc0()</code></a> instead</p>
 338 </div>
 339 <p>
 340 Allocates an atom of memory from a <a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="type">GMemChunk</span></a>, setting the memory to
 341 0.</p>
 342 <div class="variablelist"><table border="0">
 343 <col align="left" valign="top">
 344 <tbody>
 345 <tr>
 346 <td><p><span class="term"><em class="parameter"><code>mem_chunk</code></em> :</span></p></td>
 347 <td> a <a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="type">GMemChunk</span></a>.
 348 </td>
 349 </tr>
 350 <tr>
 351 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
 352 <td> a pointer to the allocated atom.
 353 </td>
 354 </tr>
 355 </tbody>
 356 </table></div>
 357 </div>
 358 <hr>
 359 <div class="refsect2" title="g_mem_chunk_free ()">
 360 <a name="g-mem-chunk-free"></a><h3>g_mem_chunk_free ()</h3>
 361 <pre class="programlisting"><span class="returnvalue">void</span>                g_mem_chunk_free                    (<a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="returnvalue">GMemChunk</span></a> *mem_chunk,
 362                                                          <a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a> mem);</pre>
 363 <div class="warning" title="Warning" style="margin-left: 0.5in; margin-right: 0.5in;">
 364 <h3 class="title">Warning</h3>
 365 <p><code class="literal">g_mem_chunk_free</code> has been deprecated since version 2.10 and should not be used in newly-written code. Use <a class="link" href="glib-Memory-Slices.html#g-slice-free1" title="g_slice_free1 ()"><code class="function">g_slice_free1()</code></a> instead</p>
 366 </div>
 367 <p>
 368 Frees an atom in a <a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="type">GMemChunk</span></a>. This should only be called if the
 369 <a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="type">GMemChunk</span></a> was created with <a class="link" href="glib-Memory-Chunks.html#G-ALLOC-AND-FREE:CAPS" title="G_ALLOC_AND_FREE"><span class="type">G_ALLOC_AND_FREE</span></a>. Otherwise it will
 370 simply return.</p>
 371 <div class="variablelist"><table border="0">
 372 <col align="left" valign="top">
 373 <tbody>
 374 <tr>
 375 <td><p><span class="term"><em class="parameter"><code>mem_chunk</code></em> :</span></p></td>
 376 <td> a <a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="type">GMemChunk</span></a>.
 377 </td>
 378 </tr>
 379 <tr>
 380 <td><p><span class="term"><em class="parameter"><code>mem</code></em> :</span></p></td>
 381 <td> a pointer to the atom to free.
 382 </td>
 383 </tr>
 384 </tbody>
 385 </table></div>
 386 </div>
 387 <hr>
 388 <div class="refsect2" title="g_mem_chunk_destroy ()">
 389 <a name="g-mem-chunk-destroy"></a><h3>g_mem_chunk_destroy ()</h3>
 390 <pre class="programlisting"><span class="returnvalue">void</span>                g_mem_chunk_destroy                 (<a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="returnvalue">GMemChunk</span></a> *mem_chunk);</pre>
 391 <div class="warning" title="Warning" style="margin-left: 0.5in; margin-right: 0.5in;">
 392 <h3 class="title">Warning</h3>
 393 <p><code class="literal">g_mem_chunk_destroy</code> has been deprecated since version 2.10 and should not be used in newly-written code. Use the <a class="link" href="glib-Memory-Slices.html" title="Memory Slices">slice
 394                  allocator</a> instead</p>
 395 </div>
 396 <p>
 397 Frees all of the memory allocated for a <a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="type">GMemChunk</span></a>.</p>
 398 <div class="variablelist"><table border="0">
 399 <col align="left" valign="top">
 400 <tbody><tr>
 401 <td><p><span class="term"><em class="parameter"><code>mem_chunk</code></em> :</span></p></td>
 402 <td> a <a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="type">GMemChunk</span></a>.
 403 </td>
 404 </tr></tbody>
 405 </table></div>
 406 </div>
 407 <hr>
 408 <div class="refsect2" title="g_mem_chunk_create()">
 409 <a name="g-mem-chunk-create"></a><h3>g_mem_chunk_create()</h3>
 410 <pre class="programlisting">#define             g_mem_chunk_create(type, pre_alloc, alloc_type)</pre>
 411 <div class="warning" title="Warning" style="margin-left: 0.5in; margin-right: 0.5in;">
 412 <h3 class="title">Warning</h3>
 413 <p><code class="literal">g_mem_chunk_create</code> has been deprecated since version 2.10 and should not be used in newly-written code. Use the <a class="link" href="glib-Memory-Slices.html" title="Memory Slices">slice
 414                  allocator</a> instead</p>
 415 </div>
 416 <p>
 417 A convenience macro for creating a new <a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="type">GMemChunk</span></a>. It calls
 418 <a class="link" href="glib-Memory-Chunks.html#g-mem-chunk-new" title="g_mem_chunk_new ()"><code class="function">g_mem_chunk_new()</code></a>, using the given type to create the <a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="type">GMemChunk</span></a>
 419 name. The atom size is determined using
 420 <code class="function"><code class="function">sizeof()</code></code>, and the area size is calculated by
 421 multiplying the <em class="parameter"><code>pre_alloc</code></em> parameter with the atom size.</p>
 422 <div class="variablelist"><table border="0">
 423 <col align="left" valign="top">
 424 <tbody>
 425 <tr>
 426 <td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td>
 427 <td> the type of the atoms, typically a structure name.
 428 </td>
 429 </tr>
 430 <tr>
 431 <td><p><span class="term"><em class="parameter"><code>pre_alloc</code></em> :</span></p></td>
 432 <td> the number of atoms to store in each block of memory.
 433 </td>
 434 </tr>
 435 <tr>
 436 <td><p><span class="term"><em class="parameter"><code>alloc_type</code></em> :</span></p></td>
 437 <td> the type of the <a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="type">GMemChunk</span></a>.  <a class="link" href="glib-Memory-Chunks.html#G-ALLOC-AND-FREE:CAPS" title="G_ALLOC_AND_FREE"><span class="type">G_ALLOC_AND_FREE</span></a> is used
 438              if the atoms will be freed individually.  <a class="link" href="glib-Memory-Chunks.html#G-ALLOC-ONLY:CAPS" title="G_ALLOC_ONLY"><span class="type">G_ALLOC_ONLY</span></a>
 439              should be used if atoms will never be freed
 440              individually.  <a class="link" href="glib-Memory-Chunks.html#G-ALLOC-ONLY:CAPS" title="G_ALLOC_ONLY"><span class="type">G_ALLOC_ONLY</span></a> is quicker, since it does
 441              not need to track free atoms, but it obviously wastes
 442              memory if you no longer need many of the atoms.
 443 </td>
 444 </tr>
 445 <tr>
 446 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
 447 <td> the new <a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="type">GMemChunk</span></a>.
 448 </td>
 449 </tr>
 450 </tbody>
 451 </table></div>
 452 </div>
 453 <hr>
 454 <div class="refsect2" title="g_chunk_new()">
 455 <a name="g-chunk-new"></a><h3>g_chunk_new()</h3>
 456 <pre class="programlisting">#define             g_chunk_new(type, chunk)</pre>
 457 <div class="warning" title="Warning" style="margin-left: 0.5in; margin-right: 0.5in;">
 458 <h3 class="title">Warning</h3>
 459 <p><code class="literal">g_chunk_new</code> has been deprecated since version 2.10 and should not be used in newly-written code. Use <a class="link" href="glib-Memory-Slices.html#g-slice-new" title="g_slice_new()"><code class="function">g_slice_new()</code></a> instead</p>
 460 </div>
 461 <p>
 462 A convenience macro to allocate an atom of memory from a <a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="type">GMemChunk</span></a>.
 463 It calls <a class="link" href="glib-Memory-Chunks.html#g-mem-chunk-alloc" title="g_mem_chunk_alloc ()"><code class="function">g_mem_chunk_alloc()</code></a> and casts the returned atom to a
 464 pointer to the given type, avoiding a type cast in the source code.</p>
 465 <div class="variablelist"><table border="0">
 466 <col align="left" valign="top">
 467 <tbody>
 468 <tr>
 469 <td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td>
 470 <td> the type of the <a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="type">GMemChunk</span></a> atoms, typically a structure name.
 471 </td>
 472 </tr>
 473 <tr>
 474 <td><p><span class="term"><em class="parameter"><code>chunk</code></em> :</span></p></td>
 475 <td> a <a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="type">GMemChunk</span></a>.
 476 </td>
 477 </tr>
 478 <tr>
 479 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
 480 <td> a pointer to the allocated atom, cast to a pointer to
 481           <em class="parameter"><code>type</code></em>.
 482 </td>
 483 </tr>
 484 </tbody>
 485 </table></div>
 486 </div>
 487 <hr>
 488 <div class="refsect2" title="g_chunk_new0()">
 489 <a name="g-chunk-new0"></a><h3>g_chunk_new0()</h3>
 490 <pre class="programlisting">#define             g_chunk_new0(type, chunk)</pre>
 491 <div class="warning" title="Warning" style="margin-left: 0.5in; margin-right: 0.5in;">
 492 <h3 class="title">Warning</h3>
 493 <p><code class="literal">g_chunk_new0</code> has been deprecated since version 2.10 and should not be used in newly-written code. Use <a class="link" href="glib-Memory-Slices.html#g-slice-new0" title="g_slice_new0()"><code class="function">g_slice_new0()</code></a> instead</p>
 494 </div>
 495 <p>
 496 A convenience macro to allocate an atom of memory from a <a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="type">GMemChunk</span></a>.
 497 It calls <a class="link" href="glib-Memory-Chunks.html#g-mem-chunk-alloc0" title="g_mem_chunk_alloc0 ()"><code class="function">g_mem_chunk_alloc0()</code></a> and casts the returned atom to a
 498 pointer to the given type, avoiding a type cast in the source code.</p>
 499 <div class="variablelist"><table border="0">
 500 <col align="left" valign="top">
 501 <tbody>
 502 <tr>
 503 <td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td>
 504 <td> the type of the <a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="type">GMemChunk</span></a> atoms, typically a structure name.
 505 </td>
 506 </tr>
 507 <tr>
 508 <td><p><span class="term"><em class="parameter"><code>chunk</code></em> :</span></p></td>
 509 <td> a <a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="type">GMemChunk</span></a>.
 510 </td>
 511 </tr>
 512 <tr>
 513 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
 514 <td> a pointer to the allocated atom, cast to a pointer to
 515           <em class="parameter"><code>type</code></em>.
 516 </td>
 517 </tr>
 518 </tbody>
 519 </table></div>
 520 </div>
 521 <hr>
 522 <div class="refsect2" title="g_chunk_free()">
 523 <a name="g-chunk-free"></a><h3>g_chunk_free()</h3>
 524 <pre class="programlisting">#define             g_chunk_free(mem, mem_chunk)</pre>
 525 <div class="warning" title="Warning" style="margin-left: 0.5in; margin-right: 0.5in;">
 526 <h3 class="title">Warning</h3>
 527 <p><code class="literal">g_chunk_free</code> has been deprecated since version 2.10 and should not be used in newly-written code. Use <a class="link" href="glib-Memory-Slices.html#g-slice-free" title="g_slice_free()"><code class="function">g_slice_free()</code></a> instead</p>
 528 </div>
 529 <p>
 530 A convenience macro to free an atom of memory from a <a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="type">GMemChunk</span></a>. It
 531 simply switches the arguments and calls <a class="link" href="glib-Memory-Chunks.html#g-mem-chunk-free" title="g_mem_chunk_free ()"><code class="function">g_mem_chunk_free()</code></a> It is
 532 included simply to complement the other convenience macros,
 533 <a class="link" href="glib-Memory-Chunks.html#g-chunk-new" title="g_chunk_new()"><code class="function">g_chunk_new()</code></a> and <a class="link" href="glib-Memory-Chunks.html#g-chunk-new0" title="g_chunk_new0()"><code class="function">g_chunk_new0()</code></a>.</p>
 534 <div class="variablelist"><table border="0">
 535 <col align="left" valign="top">
 536 <tbody>
 537 <tr>
 538 <td><p><span class="term"><em class="parameter"><code>mem</code></em> :</span></p></td>
 539 <td> a pointer to the atom to be freed.
 540 </td>
 541 </tr>
 542 <tr>
 543 <td><p><span class="term"><em class="parameter"><code>mem_chunk</code></em> :</span></p></td>
 544 <td> a <a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="type">GMemChunk</span></a>.
 545 </td>
 546 </tr>
 547 </tbody>
 548 </table></div>
 549 </div>
 550 <hr>
 551 <div class="refsect2" title="g_mem_chunk_reset ()">
 552 <a name="g-mem-chunk-reset"></a><h3>g_mem_chunk_reset ()</h3>
 553 <pre class="programlisting"><span class="returnvalue">void</span>                g_mem_chunk_reset                   (<a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="returnvalue">GMemChunk</span></a> *mem_chunk);</pre>
 554 <div class="warning" title="Warning" style="margin-left: 0.5in; margin-right: 0.5in;">
 555 <h3 class="title">Warning</h3>
 556 <p><code class="literal">g_mem_chunk_reset</code> has been deprecated since version 2.10 and should not be used in newly-written code. Use the <a class="link" href="glib-Memory-Slices.html" title="Memory Slices">slice
 557                  allocator</a> instead</p>
 558 </div>
 559 <p>
 560 Resets a GMemChunk to its initial state. It frees all of the
 561 currently allocated blocks of memory.</p>
 562 <div class="variablelist"><table border="0">
 563 <col align="left" valign="top">
 564 <tbody><tr>
 565 <td><p><span class="term"><em class="parameter"><code>mem_chunk</code></em> :</span></p></td>
 566 <td> a <a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="type">GMemChunk</span></a>.
 567 </td>
 568 </tr></tbody>
 569 </table></div>
 570 </div>
 571 <hr>
 572 <div class="refsect2" title="g_mem_chunk_clean ()">
 573 <a name="g-mem-chunk-clean"></a><h3>g_mem_chunk_clean ()</h3>
 574 <pre class="programlisting"><span class="returnvalue">void</span>                g_mem_chunk_clean                   (<a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="returnvalue">GMemChunk</span></a> *mem_chunk);</pre>
 575 <div class="warning" title="Warning" style="margin-left: 0.5in; margin-right: 0.5in;">
 576 <h3 class="title">Warning</h3>
 577 <p><code class="literal">g_mem_chunk_clean</code> has been deprecated since version 2.10 and should not be used in newly-written code. Use the <a class="link" href="glib-Memory-Slices.html" title="Memory Slices">slice
 578                  allocator</a> instead</p>
 579 </div>
 580 <p>
 581 Frees any blocks in a <a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="type">GMemChunk</span></a> which are no longer being used.</p>
 582 <div class="variablelist"><table border="0">
 583 <col align="left" valign="top">
 584 <tbody><tr>
 585 <td><p><span class="term"><em class="parameter"><code>mem_chunk</code></em> :</span></p></td>
 586 <td> a <a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="type">GMemChunk</span></a>.
 587 </td>
 588 </tr></tbody>
 589 </table></div>
 590 </div>
 591 <hr>
 592 <div class="refsect2" title="g_blow_chunks ()">
 593 <a name="g-blow-chunks"></a><h3>g_blow_chunks ()</h3>
 594 <pre class="programlisting"><span class="returnvalue">void</span>                g_blow_chunks                       (void);</pre>
 595 <div class="warning" title="Warning" style="margin-left: 0.5in; margin-right: 0.5in;">
 596 <h3 class="title">Warning</h3>
 597 <p><code class="literal">g_blow_chunks</code> has been deprecated since version 2.10 and should not be used in newly-written code. Use the <a class="link" href="glib-Memory-Slices.html" title="Memory Slices">slice
 598                  allocator</a> instead</p>
 599 </div>
 600 <p>
 601 Calls <a class="link" href="glib-Memory-Chunks.html#g-mem-chunk-clean" title="g_mem_chunk_clean ()"><code class="function">g_mem_chunk_clean()</code></a> on all <a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="type">GMemChunk</span></a> objects.</p>
 602 </div>
 603 <hr>
 604 <div class="refsect2" title="g_mem_chunk_info ()">
 605 <a name="g-mem-chunk-info"></a><h3>g_mem_chunk_info ()</h3>
 606 <pre class="programlisting"><span class="returnvalue">void</span>                g_mem_chunk_info                    (void);</pre>
 607 <div class="warning" title="Warning" style="margin-left: 0.5in; margin-right: 0.5in;">
 608 <h3 class="title">Warning</h3>
 609 <p><code class="literal">g_mem_chunk_info</code> has been deprecated since version 2.10 and should not be used in newly-written code. Use the <a class="link" href="glib-Memory-Slices.html" title="Memory Slices">slice
 610                  allocator</a> instead</p>
 611 </div>
 612 <p>
 613 Outputs debugging information for all <a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="type">GMemChunk</span></a> objects currently
 614 in use. It outputs the number of <a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="type">GMemChunk</span></a> objects currently
 615 allocated, and calls <a class="link" href="glib-Memory-Chunks.html#g-mem-chunk-print" title="g_mem_chunk_print ()"><code class="function">g_mem_chunk_print()</code></a> to output information on
 616 each one.</p>
 617 </div>
 618 <hr>
 619 <div class="refsect2" title="g_mem_chunk_print ()">
 620 <a name="g-mem-chunk-print"></a><h3>g_mem_chunk_print ()</h3>
 621 <pre class="programlisting"><span class="returnvalue">void</span>                g_mem_chunk_print                   (<a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="returnvalue">GMemChunk</span></a> *mem_chunk);</pre>
 622 <div class="warning" title="Warning" style="margin-left: 0.5in; margin-right: 0.5in;">
 623 <h3 class="title">Warning</h3>
 624 <p><code class="literal">g_mem_chunk_print</code> has been deprecated since version 2.10 and should not be used in newly-written code. Use the <a class="link" href="glib-Memory-Slices.html" title="Memory Slices">slice
 625                  allocator</a> instead</p>
 626 </div>
 627 <p>
 628 Outputs debugging information for a <a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="type">GMemChunk</span></a>. It outputs the name
 629 of the <a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="type">GMemChunk</span></a> (set with <a class="link" href="glib-Memory-Chunks.html#g-mem-chunk-new" title="g_mem_chunk_new ()"><code class="function">g_mem_chunk_new()</code></a>), the number of bytes
 630 used, and the number of blocks of memory allocated.</p>
 631 <div class="variablelist"><table border="0">
 632 <col align="left" valign="top">
 633 <tbody><tr>
 634 <td><p><span class="term"><em class="parameter"><code>mem_chunk</code></em> :</span></p></td>
 635 <td> a <a class="link" href="glib-Memory-Chunks.html#GMemChunk" title="GMemChunk"><span class="type">GMemChunk</span></a>.
 636 </td>
 637 </tr></tbody>
 638 </table></div>
 639 </div>
 640 </div>
 641 </div>
 642 <div class="footer">
 643 <hr>
 644           Generated by GTK-Doc V1.13</div>
 645 </body>
 646 </html>