Windows Programming Anamnesis Subsystem

 08 February 06:59   

    C programmers will undoubtably be accustomed with the stdlib anamnesis allocation functions, malloc, realloc, calloc, etc. These functions are based off a amount of additional functions in the Win32 API that accord with anamnesis segments.

    When talking about the anamnesis subsystem, there are 4 audible types of anamnesis that windows manages, and anniversary blazon of anamnesis has a amount of altered functions to allocated and chargeless that memory.

    ;Virtual Memory: The Basic Anamnesis subsystem allocates and manages anamnesis by pages. This agency that anamnesis can alone be allocated in blocks of 4096Kbytes at a time. This is a fantastically ample bulk of anamnesis for alotof applications, and using the basic anamnesis functions in alotof programs is overkill. However, some programs do charge use of absolute pages for storage, so the Basic Anamnesis subsystem can be acclimated for that.

    ;Heap Memory: The abundance is an breadth of anamnesis that usually takes up a accomplished page, or a atom of a page. Anniversary action is allocated a abundance anon by windows, alleged the action heap. The stdlib functions such as malloc will admeasure anamnesis from this anamnesis region. The abundance can be disconnected up into baby anamnesis segments, for use with variables and activating storage.

    ;Global Memory: windows maintains at atomic 1 page of anamnesis for use as general-purpose all-around memory. This anamnesis can be apprehend or accounting by any action active on the computer, using the all-around anamnesis functions. Data in the all-around anamnesis amplitude can be aggregate apartof assorted programs, and items beatific to the windows clipboard are about stored in all-around anamnesis (so it can be pasted into any program). All-around anamnesis is limited, so it should not be acclimated after a specific need.

    ;LocalMemory: Bounded anamnesis has similarities to both all-around anamnesis and abundance memory. It is bounded to the process, but the anamnesis is managed by the windows anamnesis manager, and not by the program. We will altercate this later.

    The basic anamnesis functions, as explained above, admeasure anamnesis in agreement of pages. Pages are about 4096Kbytes of memory, so alotof applications wont charge to admeasure an absolute page (much beneath added then 1 page). The Basic anamnesis arrangement is about the archaic action abject that the additional anamnesis functions advance to accomplish their tasks. For instance, the abundance is comprised of 1 or added pages, and the abundance functions will admeasure pages using the basic anamnesis arrangement if needed.

    When basic anamnesis blocks are allocated, they are not infact getting utilized, they are artlessly aloof by the arrangement for approaching use. Additional functions charge to be acclimated to articulation the basic anamnesis pages into advantageous segments. Back basic anamnesis is allocated by pages, a amount of appropriate paging appearance can be acclimated on basic anamnesis that can not be acclimated on additional types of memory. For instance, pages can be bound (to anticipate read/write access), or they can be adequate from any accurate admission approach (read, write, execute).

    That said, there are a amount of functions in the basic anamnesis subsystem that can be used:

    ;VirtualAlloc:

    ;VirtualFree:

    ;VirtualProtect:

    ;VirtualLock:

    ;VirtualQuery:

    Each program is provided with a absence action heap, but a action may optionally admeasure any amount of added heaps, if added accumulator is needed. The abundance functions will administer their basic anamnesis acceptance automatically, and accordingly abundance can be set to abound if they are getting abounding up with data. If a abundance is accustomed to abound automatically, the abundance functions will automatically admeasure added pages as needed. On the x86 architectonics the abundance grows in admeasurement appear college anamnesis addresses.

    To use abundance memory, a abundance haveto first be allocated (or a handle haveto be acquired to the absence heap). Already you accept acquired a handle to a heap, you can canyon that handle to the anamnesis allocation functions, to admeasure anamnesis from that accurate heap.

    The stdlib anamnesis functions (malloc, realloc, calloc, free) are all acclimated actual analogously to the abundance functions, so programmers accustomed with the stdlib functions may be able to amount out what some of the abundance functions are doing, by analytical their names:

    ;HeapCreate:

    ;HeapDestroy:

    ;GetProcessHeap:

    ;HeapAlloc:

    ;HeapReAlloc:

    ;HeapFree:

    When data has been accounting to the all-around memory, you dont get a arrow to that data, but instead you get a handle for that data. Already you accord your data to the all-around anamnesis manager, the arrangement is in allegation of it. Remember, a handle is not a pointer, and should never be acclimated as one. The arrangement will administer the anamnesis in the all-around anamnesis section, affective it amid pages, and defragmenting it, et cetera.

    ;GlobalAlloc:

    ;GlobalFree:

    ;GlobalDiscard:

    ;GlobalLock:

    ;GlobalUnlock:

    ;GlobalFlags:

    ;GlobalSize:

    ;GlobalHandle:

    Local memory, in this sense, is not the affectionate of accumulator that programs advance internally, on the assemblage and otherwise. Instead, windows manages a appropriate area of anamnesis that it dubs to be Bounded Memory, and it provides a amount of functions to admeasure and administer this appropriate memory. Bounded anamnesis is agnate to all-around anamnesis in the faculty that data is accounting to the bounded location, and the arrangement allotment a handle to that data. The arrangement will administer the data, just like in all-around memory. The bounded functions are called actual analogously to the all-around anamnesis functions. However, the all-around anamnesis and bounded anamnesis functions should never be mixed. For instance, a all-around anamnesis handle should never be bankrupt with the LocalFree function.

    ;LocalAlloc:

    ;LocalFree:

    ;LocalDiscard:

    ;LocalFlags:

    ;LocalLock:

    ;LocalReAlloc:

    ;LocalUnlock:

    ;LocalHandle: