1 / 19

Win32 Programming

Win32 Programming. Lesson 16: Virtual Memory. Where are we?. We’ve covered the theory of Windows memory, and poked around some Now let’s use how to use memory. Three ways to Use Memory. Virtual Memory – Best for very large arrays and structures

berne
Download Presentation

Win32 Programming

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Win32 Programming Lesson 16: Virtual Memory

  2. Where are we? • We’ve covered the theory of Windows memory, and poked around some • Now let’s use how to use memory

  3. Three ways to Use Memory • Virtual Memory – Best for very large arrays and structures • Memory-mapped files – Good for managing data streams and sharing memory between applications • Heaps – Best for managing large numbers of small objects

  4. Reserving Memory • Fairly straightforward: • PVOID VirtualAlloc(    PVOID pvAddress,    SIZE_T dwSize,    DWORD fdwAllocationType,    DWORD fdwProtect);

  5. Parameters • pvAddress: Usually NULL, but can be where you would like the memory • dwSize: How much memory you would like • dwAllocationType: Should we RESERVE memory or COMMIT it? • dwProtection: The type of memory protection on this area of memory

  6. Before Use… • Once you have reserved memory, you need to commit it before the pages can be accessed • Same call, but you use the parameters slightly differently • You don’t have to COMMIT all the region – you just need to COMMIT pages • Why is this a Good Thing?

  7. Can do it all in one go… • Can bitwise-OR the flags… • Just like this: • PVOID pvMem = VirtualAlloc( NULL,  99 * 1024,     MEM_RESERVE | MEM_COMMIT,  PAGE_READWRITE); • Can also specify MEM_TOP_DOWN

  8. Knowing When to Commit • Let’s say you’re writing a spreadsheet application (gee, there’s a good idea…) • Why doesn’t Excel crash the system when it loads a spreadsheet (well, usually…)

  9. MEM_LARGE_PAGE • New addition to VirtualAlloc • Higher performance, as we can allocate a large page of memory • These pages are not pageable however • SIZE_T GetLargePageMinimum();

  10. Determining the State of an Address • Four ways… • Always call COMMIT – but this is slow because it’s often (usually?) unnecessary • Use VirtualQuery to map the state and commit if necessary • Keep a record of which pages you’ve committed and which you have – can be complicated • Use SEH to catch memory exceptions and COMMIT on error (best way)

  11. Must Decommit • If you don’t want to kill the machine, it’s good to decommit memory • BOOL VirtualFree(    LPVOID pvAddress,     SIZE_T dwSize,    DWORD fdwFreeType); • Pass 0 for dwSize as the system already knows it • Must pass MEM_RELEASE

  12. Knowing when is the trick… • Consider our Spreadsheet example • Make each cell a page (not very practical, but very simple) • Keep track of which cells are on which page • Implement a garbage collection function which checks the state of cells

  13. Bug Hunting… • Sometimes protecting memory can help tremendously when hunting bugs and coding defensively • Can use VirtualProtect to change access when we’re not using memory • If a rogue pointer blats into your memory, you’re protected

  14. Physical Storage • Knowledge of the underlying system can help tremendously when trying to improve performance • For example, imagine you have some memory which you use for short periods of time… • How does the design of the system potentially slow things down?

  15. RESETting Memory • When the system looks to free physical memory it has to write RAM to the paging file • But what if you say that the memory to swap isn’t important? That is, the changes don’t need to be kept? • If you have write-access but the changes aren’t needed you can RESET the memory

  16. Example • PINT pnData = (PINT) VirtualAlloc( NULL,  1024,      MEM_RESERVE | MEM_COMMIT,  PAGE_READWRITE); pn[0] = 100; pn[1] = 200; VirtualAlloc( (PVOID) pnData,  sizeof(int),  MEM_RESET,  PAGE_READWRITE);

  17. MEM_RESET • One thing to remember is that the MEM_RESET flag doesn’t work if you OR it with anything else • It only makes sense used on its own

  18. Cool Stuff: AWE • Address Windowing Extensions • Allows the program to access more memory than fits in its process space • Introduced in Windows 2000 • Uses AllocateUserPhysicalPages • Then MAP to a Window: • BOOL MapUserPhysicalPages(    PVOID pvAddressWindow,   ULONG_PTR ulRAMPages,    PULONG_PTR aRAMPages); 

  19. Stack Space • Each thread stack exists in the process’ address space • Very clever – assigns a “guard page” so that the system knows when to commit more memory to the stack • When the stack grows too far, generates a EXCEPTION_STACK_OVERFLOW • Can handle via a SEH – we’ll talk about that later in the term

More Related