← Back to branch summary

~ubuntu-branches/ubuntu/trusty/glib2.0/trusty-proposed

« back to all changes in this revision

Viewing changes to docs/reference/glib/html/glib-Memory-Slices.html

  • Committer: Bazaar Package Importer
  • Author(s): Sebastien Bacher
  • Date: 2010-03-23 19:25:52 UTC
  • mfrom: (3.4.9 experimental)
  • Revision ID: james.westby@ubuntu.com-20100323192552-istna8c33bw6harh
Tags: 2.23.6-1ubuntu1
* Resync on Debian
* debian/patches/01_gettext-desktopfiles.patch:
  - updated to use gettext for X-GNOME-Fullname too
* debian/patches/71_gio_launch_handler.patch:
  - new gio default launch handle feature required for wncksync
* debian/control.in, 
  debian/patches/80-gtester-subunit.patch:
  - gtester-report subunit support
* debian/libglib2.0-0.symbols:
  - updated the symbols list for the gio launcher handler

Show diffs side-by-side

added added

removed removed

Lines of Context:
docs/reference/glib/html/glib-Memory-Slices.html
8
8
<link rel="up" href="glib-data-types.html" title="GLib Data Types">
9
9
<link rel="prev" href="glib-data-types.html" title="GLib Data Types">
10
10
<link rel="next" href="glib-Memory-Chunks.html" title="Memory Chunks">
11
 
<meta name="generator" content="GTK-Doc V1.11 (XML mode)">
 
11
<meta name="generator" content="GTK-Doc V1.13 (XML mode)">
12
12
<link rel="stylesheet" href="style.css" type="text/css">
13
13
<link rel="chapter" href="glib.html" title="GLib Overview">
14
14
<link rel="chapter" href="glib-fundamentals.html" title="GLib Fundamentals">
42
42
</tr>
43
43
<tr><td colspan="5" class="shortcuts">
44
44
<a href="#glib-Memory-Slices.synopsis" class="shortcut">Top</a>
45
 
                 | 
46
 
                <a href="#glib-Memory-Slices.description" class="shortcut">Description</a>
 
45
                   | 
 
46
                  <a href="#glib-Memory-Slices.description" class="shortcut">Description</a>
47
47
</td></tr>
48
48
</table>
49
49
<div class="refentry" title="Memory Slices">
58
58
<div class="refsynopsisdiv" title="Synopsis">
59
59
<a name="glib-Memory-Slices.synopsis"></a><h2>Synopsis</h2>
60
60
<pre class="synopsis">
61
 
 
62
61
#include &lt;glib.h&gt;
63
62
 
64
 
<a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer">gpointer</a>            <a class="link" href="glib-Memory-Slices.html#g-slice-alloc" title="g_slice_alloc ()">g_slice_alloc</a>                       (<a class="link" href="glib-Basic-Types.html#gsize" title="gsize">gsize</a> block_size);
65
 
<a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer">gpointer</a>            <a class="link" href="glib-Memory-Slices.html#g-slice-alloc0" title="g_slice_alloc0 ()">g_slice_alloc0</a>                      (<a class="link" href="glib-Basic-Types.html#gsize" title="gsize">gsize</a> block_size);
66
 
<a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer">gpointer</a>            <a class="link" href="glib-Memory-Slices.html#g-slice-copy" title="g_slice_copy ()">g_slice_copy</a>                        (<a class="link" href="glib-Basic-Types.html#gsize" title="gsize">gsize</a> block_size,
67
 
                                                         <a class="link" href="glib-Basic-Types.html#gconstpointer" title="gconstpointer">gconstpointer</a> mem_block);
68
 
void                <a class="link" href="glib-Memory-Slices.html#g-slice-free1" title="g_slice_free1 ()">g_slice_free1</a>                       (<a class="link" href="glib-Basic-Types.html#gsize" title="gsize">gsize</a> block_size,
69
 
                                                         <a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer">gpointer</a> mem_block);
70
 
void                <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>      (<a class="link" href="glib-Basic-Types.html#gsize" title="gsize">gsize</a> block_size,
71
 
                                                         <a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer">gpointer</a> mem_chain,
72
 
                                                         <a class="link" href="glib-Basic-Types.html#gsize" title="gsize">gsize</a> next_offset);
 
63
<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>                       (<a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a> block_size);
 
64
<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>                      (<a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a> block_size);
 
65
<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>                        (<a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a> block_size,
 
66
                                                         <a class="link" href="glib-Basic-Types.html#gconstpointer" title="gconstpointer"><span class="returnvalue">gconstpointer</span></a> mem_block);
 
67
<span class="returnvalue">void</span>                <a class="link" href="glib-Memory-Slices.html#g-slice-free1" title="g_slice_free1 ()">g_slice_free1</a>                       (<a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a> block_size,
 
68
                                                         <a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a> mem_block);
 
69
<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>      (<a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a> block_size,
 
70
                                                         <a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a> mem_chain,
 
71
                                                         <a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a> next_offset);
73
72
 
74
73
#define             <a class="link" href="glib-Memory-Slices.html#g-slice-new" title="g_slice_new()">g_slice_new</a>                         (type)
75
74
#define             <a class="link" href="glib-Memory-Slices.html#g-slice-new0" title="g_slice_new0()">g_slice_new0</a>                        (type)
83
82
<p>
84
83
Memory slices provide a space-efficient and multi-processing scalable
85
84
way to allocate equal-sized pieces of memory, just like the original
86
 
<span class="type">GMemChunks</span> (from GLib &lt;= 2.8), while avoiding their excessive
 
85
<a href="glib-Memory-Chunks.html#GMemChunk"><span class="type">GMemChunks</span></a> (from GLib &lt;= 2.8), while avoiding their excessive
87
86
memory-waste, scalability and performance problems.
88
87
</p>
89
88
<p>
90
89
To achieve these goals, the slice allocator uses a sophisticated,
91
90
layered design that has been inspired by Bonwick's slab allocator
92
 
<sup>[<a name="id536590" href="#ftn.id536590" class="footnote">6</a>]</sup>.
 
91
<sup>[<a name="id756836" href="#ftn.id756836" class="footnote">6</a>]</sup>.
93
92
It uses <code class="function">posix_memalign()</code> to optimize allocations of many equally-sized
94
93
chunks, and has per-thread free lists (the so-called magazine layer)
95
94
to quickly satisfy allocation requests of already known structure sizes.
110
109
object size used at allocation time is still available when freeing.
111
110
</p>
112
111
<div class="example">
113
 
<a name="id547634"></a><p class="title"><b>Example 15. Using the slice allocator</b></p>
114
 
<div class="example-contents"><pre class="programlisting">
115
 
  gchar *mem[10000];
116
 
  gint i;
117
 
  /* Allocate 10000 blocks. */
118
 
  for (i = 0; i &lt; 10000; i++)
119
 
    {
120
 
      mem[i] = g_slice_alloc (50);
121
 
      /* Fill in the memory with some junk. */
122
 
      for (j = 0; j &lt; 50; j++)
123
 
        mem[i][j] = i * j;
124
 
    }
125
 
  /* Now free all of the blocks. */
126
 
  for (i = 0; i &lt; 10000; i++)
127
 
    {
128
 
      g_slice_free1 (50, mem[i]);
129
 
    }
130
 
</pre></div>
 
112
<a name="id756412"></a><p class="title"><b>Example 15. Using the slice allocator</b></p>
 
113
<div class="example-contents">
 
114
  <table class="listing_frame" border="0" cellpadding="0" cellspacing="0">
 
115
    <tbody>
 
116
      <tr>
 
117
        <td class="listing_lines" align="right"><pre>1
 
118
2
 
119
3
 
120
4
 
121
5
 
122
6
 
123
7
 
124
8
 
125
9
 
126
10
 
127
11
 
128
12
 
129
13
 
130
14
 
131
15</pre></td>
 
132
        <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>
 
133
<span class="usertype">gint</span><span class="normal"> i</span><span class="symbol">;</span>
 
134
<span class="comment">/* Allocate 10000 blocks. */</span>
 
135
<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>
 
136
<span class="normal">  </span><span class="cbracket">{</span>
 
137
<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>
 
138
<span class="normal">    </span><span class="comment">/* Fill in the memory with some junk. */</span>
 
139
<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>
 
140
<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>
 
141
<span class="normal">  </span><span class="cbracket">}</span>
 
142
<span class="comment">/* Now free all of the blocks. */</span>
 
143
<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>
 
144
<span class="normal">  </span><span class="cbracket">{</span>
 
145
<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>
 
146
<span class="normal">  </span><span class="cbracket">}</span></pre></td>
 
147
      </tr>
 
148
    </tbody>
 
149
  </table>
 
150
</div>
 
151
 
131
152
</div>
132
153
<br class="example-break"><div class="example">
133
 
<a name="id765861"></a><p class="title"><b>Example 16. Using the slice allocator with data structures</b></p>
134
 
<div class="example-contents"><pre class="programlisting">
135
 
  GRealArray *array;
136
 
  /* Allocate one block, using the g_slice_new() macro. */
137
 
  array = g_slice_new (GRealArray);
138
 
  /* We can now use array just like a normal pointer to a structure. */
139
 
  array-&gt;data            = NULL;
140
 
  array-&gt;len             = 0;
141
 
  array-&gt;alloc           = 0;
142
 
  array-&gt;zero_terminated = (zero_terminated ? 1 : 0);
143
 
  array-&gt;clear           = (clear ? 1 : 0);
144
 
  array-&gt;elt_size        = elt_size;
145
 
  /* We can free the block, so it can be reused. */
146
 
  g_slice_free (GRealArray, array);
147
 
</pre></div>
 
154
<a name="id729439"></a><p class="title"><b>Example 16. Using the slice allocator with data structures</b></p>
 
155
<div class="example-contents">
 
156
  <table class="listing_frame" border="0" cellpadding="0" cellspacing="0">
 
157
    <tbody>
 
158
      <tr>
 
159
        <td class="listing_lines" align="right"><pre>1
 
160
2
 
161
3
 
162
4
 
163
5
 
164
6
 
165
7
 
166
8
 
167
9
 
168
10
 
169
11
 
170
12</pre></td>
 
171
        <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>
 
172
<span class="comment">/* Allocate one block, using the g_slice_new() macro. */</span>
 
173
<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>
 
174
<span class="comment">/* We can now use array just like a normal pointer to a structure. */</span>
 
175
<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>
 
176
<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>
 
177
<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>
 
178
<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>
 
179
<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>
 
180
<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>
 
181
<span class="comment">/* We can free the block, so it can be reused. */</span>
 
182
<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>
 
183
      </tr>
 
184
    </tbody>
 
185
  </table>
 
186
</div>
 
187
 
148
188
</div>
149
189
<br class="example-break">
150
190
</div>
152
192
<a name="glib-Memory-Slices.details"></a><h2>Details</h2>
153
193
<div class="refsect2" title="g_slice_alloc ()">
154
194
<a name="g-slice-alloc"></a><h3>g_slice_alloc ()</h3>
155
 
<pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer">gpointer</a>            g_slice_alloc                       (<a class="link" href="glib-Basic-Types.html#gsize" title="gsize">gsize</a> block_size);</pre>
 
195
<pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            g_slice_alloc                       (<a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a> block_size);</pre>
156
196
<p>
157
197
Allocates a block of memory from the slice allocator.
158
198
The block adress handed out can be expected to be aligned
184
224
<hr>
185
225
<div class="refsect2" title="g_slice_alloc0 ()">
186
226
<a name="g-slice-alloc0"></a><h3>g_slice_alloc0 ()</h3>
187
 
<pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer">gpointer</a>            g_slice_alloc0                      (<a class="link" href="glib-Basic-Types.html#gsize" title="gsize">gsize</a> block_size);</pre>
 
227
<pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            g_slice_alloc0                      (<a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a> block_size);</pre>
188
228
<p>
189
229
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>
190
230
and initialize the returned memory to 0.
212
252
<hr>
213
253
<div class="refsect2" title="g_slice_copy ()">
214
254
<a name="g-slice-copy"></a><h3>g_slice_copy ()</h3>
215
 
<pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer">gpointer</a>            g_slice_copy                        (<a class="link" href="glib-Basic-Types.html#gsize" title="gsize">gsize</a> block_size,
216
 
                                                         <a class="link" href="glib-Basic-Types.html#gconstpointer" title="gconstpointer">gconstpointer</a> mem_block);</pre>
 
255
<pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            g_slice_copy                        (<a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a> block_size,
 
256
                                                         <a class="link" href="glib-Basic-Types.html#gconstpointer" title="gconstpointer"><span class="returnvalue">gconstpointer</span></a> mem_block);</pre>
217
257
<p>
218
258
Allocates a block of memory from the slice allocator and copies
219
259
<em class="parameter"><code>block_size</code></em> bytes into it from <em class="parameter"><code>mem_block</code></em>.
243
283
<hr>
244
284
<div class="refsect2" title="g_slice_free1 ()">
245
285
<a name="g-slice-free1"></a><h3>g_slice_free1 ()</h3>
246
 
<pre class="programlisting">void                g_slice_free1                       (<a class="link" href="glib-Basic-Types.html#gsize" title="gsize">gsize</a> block_size,
247
 
                                                         <a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer">gpointer</a> mem_block);</pre>
 
286
<pre class="programlisting"><span class="returnvalue">void</span>                g_slice_free1                       (<a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a> block_size,
 
287
                                                         <a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a> mem_block);</pre>
248
288
<p>
249
289
Frees a block of memory. The memory must have been allocated via
250
290
<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>
273
313
<hr>
274
314
<div class="refsect2" title="g_slice_free_chain_with_offset ()">
275
315
<a name="g-slice-free-chain-with-offset"></a><h3>g_slice_free_chain_with_offset ()</h3>
276
 
<pre class="programlisting">void                g_slice_free_chain_with_offset      (<a class="link" href="glib-Basic-Types.html#gsize" title="gsize">gsize</a> block_size,
277
 
                                                         <a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer">gpointer</a> mem_chain,
278
 
                                                         <a class="link" href="glib-Basic-Types.html#gsize" title="gsize">gsize</a> next_offset);</pre>
 
316
<pre class="programlisting"><span class="returnvalue">void</span>                g_slice_free_chain_with_offset      (<a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a> block_size,
 
317
                                                         <a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a> mem_chain,
 
318
                                                         <a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a> next_offset);</pre>
279
319
<p>
280
320
Frees a linked list of memory blocks of structure type <em class="parameter"><code>type</code></em>.
281
321
The memory blocks must be equal-sized, allocated via
471
511
</div>
472
512
<div class="footnotes">
473
513
<br><hr width="100" align="left">
474
 
<div class="footnote"><p><sup>[<a name="ftn.id536590" href="#id536590" class="para">6</a>] </sup>
 
514
<div class="footnote"><p><sup>[<a name="ftn.id756836" href="#id756836" class="para">6</a>] </sup>
475
515
<a class="ulink" href="http://citeseer.ist.psu.edu/bonwick94slab.html" target="_top">[Bonwick94]</a> Jeff Bonwick, The slab allocator: An object-caching kernel
476
516
memory allocator. USENIX 1994, and
477
517
<a class="ulink" href="http://citeseer.ist.psu.edu/bonwick01magazines.html" target="_top">[Bonwick01]</a> Bonwick and Jonathan Adams, Magazines and vmem: Extending the
481
521
</div>
482
522
<div class="footer">
483
523
<hr>
484
 
          Generated by GTK-Doc V1.11</div>
 
524
          Generated by GTK-Doc V1.13</div>
485
525
</body>
486
 
</html>
 
526
</html>
 
 
b'\\ No newline at end of file'