UCommon
memory.h
Go to the documentation of this file.
1// Copyright (C) 2006-2014 David Sugar, Tycho Softworks.
2// Copyright (C) 2015 Cherokees of Idaho.
3//
4// This file is part of GNU uCommon C++.
5//
6// GNU uCommon C++ is free software: you can redistribute it and/or modify
7// it under the terms of the GNU Lesser General Public License as published
8// by the Free Software Foundation, either version 3 of the License, or
9// (at your option) any later version.
10//
11// GNU uCommon C++ is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14// GNU Lesser General Public License for more details.
15//
16// You should have received a copy of the GNU Lesser General Public License
17// along with GNU uCommon C++. If not, see <http://www.gnu.org/licenses/>.
18
31#ifndef _UCOMMON_MEMORY_H_
32#define _UCOMMON_MEMORY_H_
33
34#ifndef _UCOMMON_CONFIG_H_
35#include <ucommon/platform.h>
36#endif
37
38#ifndef _UCOMMON_PROTOCOLS_H_
39#include <ucommon/protocols.h>
40#endif
41
42#ifndef _UCOMMON_LINKED_H_
43#include <ucommon/linked.h>
44#endif
45
46#ifndef _UCOMMON_STRING_H_
47#include <ucommon/string.h>
48#endif
49
50namespace ucommon {
51
52class PagerPool;
53
61class __EXPORT memalloc : public __PROTOCOL MemoryProtocol
62{
63private:
64 friend class bufpager;
65
66 size_t pagesize, align;
67 unsigned count;
68
69 typedef struct mempage {
70 struct mempage *next;
71 union {
72 void *memalign;
73 unsigned used;
74 };
75 } page_t;
76
77 page_t *page;
78
79protected:
80 unsigned limit;
81
86 page_t *pager(void);
87
88public:
93 memalloc(size_t page = 0);
94
95 memalloc(const memalloc& copy);
96
100 virtual ~memalloc();
101
106 inline unsigned pages(void) const {
107 return count;
108 }
109
117 inline unsigned max(void) const {
118 return limit;
119 }
120
125 inline size_t size(void) const {
126 return pagesize;
127 }
128
139 unsigned utilization(void) const;
140
144 void purge(void);
145
146protected:
154 virtual void *_alloc(size_t size) __OVERRIDE;
155
156public:
161 void assign(memalloc& source);
162};
163
184class __EXPORT mempager : public memalloc, public __PROTOCOL LockingProtocol
185{
186private:
187 mutable pthread_mutex_t mutex;
188
189protected:
196 virtual void _lock(void) __OVERRIDE;
197
201 virtual void _unlock(void) __OVERRIDE;
202
203public:
208 mempager(size_t page = 0);
209
210 mempager(const mempager& copy);
211
215 virtual ~mempager();
216
227 unsigned utilization(void);
228
232 void purge(void);
233
241 virtual void dealloc(void *memory);
242
243protected:
252 virtual void *_alloc(size_t size) __OVERRIDE;
253
254public:
259 void assign(mempager& source);
260};
261
262class __EXPORT ObjectPager : protected memalloc
263{
264public:
265 class __EXPORT member : public LinkedObject
266 {
267 private:
268 void *mem;
269
270 protected:
271 friend class ObjectPager;
272
273 inline void set(member *node) {
274 Next = node;
275 }
276
277 inline void *get(void) const {
278 return mem;
279 }
280
281 member(LinkedObject **root);
282 member();
283
284 public:
285 inline void *operator*() const {
286 return mem;
287 }
288 };
289
290private:
291 unsigned members;
292 LinkedObject *root;
293 size_t typesize;
294 member *last;
295 void **index;
296
297 __DELETE_COPY(ObjectPager);
298
299protected:
300 ObjectPager(size_t objsize, size_t pagesize = 256);
301
308 void *get(unsigned item) const;
309
314 void *add(void);
315
316 void *push(void);
317
322 void *pull(void);
323
328 void *pop(void);
329
334 void *invalid(void) const;
335
336public:
341 void clear(void);
342
348 inline ObjectPager::member *begin(void) {
349 return static_cast<ObjectPager::member *>(root);
350 }
351
352 inline operator bool() const {
353 return members > 0;
354 }
355
356 inline bool operator!() const {
357 return !members;
358 }
359
364 inline unsigned count(void) const {
365 return members;
366 }
367
371 typedef linked_pointer<ObjectPager::member> iterator;
372
373 inline size_t size(void) {
374 return memalloc::size();
375 }
376
377 inline unsigned pages(void) {
378 return memalloc::pages();
379 }
380
381protected:
386 void **list(void);
387
388public:
393 void assign(ObjectPager& source);
394};
395
401class __EXPORT StringPager : protected memalloc
402{
403private:
404 unsigned members;
405 LinkedObject *root;
406
407public:
415 virtual bool filter(char *text, size_t size);
416
423 class __EXPORT member : public LinkedObject
424 {
425 private:
426 const char *text;
427
428 protected:
429 friend class StringPager;
430
431 inline void set(member *node)
432 {Next = node;}
433
434 member(LinkedObject **root, const char *data);
435 member(const char *data);
436
437 public:
438 inline const char *operator*() const {
439 return text;
440 }
441
442 inline const char *get(void) const {
443 return text;
444 }
445 };
446
451 StringPager(size_t pagesize = 256);
452
453 StringPager(char **list, size_t pagesize = 256);
454
459 inline unsigned count(void) const {
460 return members;
461 }
462
469 const char *get(unsigned item) const;
470
476 void set(unsigned item, const char *string);
477
482 void add(const char *text);
483
488 void push(const char *text);
489
494 void push(char **text);
495
500 const char *pull(void);
501
506 const char *pop(void);
507
513 void add(char **list);
514
520 void set(char **list);
521
526 void clear(void);
527
534 inline const char *operator[](unsigned item) const {
535 return get(item);
536 }
537
538 inline const char *at(unsigned item) const {
539 return get(item);
540 }
541
547 inline StringPager::member *begin(void) const {
548 return static_cast<StringPager::member *>(root);
549 }
550
555 inline void operator+=(const char *text) {
556 add(text);
557 }
558
563 inline StringPager& operator<<(const char *text) {
564 add(text);
565 return *this;
566 }
567
568 inline StringPager& operator>>(const char *text) {
569 push(text);
570 return *this;
571 }
572
576 void sort(void);
577
582 char **list(void);
583
592 unsigned token(const char *text, const char *list, const char *quote = NULL, const char *end = NULL);
593
594 unsigned split(const char *text, const char *string, unsigned flags = 0);
595
596 unsigned split(stringex_t& expr, const char *string, unsigned flags = 0);
597
598 String join(const char *prefix = NULL, const char *middle = NULL, const char *suffix = NULL);
599
600 inline operator bool() const {
601 return members > 0;
602 }
603
604 inline bool operator!() const {
605 return !members;
606 }
607
608 inline StringPager& operator=(char **list) {
609 set(list);
610 return *this;
611 }
612
613 inline const char *operator*() {
614 return pull();
615 }
616
617 inline operator char **() {
618 return list();
619 }
620
625
626 inline size_t size(void) const {
627 return memalloc::size();
628 }
629
630 inline unsigned pages(void) const {
631 return memalloc::pages();
632 }
633
634private:
635 member *last;
636 char **index;
637
638public:
643 void assign(StringPager& source);
644};
645
653class __EXPORT DirPager : protected StringPager
654{
655private:
656 __DELETE_COPY(DirPager);
657
658protected:
659 const char *dir;
660
668 virtual bool filter(char *filename, size_t size) __OVERRIDE;
669
675 bool load(const char *path);
676
677public:
678 DirPager();
679
680 DirPager(const char *path);
681
682 void operator=(const char *path);
683
684 inline const char *operator*() const {
685 return dir;
686 }
687
688 inline operator bool() const {
689 return dir != NULL;
690 }
691
692 inline bool operator!() const {
693 return dir == NULL;
694 }
695
696 inline unsigned count(void) const {
697 return StringPager::count();
698 }
699
706 inline const char *operator[](unsigned item) const {
707 return StringPager::get(item);
708 }
709
710 inline const char *get(unsigned item) const {
711 return StringPager::get(item);
712 }
713
714 inline const char *at(unsigned item) const {
715 return StringPager::get(item);
716 }
717
718 inline size_t size(void) const {
719 return memalloc::size();
720 }
721
722 inline unsigned pages(void) const {
723 return memalloc::pages();
724 }
725
726public:
731 void assign(DirPager& source);
732};
733
741class __EXPORT autorelease
742{
743private:
744 LinkedObject *pool;
745
746 __DELETE_COPY(autorelease);
747
748public:
753
758
764 void release(void);
765
771};
772
783class __EXPORT PagerObject : public LinkedObject, public CountedObject
784{
785private:
786 __DELETE_COPY(PagerObject);
787
788protected:
789 friend class PagerPool;
790
792
797
801 void reset(void);
802
803 void retain(void) __OVERRIDE;
804
808 void release(void) __OVERRIDE;
809
813 void dealloc(void) __OVERRIDE;
814};
815
824class __EXPORT PagerPool : public __PROTOCOL MemoryProtocol
825{
826private:
827 LinkedObject *freelist;
828 mutable pthread_mutex_t mutex;
829
830 __DELETE_COPY(PagerPool);
831
832protected:
833 PagerPool();
834 virtual ~PagerPool();
835
836 PagerObject *get(size_t size);
837
838public:
843 void put(PagerObject *object);
844};
845
852template <typename T>
853class pager : private MemoryRedirect, private PagerPool
854{
855private:
856 __DELETE_COPY(pager);
857
858public:
863 inline pager(mempager *heap = NULL) : MemoryRedirect(heap), PagerPool() {}
864
869 inline T *operator()(void) {
870 return new(get(sizeof(T))) T;
871 }
872
877 inline T *operator*() {
878 return new(get(sizeof(T))) T;
879 }
880};
881
886
891
896
897inline String str(StringPager& list, const char *prefix = NULL, const char *middle = NULL, const char *suffix = NULL) {
898 return list.join(prefix, middle, suffix);
899}
900
901} // namespace ucommon
902
903#endif
Linked objects, lists, templates, and containers.
Various miscellaneous platform specific headers and defines.
Abstract interfaces and support.
Common namespace for all ucommon objects.
Definition access.h:47
DirPager dirlist_t
A convenience type for using DirPager directly.
Definition memory.h:895
T & limit(T &value, T &low, T &high)
Convenience macro to range restrict values.
Definition generics.h:468
StringPager stringlist_t
A convenience type for paged string lists.
Definition memory.h:885
StringPager::member stringlistitem_t
A convenience type for paged string list items.
Definition memory.h:890
Convenience class for directories.
Definition fsys.h:744
Common base class for all objects that can be formed into a linked list.
Definition linked.h:56
A smart pointer template for iterating linked lists.
Definition linked.h:992
A memory protocol pager for private heap manager.
Definition memory.h:62
size_t size(void) const
Get the size of a memory page.
Definition memory.h:125
void purge(void)
Purge all allocated memory and heap pages immediately.
page_t * pager(void)
Acquire a new page from the heap.
virtual void * _alloc(size_t size)
Allocate memory from the pager heap.
virtual ~memalloc()
Destroy a memory pager.
memalloc(size_t page=0)
Construct a memory pager.
unsigned pages(void) const
Get the number of pages that have been allocated from the real heap.
Definition memory.h:106
void assign(memalloc &source)
Assign foreign pager to us.
unsigned max(void) const
Get the maximum number of pages that are permitted.
Definition memory.h:117
unsigned utilization(void) const
Determine fragmentation level of acquired heap pages.
A managed private heap for small allocations.
Definition memory.h:185
virtual ~mempager()
Destroy a memory pager.
virtual void _unlock(void)
Unlock the memory pager mutex.
virtual void _lock(void)
Lock the memory pager mutex.
void purge(void)
Purge all allocated memory and heap pages immediately.
unsigned utilization(void)
Determine fragmentation level of acquired heap pages.
virtual void * _alloc(size_t size)
Allocate memory from the pager heap.
void assign(mempager &source)
Assign foreign pager to us.
virtual void dealloc(void *memory)
Return memory back to pager heap.
mempager(size_t page=0)
Construct a memory pager.
String pager for storing lists of NULL terminated strings.
Definition memory.h:402
const char * pull(void)
Remove element from front of list.
const char * operator[](unsigned item) const
Return specified member from pager list.
Definition memory.h:534
void set(char **list)
Set list to list.
char ** list(void)
Gather index list.
void add(char **list)
Add list to list.
linked_pointer< StringPager::member > iterator
Convenience typedef for iterative pointer.
Definition memory.h:624
unsigned token(const char *text, const char *list, const char *quote=NULL, const char *end=NULL)
Tokenize a string and add each token to the StringPager.
void sort(void)
Sort members.
StringPager::member * begin(void) const
Get root of pager list.
Definition memory.h:547
void set(unsigned item, const char *string)
Replace string item in list.
void operator+=(const char *text)
Convenience operator to add to pager and auto-sort.
Definition memory.h:555
void assign(StringPager &source)
Assign foreign pager to us.
const char * get(unsigned item) const
Get string item from list.
const char * pop(void)
Remove element from back of list.
unsigned count(void) const
Get the number of items in the pager string list.
Definition memory.h:459
void add(const char *text)
Add text to list.
virtual bool filter(char *text, size_t size)
Filter text in a derived class.
StringPager(size_t pagesize=256)
Create a pager with a maximum page size.
void push(const char *text)
Add text to front of list.
StringPager & operator<<(const char *text)
Convenience operator to add to pager.
Definition memory.h:563
void push(char **text)
Add text list to front of list.
void clear(void)
Purge all members and release pager member.
Member of string list.
Definition memory.h:424
Directory pager is a paged string list for directory file names.
Definition memory.h:654
virtual bool filter(char *filename, size_t size)
Filter filenames in a derived class.
bool load(const char *path)
Load a directory path.
const char * operator[](unsigned item) const
Return specified filename from directory list.
Definition memory.h:706
void assign(DirPager &source)
Assign foreign pager to us.
Create a linked list of auto-releasable objects.
Definition memory.h:742
void operator+=(LinkedObject *object)
Add a linked object to the autorelease pool.
autorelease()
Create an initially empty autorelease pool.
void release(void)
Destroy an autorelease pool and delete member objects.
~autorelease()
Destroy an autorelease pool and delete member objects.
This is a base class for objects that may be created in pager pools.
Definition memory.h:784
void retain(void)
Retain by marking as self referenced list.
void dealloc(void)
Return the pager object back to it's originating pool.
void reset(void)
Reset state of object.
void release(void)
Release a pager object reference.
PagerObject()
Create a pager object.
Pager pool base class for managed memory pools.
Definition memory.h:825
void put(PagerObject *object)
Return a pager object back to our free list.
Mempager managed type factory for pager pool objects.
Definition memory.h:854
pager(mempager *heap=NULL)
Construct a pager and optionally assign a private pager heap.
Definition memory.h:863
T * operator()(void)
Create a managed object by casting reference.
Definition memory.h:869
T * operator*()
Create a managed object by pointer reference.
Definition memory.h:877
A base class for reference counted objects.
Definition object.h:57
A redirection base class for the memory protocol.
Definition protocols.h:101
Common locking protocol.
Definition protocols.h:119
A copy-on-write string class that operates by reference count.
Definition string.h:79
A common string class and character string support functions.