[DAPL2] sync with WinOF 2.1 branch
[mirror/winof/.git] / inc / complib / cl_qpool.h
1 /*\r
2  * Copyright (c) 2005 SilverStorm Technologies.  All rights reserved.\r
3  * Copyright (c) 1996-2003 Intel Corporation. All rights reserved. \r
4  *\r
5  * This software is available to you under the OpenIB.org BSD license\r
6  * below:\r
7  *\r
8  *     Redistribution and use in source and binary forms, with or\r
9  *     without modification, are permitted provided that the following\r
10  *     conditions are met:\r
11  *\r
12  *      - Redistributions of source code must retain the above\r
13  *        copyright notice, this list of conditions and the following\r
14  *        disclaimer.\r
15  *\r
16  *      - Redistributions in binary form must reproduce the above\r
17  *        copyright notice, this list of conditions and the following\r
18  *        disclaimer in the documentation and/or other materials\r
19  *        provided with the distribution.\r
20  *\r
21  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,\r
22  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\r
23  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\r
24  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS\r
25  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\r
26  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
27  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r
28  * SOFTWARE.\r
29  *\r
30  * $Id$\r
31  */\r
32 \r
33 \r
34 /*\r
35  * Abstract:\r
36  *      Declaration of the quick pool.\r
37  *      The quick pool manages a pool of objects.\r
38  *      The pool can grow to meet demand, limited only by system memory.\r
39  *\r
40  * Environment:\r
41  *      All\r
42  */\r
43 \r
44 \r
45 #ifndef _CL_QUICK_POOL_H_\r
46 #define _CL_QUICK_POOL_H_\r
47 \r
48 \r
49 #include <complib/cl_qcomppool.h>\r
50 \r
51 \r
52 /****h* Component Library/Quick Pool\r
53 * NAME\r
54 *       Quick Pool\r
55 *\r
56 * DESCRIPTION\r
57 *       The quick pool provides a self-contained and self-sustaining pool\r
58 *       of user defined objects.\r
59 *\r
60 *       To aid in object oriented design, the quick pool provides the user\r
61 *       the ability to specify callbacks that are invoked for each object for\r
62 *       construction, initialization, and destruction. Constructor and destructor\r
63 *       callback functions may not fail.\r
64 *\r
65 *       A quick pool does not return memory to the system as the user returns\r
66 *       objects to the pool. The only method of returning memory to the system is\r
67 *       to destroy the pool.\r
68 *\r
69 *       The quick pool operates on cl_pool_item_t structures that describe\r
70 *       objects. This can provides for more efficient memory use and operation.\r
71 *       If using a cl_pool_item_t is not desired, the Pool provides similar\r
72 *       functionality but operates on opaque objects.\r
73 *\r
74 *       The quick pool functions operates on a cl_qpool_t structure which should\r
75 *       be treated as opaque and should be manipulated only through the provided\r
76 *       functions.\r
77 *\r
78 * SEE ALSO\r
79 *       Structures:\r
80 *               cl_qpool_t, cl_pool_item_t\r
81 *\r
82 *       Callbacks:\r
83 *               cl_pfn_qpool_init_t, cl_pfn_qpool_dtor_t\r
84 *\r
85 *       Initialization/Destruction:\r
86 *               cl_qpool_construct, cl_qpool_init, cl_qpool_destroy\r
87 *\r
88 *       Manipulation:\r
89 *               cl_qpool_get, cl_qpool_put, cl_qpool_put_list, cl_qpool_grow\r
90 *\r
91 *       Attributes:\r
92 *               cl_is_qpool_inited, cl_qpool_count\r
93 *********/\r
94 \r
95 \r
96 /****d* Component Library: Quick Pool/cl_pfn_qpool_init_t\r
97 * NAME\r
98 *       cl_pfn_qpool_init_t\r
99 *\r
100 * DESCRIPTION\r
101 *       The cl_pfn_qpool_init_t function type defines the prototype for\r
102 *       functions used as constructor for objects being allocated by a\r
103 *       quick pool.\r
104 *\r
105 * SYNOPSIS\r
106 */\r
107 typedef cl_status_t\r
108 (CL_API *cl_pfn_qpool_init_t)(\r
109         IN      void* const                             p_object,\r
110         IN      void*                                   context,\r
111         OUT     cl_pool_item_t** const  pp_pool_item );\r
112 /*\r
113 * PARAMETERS\r
114 *       p_object\r
115 *               [in] Pointer to an object to initialize.\r
116 *\r
117 *       context\r
118 *               [in] Context provided in a call to cl_qpool_init.\r
119 *\r
120 * RETURN VALUES\r
121 *       Return CL_SUCCESS to indicate that initialization of the object\r
122 *       was successful and that initialization of further objects may continue.\r
123 *\r
124 *       Other cl_status_t values will be returned by cl_qcpool_init\r
125 *       and cl_qcpool_grow.\r
126 *\r
127 * NOTES\r
128 *       This function type is provided as function prototype reference for\r
129 *       the function provided by the user as an optional parameter to the\r
130 *       cl_qpool_init function.\r
131 *\r
132 *       The initializer is invoked once per allocated object, allowing the user\r
133 *       to perform any necessary initialization.  Returning a status other than\r
134 *       CL_SUCCESS aborts a grow operation, initiated either through cl_qcpool_init\r
135 *       or cl_qcpool_grow, causing the initiating function to fail.\r
136 *       Any non-CL_SUCCESS status will be returned by the function that initiated\r
137 *       the grow operation.\r
138 *\r
139 *       All memory for the object is pre-allocated.  Users should include space in\r
140 *       their objects for the cl_pool_item_t structure that will represent the\r
141 *       object to avoid having to allocate that structure in the initialization\r
142 *       callback.\r
143 *\r
144 *       When later performing a cl_qcpool_get call, the return value is a pointer\r
145 *       to the cl_pool_item_t returned by this function in the pp_pool_item\r
146 *       parameter.  Users must set pp_pool_item to a valid pointer to the\r
147 *       cl_pool_item_t representing the object if they return CL_SUCCESS.\r
148 *\r
149 * SEE ALSO\r
150 *       Quick Pool, cl_qpool_init\r
151 *********/\r
152 \r
153 \r
154 /****d* Component Library: Quick Pool/cl_pfn_qpool_dtor_t\r
155 * NAME\r
156 *       cl_pfn_qpool_dtor_t\r
157 *\r
158 * DESCRIPTION\r
159 *       The cl_pfn_qpool_dtor_t function type defines the prototype for\r
160 *       functions used as destructor for objects being deallocated by a\r
161 *       quick pool.\r
162 *\r
163 * SYNOPSIS\r
164 */\r
165 typedef void\r
166 (CL_API *cl_pfn_qpool_dtor_t)(\r
167         IN      const cl_pool_item_t* const     p_pool_item,\r
168         IN      void*                                           context );\r
169 /*\r
170 * PARAMETERS\r
171 *       p_pool_item\r
172 *               [in] Pointer to a cl_pool_item_t structure representing an object.\r
173 *\r
174 *       context\r
175 *               [in] Context provided in a call to cl_qpool_init.\r
176 *\r
177 * RETURN VALUE\r
178 *       This function does not return a value.\r
179 *\r
180 * NOTES\r
181 *       This function type is provided as function prototype reference for\r
182 *       the function provided by the user as an optional parameter to the\r
183 *       cl_qpool_init function.\r
184 *\r
185 *       The destructor is invoked once per allocated object, allowing the user\r
186 *       to perform any necessary cleanup. Users should not attempt to deallocate\r
187 *       the memory for the object, as the quick pool manages object\r
188 *       allocation and deallocation.\r
189 *\r
190 * SEE ALSO\r
191 *       Quick Pool, cl_qpool_init\r
192 *********/\r
193 \r
194 \r
195 /****s* Component Library: Quick Pool/cl_qpool_t\r
196 * NAME\r
197 *       cl_qpool_t\r
198 *\r
199 * DESCRIPTION\r
200 *       Quick pool structure.\r
201 *\r
202 *       The cl_qpool_t structure should be treated as opaque and should be\r
203 *       manipulated only through the provided functions.\r
204 *\r
205 * SYNOPSIS\r
206 */\r
207 typedef struct _cl_qpool\r
208 {\r
209         cl_qcpool_t                             qcpool;\r
210         cl_pfn_qpool_init_t             pfn_init;\r
211         cl_pfn_qpool_dtor_t             pfn_dtor;\r
212         const void                              *context;\r
213 \r
214 } cl_qpool_t;\r
215 /*\r
216 * FIELDS\r
217 *       qcpool\r
218 *               Quick composite pool that manages all objects.\r
219 *\r
220 *       pfn_init\r
221 *               Pointer to the user's initializer callback, used by the pool\r
222 *               to translate the quick composite pool's initializer callback to\r
223 *               a quick pool initializer callback.\r
224 *\r
225 *       pfn_dtor\r
226 *               Pointer to the user's destructor callback, used by the pool\r
227 *               to translate the quick composite pool's destructor callback to\r
228 *               a quick pool destructor callback.\r
229 *\r
230 *       context\r
231 *               User's provided context for callback functions, used by the pool\r
232 *               to when invoking callbacks.\r
233 *\r
234 * SEE ALSO\r
235 *       Quick Pool\r
236 *********/\r
237 \r
238 \r
239 \r
240 #ifdef __cplusplus\r
241 extern "C"\r
242 {\r
243 #endif  /* __cplusplus */\r
244 \r
245 \r
246 /****f* Component Library: Quick Pool/cl_qpool_construct\r
247 * NAME\r
248 *       cl_qpool_construct\r
249 *\r
250 * DESCRIPTION\r
251 *       The cl_qpool_construct function constructs a quick pool.\r
252 *\r
253 * SYNOPSIS\r
254 */\r
255 CL_EXPORT void CL_API\r
256 cl_qpool_construct(\r
257         IN      cl_qpool_t* const       p_pool );\r
258 /*\r
259 * PARAMETERS\r
260 *       p_pool\r
261 *               [in] Pointer to a cl_qpool_t structure whose state to initialize.\r
262 *\r
263 * RETURN VALUE\r
264 *       This function does not return a value.\r
265 *\r
266 * NOTES\r
267 *       Allows calling cl_qpool_init, cl_qpool_destroy, cl_is_qpool_inited.\r
268 *\r
269 *       Calling cl_qpool_construct is a prerequisite to calling any other\r
270 *       quick pool function except cl_pool_init.\r
271 *\r
272 * SEE ALSO\r
273 *       Quick Pool, cl_qpool_init, cl_qpool_destroy, cl_is_qpool_inited.\r
274 *********/\r
275 \r
276 \r
277 /****f* Component Library: Quick Pool/cl_is_qpool_inited\r
278 * NAME\r
279 *       cl_is_qpool_inited\r
280 *\r
281 * DESCRIPTION\r
282 *       The cl_is_qpool_inited function returns whether a quick pool was\r
283 *       successfully initialized.\r
284 *\r
285 * SYNOPSIS\r
286 */\r
287 CL_INLINE uint32_t CL_API\r
288 cl_is_qpool_inited(\r
289         IN      const cl_qpool_t* const p_pool )\r
290 {\r
291         /* CL_ASSERT that a non-null pointer is provided. */\r
292         CL_ASSERT( p_pool );\r
293         return( cl_is_qcpool_inited( &p_pool->qcpool ) );\r
294 }\r
295 /*\r
296 * PARAMETERS\r
297 *       p_pool\r
298 *               [in] Pointer to a cl_qpool_t structure whose initialization state\r
299 *               to check.\r
300 *\r
301 * RETURN VALUES\r
302 *       TRUE if the quick pool was initialized successfully.\r
303 *\r
304 *       FALSE otherwise.\r
305 *\r
306 * NOTES\r
307 *       Allows checking the state of a quick pool to determine if\r
308 *       invoking member functions is appropriate.\r
309 *\r
310 * SEE ALSO\r
311 *       Quick Pool\r
312 *********/\r
313 \r
314 \r
315 /****f* Component Library: Quick Pool/cl_qpool_init\r
316 * NAME\r
317 *       cl_qpool_init\r
318 *\r
319 * DESCRIPTION\r
320 *       The cl_qpool_init function initializes a quick pool for use.\r
321 *\r
322 * SYNOPSIS\r
323 */\r
324 CL_EXPORT cl_status_t CL_API\r
325 cl_qpool_init(\r
326         IN      cl_qpool_t* const               p_pool,\r
327         IN      const size_t                    min_size,\r
328         IN      const size_t                    max_size,\r
329         IN      const size_t                    grow_size,\r
330         IN      const size_t                    object_size,\r
331         IN      cl_pfn_qpool_init_t             pfn_initializer OPTIONAL,\r
332         IN      cl_pfn_qpool_dtor_t             pfn_destructor OPTIONAL,\r
333         IN      const void* const               context );\r
334 /*\r
335 * PARAMETERS\r
336 *       p_pool\r
337 *               [in] Pointer to a cl_qpool_t structure to initialize.\r
338 *\r
339 *       min_size\r
340 *               [in] Minimum number of objects that the pool should support. All\r
341 *               necessary allocations to allow storing the minimum number of items\r
342 *               are performed at initialization time, and all necessary callbacks\r
343 *               successfully invoked.\r
344 *\r
345 *       max_size\r
346 *               [in] Maximum number of objects to which the pool is allowed to grow.\r
347 *               A value of zero specifies no maximum.\r
348 *\r
349 *       grow_size\r
350 *               [in] Number of objects to allocate when incrementally growing the pool.\r
351 *               A value of zero disables automatic growth.\r
352 *\r
353 *       object_size\r
354 *               [in] Size, in bytes, of each object.\r
355 *\r
356 *       pfn_initializer\r
357 *               [in] Initialization callback to invoke for every new object when\r
358 *               growing the pool. This parameter is optional and may be NULL. If NULL,\r
359 *               the pool assumes the cl_pool_item_t structure describing objects is\r
360 *               located at the head of each object. See the cl_pfn_qpool_init_t\r
361 *               function type declaration for details about the callback function.\r
362 *\r
363 *       pfn_destructor\r
364 *               [in] Destructor callback to invoke for every object before memory for\r
365 *               that object is freed. This parameter is optional and may be NULL.\r
366 *               See the cl_pfn_qpool_dtor_t function type declaration for details\r
367 *               about the callback function.\r
368 *\r
369 *       context\r
370 *               [in] Value to pass to the callback functions to provide context.\r
371 *\r
372 * RETURN VALUES\r
373 *       CL_SUCCESS if the quick pool was initialized successfully.\r
374 *\r
375 *       CL_INSUFFICIENT_MEMORY if there was not enough memory to initialize the\r
376 *       quick pool.\r
377 *\r
378 *       CL_INVALID_SETTING if a the maximum size is non-zero and less than the\r
379 *       minimum size.\r
380 *\r
381 *       Other cl_status_t value returned by optional initialization callback function\r
382 *       specified by the pfn_initializer parameter.\r
383 *\r
384 * NOTES\r
385 *       cl_qpool_init initializes, and if necessary, grows the pool to\r
386 *       the capacity desired.\r
387 *\r
388 * SEE ALSO\r
389 *       Quick Pool, cl_qpool_construct, cl_qpool_destroy,\r
390 *       cl_qpool_get, cl_qpool_put, cl_qpool_grow,\r
391 *       cl_qpool_count, cl_pfn_qpool_init_t, cl_pfn_qpool_init_t,\r
392 *       cl_pfn_qpool_dtor_t\r
393 *********/\r
394 \r
395 \r
396 /****f* Component Library: Quick Pool/cl_qpool_destroy\r
397 * NAME\r
398 *       cl_qpool_destroy\r
399 *\r
400 * DESCRIPTION\r
401 *       The cl_qpool_destroy function destroys a quick pool.\r
402 *\r
403 * SYNOPSIS\r
404 */\r
405 CL_INLINE void CL_API\r
406 cl_qpool_destroy(\r
407         IN      cl_qpool_t* const       p_pool )\r
408 {\r
409         CL_ASSERT( p_pool );\r
410         cl_qcpool_destroy( &p_pool->qcpool );\r
411 }\r
412 /*\r
413 * PARAMETERS\r
414 *       p_pool\r
415 *               [in] Pointer to a cl_qpool_t structure to destroy.\r
416 *\r
417 * RETURN VALUE\r
418 *       This function does not return a value.\r
419 *\r
420 * NOTES\r
421 *       All memory allocated for objects is freed. The destructor callback,\r
422 *       if any, will be invoked for every allocated object. Further operations\r
423 *       on the pool should not be attempted after cl_qpool_destroy\r
424 *       is invoked.\r
425 *\r
426 *       This function should only be called after a call to\r
427 *       cl_qpool_construct or cl_qpool_init.\r
428 *\r
429 *       In a debug build, cl_qpool_destroy asserts that all objects are in\r
430 *       the pool.\r
431 *\r
432 * SEE ALSO\r
433 *       Quick Pool, cl_qpool_construct, cl_qpool_init\r
434 *********/\r
435 \r
436 \r
437 /****f* Component Library: Quick Pool/cl_qpool_count\r
438 * NAME\r
439 *       cl_qpool_count\r
440 *\r
441 * DESCRIPTION\r
442 *       The cl_qpool_count function returns the number of available objects\r
443 *       in a quick pool.\r
444 *\r
445 * SYNOPSIS\r
446 */\r
447 CL_INLINE size_t CL_API\r
448 cl_qpool_count(\r
449         IN      cl_qpool_t* const       p_pool )\r
450 {\r
451         CL_ASSERT( p_pool );\r
452         return( cl_qcpool_count( &p_pool->qcpool ) );\r
453 }\r
454 /*\r
455 * PARAMETERS\r
456 *       p_pool\r
457 *               [in] Pointer to a cl_qpool_t structure for which the number of\r
458 *               available objects is requested.\r
459 *\r
460 * RETURN VALUE\r
461 *       Returns the number of objects available in the specified quick pool.\r
462 *\r
463 * SEE ALSO\r
464 *       Quick Pool\r
465 *********/\r
466 \r
467 \r
468 /****f* Component Library: Quick Pool/cl_qpool_get\r
469 * NAME\r
470 *       cl_qpool_get\r
471 *\r
472 * DESCRIPTION\r
473 *       The cl_qpool_get function retrieves an object from a\r
474 *       quick pool.\r
475 *\r
476 * SYNOPSIS\r
477 */\r
478 CL_INLINE cl_pool_item_t* CL_API\r
479 cl_qpool_get(\r
480         IN      cl_qpool_t* const       p_pool )\r
481 {\r
482         CL_ASSERT( p_pool );\r
483         return( cl_qcpool_get( &p_pool->qcpool ) );\r
484 }\r
485 /*\r
486 * PARAMETERS\r
487 *       p_pool\r
488 *               [in] Pointer to a cl_qpool_t structure from which to retrieve\r
489 *               an object.\r
490 *\r
491 * RETURN VALUES\r
492 *       Returns a pointer to a cl_pool_item_t for an object.\r
493 *\r
494 *       Returns NULL if the pool is empty and can not be grown automatically.\r
495 *\r
496 * NOTES\r
497 *       cl_qpool_get returns the object at the head of the pool. If the pool is\r
498 *       empty, it is automatically grown to accommodate this request unless the\r
499 *       grow_size parameter passed to the cl_qpool_init function was zero.\r
500 *\r
501 * SEE ALSO\r
502 *       Quick Pool, cl_qpool_get_tail, cl_qpool_put, cl_qpool_grow, cl_qpool_count\r
503 *********/\r
504 \r
505 \r
506 /****f* Component Library: Quick Pool/cl_qpool_put\r
507 * NAME\r
508 *       cl_qpool_put\r
509 *\r
510 * DESCRIPTION\r
511 *       The cl_qpool_put function returns an object to the head of a quick pool.\r
512 *\r
513 * SYNOPSIS\r
514 */\r
515 CL_INLINE void CL_API\r
516 cl_qpool_put(\r
517         IN      cl_qpool_t* const               p_pool,\r
518         IN      cl_pool_item_t* const   p_pool_item )\r
519 {\r
520         CL_ASSERT( p_pool );\r
521         cl_qcpool_put( &p_pool->qcpool, p_pool_item );\r
522 }\r
523 /*\r
524 * PARAMETERS\r
525 *       p_pool\r
526 *               [in] Pointer to a cl_qpool_t structure to which to return\r
527 *               an object.\r
528 *\r
529 *       p_pool_item\r
530 *               [in] Pointer to a cl_pool_item_t structure for the object\r
531 *               being returned.\r
532 *\r
533 * RETURN VALUE\r
534 *       This function does not return a value.\r
535 *\r
536 * NOTES\r
537 *       cl_qpool_put places the returned object at the head of the pool.\r
538 *\r
539 *       The object specified by the p_pool_item parameter must have been\r
540 *       retrieved from the pool by a previous call to cl_qpool_get.\r
541 *\r
542 * SEE ALSO\r
543 *       Quick Pool, cl_qpool_put_tail, cl_qpool_get\r
544 *********/\r
545 \r
546 \r
547 /****f* Component Library: Quick Pool/cl_qpool_put_list\r
548 * NAME\r
549 *       cl_qpool_put_list\r
550 *\r
551 * DESCRIPTION\r
552 *       The cl_qpool_put_list function returns a list of objects to the head\r
553 *       of a quick pool.\r
554 *\r
555 * SYNOPSIS\r
556 */\r
557 CL_INLINE void CL_API\r
558 cl_qpool_put_list(\r
559         IN      cl_qpool_t* const       p_pool,\r
560         IN      cl_qlist_t* const       p_list )\r
561 {\r
562         CL_ASSERT( p_pool );\r
563         cl_qcpool_put_list( &p_pool->qcpool, p_list );\r
564 }\r
565 /*\r
566 * PARAMETERS\r
567 *       p_pool\r
568 *               [in] Pointer to a cl_qpool_t structure to which to return\r
569 *               a list of objects.\r
570 *\r
571 *       p_list\r
572 *               [in] Pointer to a cl_qlist_t structure for the list of objects\r
573 *               being returned.\r
574 *\r
575 * RETURN VALUE\r
576 *       This function does not return a value.\r
577 *\r
578 * NOTES\r
579 *       cl_qpool_put_list places the returned objects at the head of the pool.\r
580 *\r
581 *       The objects in the list specified by the p_list parameter must have been\r
582 *       retrieved from the pool by a previous call to cl_qpool_get.\r
583 *\r
584 * SEE ALSO\r
585 *       Quick Pool, cl_qpool_put, cl_qpool_put_tail, cl_qpool_get\r
586 *********/\r
587 \r
588 \r
589 /****f* Component Library: Quick Pool/cl_qpool_grow\r
590 * NAME\r
591 *       cl_qpool_grow\r
592 *\r
593 * DESCRIPTION\r
594 *       The cl_qpool_grow function grows a quick pool by\r
595 *       the specified number of objects.\r
596 *\r
597 * SYNOPSIS\r
598 */\r
599 CL_INLINE cl_status_t CL_API\r
600 cl_qpool_grow(\r
601         IN      cl_qpool_t* const       p_pool,\r
602         IN      const size_t            obj_count )\r
603 {\r
604         CL_ASSERT( p_pool );\r
605         return( cl_qcpool_grow( &p_pool->qcpool, obj_count ) );\r
606 }\r
607 /*\r
608 * PARAMETERS\r
609 *       p_pool\r
610 *               [in] Pointer to a cl_qpool_t structure whose capacity to grow.\r
611 *\r
612 *       obj_count\r
613 *               [in] Number of objects by which to grow the pool.\r
614 *\r
615 * RETURN VALUES\r
616 *       CL_SUCCESS if the quick pool grew successfully.\r
617 *\r
618 *       CL_INSUFFICIENT_MEMORY if there was not enough memory to grow the\r
619 *       quick pool.\r
620 *\r
621 *       cl_status_t value returned by optional initialization callback function\r
622 *       specified by the pfn_initializer parameter passed to the\r
623 *       cl_qpool_init function.\r
624 *\r
625 * NOTES\r
626 *       It is not necessary to call cl_qpool_grow if the pool is\r
627 *       configured to grow automatically.\r
628 *\r
629 * SEE ALSO\r
630 *       Quick Pool\r
631 *********/\r
632 \r
633 \r
634 #ifdef __cplusplus\r
635 }       /* extern "C" */\r
636 #endif  /* __cplusplus */\r
637 \r
638 \r
639 #endif  /* _CL_QUICK_POOL_H_ */\r