Return to pool.3 CVS log

Up to [Research Unix] / researchv10dc / man / adm / man3

Annotation of researchv10dc/man/adm/man3/pool.3, revision 1.1

1.1     ! root        1: .TH POOL 3+
        !             2: .CT 2 datatype
        !             3: .SH NAME
        !             4: pool \- fast memory allocation
        !             5: .SH SYNOPSIS
        !             6: .nf
        !             7: .B #include <Pool.h>
        !             8: .PP
        !             9: .ft L
        !            10: struct Pool {
        !            11:        Pool(unsigned);
        !            12:        ~Pool();
        !            13:        void* alloc();
        !            14:        void free(void*)
        !            15: };
        !            16: .fi
        !            17: .SH DESCRIPTION
        !            18: .PP
        !            19: Every
        !            20: .L Pool
        !            21: is a collection of
        !            22: .IR elements ,
        !            23: each of which is an array of bytes.
        !            24: All elements of a pool
        !            25: are the same size.
        !            26: Pool functions are
        !            27: .nr xx \w'\fIp\fL.free(\fIep\fL)\ '
        !            28: .TP \n(xxu
        !            29: .BI Pool( n )
        !            30: Construct a pool whose elements are of size
        !            31: .I n.
        !            32: .TP
        !            33: .IB p .alloc()
        !            34: Allocate a new element in pool
        !            35: .LR p .
        !            36: Return a pointer to the element.
        !            37: .TP
        !            38: .IB p .free( ep )
        !            39: Free the element of
        !            40: .I p
        !            41: pointed to by
        !            42: .I ep.
        !            43: The element must
        !            44: have been allocated from
        !            45: .I p.
        !            46: .PP
        !            47: Destroying a pool
        !            48: frees all the memory occupied by its elements.
        !            49: .PP
        !            50: The memory in a pool element is aligned on
        !            51: the same boundary as memory returned by
        !            52: .IR malloc (3)
        !            53: so that it may be used to contain an
        !            54: object of any type.
        !            55: In typical use, there would be one pool per class, with
        !            56: the pool known only to the 
        !            57: .B new
        !            58: and
        !            59: .B delete
        !            60: operators of that class.
        !            61: .SS Performance
        !            62: Pool memory is allocated in chunks that are typically
        !            63: about 1,000 bytes each.
        !            64: Once a chunk is allocated to a particular pool,
        !            65: that chunk is only released when the pool itself
        !            66: is destroyed.
        !            67: .PP
        !            68: Elements are allocated inline except when 
        !            69: a new chunk must be added to the pool.
        !            70: Elements are always freed inline.
        !            71: .SH EXAMPLES
        !            72: .B #include <Pool.h>
        !            73: .PP
        !            74: .EX
        !            75: struct Mytype {
        !            76:        static Pool mypool;
        !            77:        // constructors and members
        !            78:        void* operator new(unsigned) { return mypool.alloc(); }
        !            79:        void operator delete(void* p) { mypool.free(p); }
        !            80: };
        !            81: .EE
        !            82: .PP
        !            83: .B Pool Mytype::mypool(sizeof(Mytype));
        !            84: .SH SEE ALSO
        !            85: .IR malloc (3)

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.