Tour De Linux Memory Management -

10m ago
597.53 KB
36 Pages
Last View : 6m ago
Last Download : 3m ago
Upload by : Axel Lin

Tour de Linux memory managementMichal HockoSuse

Documentation & Upstream development Documentation/vm Many very good articlesUnderstanding The Linux Virtual Manager – by Mel Gorman Quite ad-hoc – systematic design documentation is missingVery good and systematic coverage but too old – from 2.4 era (with What’snew in 2.6 sections)Still very useful to understand core design am development Mailing list linux-mm@kvack.orgPatches routed usually via Andrew Morton andhist mm treeCode lives mostly in mm/ and many include files2

Purpose and the scope of MM Manage system RAM Support for memory over-commit Architecture independent view on the memorySupport for UMA/NUMA architecturesMemory hotplug support – used by NVDIMMsVirtual memoryOn demand memory reclaimCopyOnWriteSupport also for MMUless architectures3

Purpose and the scope of MMAPIs for kernel Bootmem/memblock allocator – early initializationPage allocator – page order (2N physically contiguous pages)SLAB allocator – sub page granularity, internal fragmentationmanagement Vmalloc – virtually contiguous memory allocator – via page tablesMempool allocator Guarantee for a forward progress – mostly for IO pathsPage cache management for filesystemsMemory tracking for userspace – process managementPage table management SLOB – very rudimentary for small devicesSLAB – based on Solaris design – optimized for CPU cache efficiency, NUMA awareSLUB – new generation design – aimed for better scalabilityget user pages – virtual struct page translationOn-demand memory paging4

Purpose and the scope of MMAPIs for userspace Syscalls to manage memory Memory backed filesystems Mostly for user space consumption limiting, kernel allocations are opt-inSupport for hard limit, soft/low limit, swap configuration, userspace OOM killerAccess to huge pages (2MB, 1GB) Ramdisk – fixed sized memory backed block deviceRamfs – simple memory backed filesystemTmpfs – more advanced memory backed filesystem, support for swapout, ACL, extended attributesMemory cgroups controller – more fine grained partitioning of the system memory mmap, munmap, mprotect, brk, mlock – POSIXmadvise – hints from userspace e.g. MADV DONTNEED, MADV FREE etc.userfaultfd – page fault handling from userspaceSystemV shared memory – IPC, shmget, shmat, shmdtmemfd create – anonymous memory referenced by a file descriptor – for IPCHugetlbfs – filesystem backed by preallocated huge pagesTHP – transparent huge pagesNUMA allocation policies Mbind, set mempolicy, get mempolicy5

Physical Memory representation Managed in page size granularity – arch specific, mostly 4kBEach page is represented by struct pageHeavily packed – 64B on 64b systems ( 1.5% with 4kB pages) Statically allocated during boot/memory hotplug - memmapReference counted Lots of unions to distinguish different usageSpecial tricks to save space – set bottom bits in addresses etc.get page(), put page(), get page unless zero(),put page test zero()memory is returned to the page allocator when 0pfn valid(), pfn to page(), page to pfn() – physical pageframe number to struct page translationpage owner – tracks stack of the allocation request – very usefulfor debugging6

Physical Memory representation Memory ranges exported by BIOS/EFI firmware E820 for x86 systems[0.000000] e820: BIOS-provided physical RAM map:[0.000000] BIOS-e820: [mem 0x0000000000000000-0x000000000009dbff] usable[0.000000] BIOS-e820: [mem 0x000000000009dc00-0x000000000009ffff] reserved[0.000000] BIOS-e820: [mem 0x00000000000f0000-0x00000000000fffff] reserved[0.000000] BIOS-e820: [mem 0x0000000000100000-0x00000000bf61ffff] usable[0.000000] BIOS-e820: [mem 0x00000000bf620000-0x00000000bf63bfff] ACPI data[0.000000] BIOS-e820: [mem 0x00000000bf63c000-0x00000000bf63cfff] usable[0.000000] BIOS-e820: [mem 0x00000000bf63d000-0x00000000cfffffff] reserved[0.000000] BIOS-e820: [mem 0x00000000fec00000-0x00000000fee0ffff] reserved[0.000000] BIOS-e820: [mem 0x00000000ff800000-0x00000000ffffffff] reserved[0.000000] BIOS-e820: [mem 0x0000000100000000-0x000000403fffefff] usable Memory model defines how we represent physical memory ranges Flatmem – the simplest one, single range of physical memory, doesn’t support NUMADiscontigmem – more advanced, supports holes, NUMA, doesn’t support memoryhotplugSparsemem – the most widely used, supports NUMA, memory hotplug, keeps track ofmemory range in memory sections Vmemmap sparsemem – virtually contiguous memory map via page tables, very efficientpfn to page (simple pointer arithmetic)7

Page flags enum pageflags – describes the state of the pagePG NAME are accessed via Page NAME(), SetPage NAME(),TestSetPage NAME(), ClearPage NAME(), TestClearPage NAME() Defined by macrosPAGEFLAG(Referenced, referenced, PF HEAD)TESTCLEARFLAG(Referenced, referenced, PF HEAD)SETPAGEFLAG(Referenced, referenced, PF HEAD) Atomic updatesNon atomic variants SetPage NAME, ClearPage NAMEPage lock is implemented as bit lockUpper part of flags is used to encode numa node/section nr, zoneid8

Physical Memory representation NUMA node represented by struct pglist dataUMA machines have one static numa node, NUMA has an array ofnodesSRAT tables on x86 systems – describe nodes, distancesKswapd kernel thread for the background memory reclaimLRU lists for the memory reclaimFree pages are maintained on the per-zone basesCounters - /proc/zone info9

[0.000000] ACPI: SRAT: Node 0 PXM 0 [mem 0x00000000-0xbfffffff][0.000000] ACPI: SRAT: Node 0 PXM 0 [mem 0x100000000-0x103fffffff][0.000000] ACPI: SRAT: Node 1 PXM 1 [mem 0x1040000000-0x203fffffff][0.000000] ACPI: SRAT: Node 2 PXM 2 [mem 0x2040000000-0x303fffffff][0.000000] ACPI: SRAT: Node 3 PXM 3 [mem 0x3040000000-0x403fffffff][0.000000] NUMA: Node 0 [mem 0x00000000-0xbfffffff] [mem 0x100000000-0x103fffffff] - [mem 0x000000000x103fffffff][0.000000] NODE DATA(0) allocated [mem 0x103ffde000-0x103fffffff][0.000000] NODE DATA(1) allocated [mem 0x203ffde000-0x203fffffff][0.000000] NODE DATA(2) allocated [mem 0x303ffde000-0x303fffffff][0.000000] NODE DATA(3) allocated [mem 0x403ffdd000-0x403fffefff] numactl -Havailable: 4 nodes (0-3)node 0 cpus: 0 4 8 12 16 20 24 28 32 36 40 44 48 52 56 60node 0 size: 64295 MBnode 0 free: 53958 MBnode 1 cpus: 1 5 9 13 17 21 25 29 33 37 41 45 49 53 57 61node 1 size: 64509 MBnode 1 free: 48875 MBnode 2 cpus: 2 6 10 14 18 22 26 30 34 38 42 46 50 54 58 62node 2 size: 64509 MBnode 2 free: 50959 MBnode 3 cpus: 3 7 11 15 19 23 27 31 35 39 43 47 51 55 59 63node 3 size: 64507 MBnode 3 free: 33646 MBnode 2020201010

Physical Memory representation Memory zones for the page allocator – struct zone Defines a class of memory ZONE DMA – low 16MB for legacy HW (ISA buses) ZONE DMA32 – low 4GB for 32b restricted devices ZONE NORMAL – memory usable by the kernel directly ZONE HIGHMEM – memory for userspace on 32b systems – has to be mapped to beused from the kernelZONE MOVABLE – allocations which can be migrated – mostly user memory, pagecacheZONE DEVICE – special zone to describe device memory – non-volatile memoryDAX, non-coherent device memory HMM Free pages maintained in zone::free area Watermarks to limit access to free pages zone::watermark[]11

Virtual Memory representation 48b (128TB) view of contiguous memory which is translated to the physicalmemory by page tablesSupport for future 52b (4PB) physical address space in 5-level pte (57b ofvirtual) Explicit opt in to use in userspace by addr hint to mmapKernel vs. User space view Virtual address space is split to kernel and userspace Kernel part is static and doesn’t change with context switches32b - Lowmem (1GB for direct usage) vs. Highmem (3GB) Only low mem can be accessed directly, highmem has to be mapped temporarily Only 896MB usable – 128MB reserved for vmalloc and kmap0000000C000000F7xxxxxFF80000 ––––BFFFFFFF user spaceF7xxxxxx kernel (direct mapping)FF7FE0000 vmallocFFC000000 kmap64b – negative address space kernel, positive userspace0000000000000000 – 00007FFFFFFFFFFF – user spaceFFFF880000000000 – FFFFC7FFFFFFFFFF – direct mappingFFFFC90000000000 – FFFFE8FFFFFFFFFF – vmalloc Kernel space is configured to use direct 1:1 mapping Translation is a simple arithmetic operation ( va(), pa())12

Virtual Memory representation Page table walkers use unified 5 page table levels pgd t, p4d, pud t, pmd t and pte tpgd alloc, pgd none, pgd index, pgd offset etc.Architectures with a different pte topology emulate 5 levels (e.g.include/asm-generic/5level-fixup.h)Simple page table walkpgd pgd offset(mm, addr) /* mm of the process or init mm */P4d p4d offset(pgd, addr)pud pud offset(p4d, addr)pmd pmd offset(pud, addr)pte pte offset map lock(mm, pmd, addr, &ptl) Once we have pte – vm normal page() pte pfn() pfn to page with some special casing for special mappings13

Address space descriptor Each process has its address space descriptor struct mm structKeeps track of all the maped memory mm struct::mmap – linked list of all mapped areas (VMA) mm struct::mm rb – RedBlack tree for quick VMA lookups - find vmaReference counted mm count – mmgrab(), mmdrop() mm users – mmget(), mmget not zero(), mmput() Number of mm struct users – last reference will free the data structureNumber of users of the address space – last user will unmap the whole address spaceLinks to the top page table entry – mm struct::pgdCounters – number of page table entries, locked memory, high rssetc mmap sem – RW lock to serialize address space operations And more abusers unfortunately14

Address space descriptor Mapped memory range struct vm area structCreated for mmap, brk, special mappings (VDSO)vm flags Access protection – VM READ, VM WRITE, VM EXEC Mlock status – VM LOCKED Special mappnig – VM IO, VM PFNMAP, VM MIXEDMAPLink to the mapped object – vm file or anon vmaMemory policy for the areaSet of “virtual functions” - vm ops How to handle page fault – fault()Notify the backing store that a read only page will become writable –page mkwrite() – FS can refuse due to ENOSPACE and process will get SIGBUSOther hooks for special device mappings15

On demand paging HW (onx86) will trigger #PF exception when the pte is not mapped or the currentprotection doesn’t allow requested operation (e.g. Write on ReadOnly pte).do page fault – main entry – arch specific A lot of special casing – e.g. faults from kernel, fixups, errata workarounds etcTake mmap sem in read modefind vma – no VMA SEGVExpand stack VMAs – VM GROWS {UP,DOWN}handle mm fault – arch independent page fault handling Wrong access SEGVhandle mm fault pte walk, handle large pages (PUD, PMD) or handle pte fault for basepages do anonymous page – allocates a new page, setups page table, reverse mapping, adds page the LRU list do fault – relies on vm ops fault() - many filesystems rely on filemap fault do swap page – swapped out page – swap it in do numa page – used by numa balancing do wp page – break CoW page – allocate new anonymous page for private mappingsParallel page faults are handled by rechecking pte against the saved one under the page table lock(pte same())16

page VMA mappings How to get from struct page to all mappings? (mm/rmap.c) rmap walk – rmap walk control defines callback to call for each mappingpage::mapping, page::index Anonymous pages – page::mapping has the lowest bit set anon vma page mapping & PAGE MAPPING FLAGS Address space of all anonymous pages – hierarchical tree of interval treesINTERVAL TREE DEFINE(struct anon vma chain, rb, unsigned long, rb subtree last,avc start pgoff, avc last pgoff,static inline, anon vma interval tree) More on pgoff page index anon vma interval tree foreach – iterates over all VMAs which contain pgoffFile backed pages Mapping points to struct address space – one per each inode/block device mapping i mmap contains interval tree of all VMAs vma interval tree foreach iterates over all VMAs which contain pgoff17

Address space – gluing it togethermm structVMAVMAVMAanon vmavm filestruct filestruct anon vmaf inodestruct inodei mappingrb rootstruct anon vma chaini mmapstruct address spacemapping & PAGE MAPPING FLAGSmappingstruct pageindexindexstruct page18

Page cache management address space::page tree - radix tree of pages belonging to theinode – move to xarray in the recent pastfilemap fault find get page Returns an existing page from the radix tree or allocates a new onepage cache alloc() and inserted to the radix treeadd to page cache locked() and LRU listPage is locked and !PageUptodate() if newly allocateddo async mmap readahead() – triggers asynchronous read from thebacking storage (including readahead).do sync mmap readahead() – synchronous readread pages – mapping a ops readpages() – to do the actual read fromthe (fs usually use mpage readpages())Once we have the content – SetPageUptodate() PageUnlock()19

Page allocator alloc pages nodemask(gfp t gfp mask, unsigned int order, struct zonelist *zonelist,nodemask t *nodemask) to get a struct pageget free pages() to get a directly usable pointer – use with care!gfp mask – bitmask for the allocation mode Request specific zones – GFP DMA, GFP DMA32, GFP HIGHMEM, GFP MOVABLE GFP NOWAIT, GFP ATOMIC – non sleeping allocations, no direct reclaim GFP KERNEL – standard kernel allocations GFP USER, GFP USER MOVABLE – allocations for userspace GFP NOFAIL – non-failing allocations GFP NOFS, GFP NOIO – do not recurse to fs perform any IO from the reclaimOrder – size of the allocation 2 order contiguous pages PAGE ALLOC COSTLY ORDER (3) – small allocations are special – trigger OOM killer rather than failZonelists – list of zones to allocate from Start with zones of a local or requested node - node zonelist() build zonelists() - numa zonelist order kernel boot parameter – node order, zone orderNodemask to filter only allowed nodes defined by memory policy Note that there is also cpuset API to overrule memory policiesFunny things will happen if those two disagree20

Page allocator Slow path quite complex Core of the page allocator – get page from freelist() Wake up kswapd/kcompactdTriggers direct memory reclaim/compaction when neededTriggers the OOM killer when no progress was made during the reclaimChecks watermarks to not allow memory depletionPer-cpu allocation for order-0 – no locking, batch refill, freeing - rmqueue pcplist()rmqueue() for other ordersBased on buddy allocator Physically contiguous pages are grouped in 2N chunks2 2N-1 blocks are merged to 2N when page is freed - free one page()A larger block is split up when appropriate is not available - rmqueue smallest()vs rmqueue fallback() cat /proc/buddyinfoNode 0, zoneDMA10101110113Node 0, zoneDMA327435357542538Node 0, zoneNormal438445339715888773671777436731221

Memory reclaim Background reclaim The main logic implemented in balance pgdat()Direct reclaim All eligible zones hit the min watermark Tries to free SWAP CLUSTER MAX pages The main logic implemented in try to free pages()Node reclaim – former zone reclaim Kernel thread per NUMA nodeStarts when free memory hit low watermark on all zones eligible for the allocation –pgdat balanced()Reclaims until high watermark is hitEnforce direct reclaim on the requested node firstUsed to be enabled on NUMA machines with large numa distances in the pastHas to be enabled explicitly - /proc/sys/vm/zone reclaim modeOOM killer Last despair attempt to free memory by killing the task with the largest memory consumptionoom reaper – kernel thread to unmap memory of the oom victimVery tricky to get right22

Memory reclaim Reclaimable pages are sitting on LRU lists – struct lruvecenum lru list {LRU INACTIVE ANON LRU BASE,LRU ACTIVE ANON LRU BASE LRU ACTIVE,LRU INACTIVE FILE LRU BASE LRU FILE,LRU ACTIVE FILE LRU BASE LRU FILE LRU ACTIVE,LRU UNEVICTABLE,NR LRU LISTS}; Used to have LRU lists per zones, now we have one per node Pages are added to the list when allocatedAnonymous pages start on the active listFile pages start on the inactive list Pages freed recently are put to the active list - workingset refault()Promotion from inactive to active list based on pte references –page check references() Actually per memory cgroup – more on that laterUsed once heuristic for file pagesExecutable pages protectionActive list is shrunk when it grows too large – inactive list is low()23

Memory reclaim Each reclaim pass has a priority – starting from DEF PRIORITY (12) get scan count() - keeps balance between file and anonymous lru lists Highly biased to reclaim file pages/proc/sys/vm/swappinessConsiders recently scanned and rotated pages for each LRUisolate lru pages() - removes pages from the LRU list in a batch for further inspection Size of the window to scan LRU lists – lruvec lru size() priorityReduces the lock contentionSkip over ineligible pages – e.g. highmem pages for GFP KERNEL requestshrink page list() - core of the reclaim Referenced pages are promoted to the active listAnonymous pages are added to the swap cache and scheduled for swapout - add to swap()Dirty file pages are written out – pageout() - only in kswapd contextMapped pages are unmapped – try to unmap one() Anonymous ptes will point to swap entries, MADV FREE pages are dropped Dirty pte states is moved to struct page – set page dirty()remove mapping() Dirty pages are not removed – protection for racesRemove from the page cache (including swap cache) – records the eviction time for file cacheworkingset eviction()24

Memory reclaim Many types of SLAB allocations are reclaimable Dentry, inode cache etc Register their shrinkers Not restricted to slab objects onlystruct shrinker {unsigned long (*count objects)(struct shrinker *,struct shrink control *sc);unsigned long (*scan objects)(struct shrinker *,struct shrink control *sc);int seeks;/* seeks to recreate an obj */long batch;/* reclaim batch size, 0 default */unsigned long flags;/* These are for internal use */struct list head list;/* objs pending delete, per node */atomic long t *nr deferred;}; shrink slab() Invokes shrinkers – count objects() to see how many are freeable, scan objects willreclaim and ageCan be really inefficient because it is object rather than page based – internalfragmentation25

Huge pages in Linux Kernel mapping of physical memoryUses 1GB or 2MB huge pages when possible Direct mapping, ioremap() for device memory rangesExplicit hugepage usage – HugeTLBfs Pre-allocated in pools, accessible by several interfaces Private or shared, no splitting, no swapping Multiple sizes supported; page table sharing supportTransparent hugepage usage – THP Allocated implicitly, possible to prefer or disallow by hints Anonymous, private (except fork COW), can be split back to base pagesand then swapped out Shmem/tmpfs support – controlled via mount parameter

HugeTLBfs Usage SysV shared memory segment Sice 3.8: same alternative flags as shmget()mount -t hugetlbfs none /dev/hugepages -o pagesize 2M fd open(“/dev/hugepages/1”, O CREAT O RDWR, 0755);addr mmap(NULL, SIZE, PROT *, MAP SHARED, fd, 0);Use libhugetlbfs library – man libhugetlbfs(7) addr mmap(NULL, SIZE, PROT *,MAP PRIVATE MAP ANONYMOUS MAP HUGETLB, -1, 0);Mount a special virtual filesystem Since 3.8: alternative flags SHM HUGE 2MB, SHM HUGE 1GB, and SHM HUGE SHIFTAnonymous mmap() shmid shmget(key, SIZE, SHM HUGETLB );addr shmat(shmid, NULL, 0);get huge pages(), get hugepage region().LD PRELOAD for legacy applicationsText, data, malloc(), shared memory backed by hugepagesUseful tools: hugeadm, hugectl

HugeTLBfs Internals Hugetlb pages reserved on mmap() Reservation system tracksCheaper mmap(), potentially better NUMA placementPrivate mappings can fork() COW fault at any time Potential copies not reserved – fork() won’t failCOW will try to allocate without reserve, but that can fail Child COW alloc fails SIGBUS Parent COW alloc fails child’s mapping removed, fault SIGBUS Reservations don’t guarantee NUMA placementShared page tables Scenario: many processes mapping the same region of 2MB hugepagesEach 1GB large region (fully populated or not) would have 4KB pmd-level page table foreach processThis page table will be shared when mappings are properly aligned, reducing thememory usageExample: Memory usage of (system running Oracle) by page tables 150GB without vs1GB with HugeTLB

THP First page fault in each huge-page aligned part of vma (last-level pagetable does not yet exist) Read fault map a shared “THP zero page” firstDuring mmap() with MAP POPULATEKhugepaged merge small pages into THP in the backgroundIf allocating huge page fails, fallback to mapping a page table with asingle PTE entry for a base pageCOW – alloc copy whole huge page, fallback to alloc copy many basepages mapped by PTEsTHP may be mapped by ptes partially – mprotect, unmapFault in resp. merging policy fine tuning madvise(MADV HUGEPAGE, MADV NOHUGEPAGE)prctl(PR SET THP DISABLE)Global setting - /sys/kernel/mm/transparent hugepage/ allways, madvise, never for global settingallways, madvise, never, defer, defer madvise for khugepagedShmem controlled by mount option allways, advise, never, within size

THP - khugepaged Kernel thread to scan address space/sys/kernel/mm/transparent hugepage/khugepaged/*Merges sparsely populated PMD Pros max ptes none – how much more to allocatemax ptes swap – how much to swap inpages to scan, scan sleep millisecs – how much/often to scanFault in is latency sensitive while deferred context might try harderVMAs might grow over time (e.g. stack, shmem file)Reduces memory fragmentationCons Background interference – e.g. mmap sem lock contentionJumps in too late for short lived mappings

THP related statistics/proc/meminfoAnonHugePages:1929216 kBShmemHugePages, ShmemPmdMapped/proc/vmstatthp split page 5542thp fault alloc 174171thp split page failed 4thp fault fallback 61457thp deferred split page 199thp collapse alloc 35893thp collapse alloc failed 703 thp split pmd 26504thp split pud 0thp file alloc 0thp zero page alloc 1thp file mapped 0thp zero page alloc failed 0/sys/kernel/mm/transparent hugepage/khugepagedfull scans: 751pages collapsed: 26272

Memory cgroup controller Hierarchical accounting of user memory (page faults) and opt-in kernelallocations GFP ACCOUNT (e.g. kernel stacks)Represented by struct mem cgroup Page counters for chargesOwn LRUs – mem cgroup::nodeinfo – per NUMA nodeMemory is charged when the page is added to the LRU list or in the pageallocator for kernel allocations - try charge() Charge is propagated up the hierarchyPerforms direct reclaim on the memcg which hits hard limit mem cgroup shrink node() shrink node memcg() - iterates over all lruvecs under given mem cgroup in a round robinmannerCode shared with the standard reclaim – some exceptions, we wait for Dirty pages, swappiness isnot ignored even under hard memory pressure etc.Schedules “background” reclaim when high limit is reached – reclaim high() whenreturning to the user spaceLow/Min limit protects memory cgroup from reclaim32

Memory cgroup controller Charge fails and marks OOM context when the reclaim fails Memcg OOM killer can be handled from userspace Only kills tasks from the memcg hierarchyecho 1 memory.oom control – disables oom killer, the kernel will notifylistener on this file and waits for situation to change mem cgroup oom synchronize()Admin may increase the limit or kill a task manuallyOnly page faults are triggering memcg OOM killerpagefault out of memory() Used to trigger it from the charge path but this could deadlock easily – chargecontext can hold locks which might be needed for OOM to make a forwardprogress33


Unpublished Work of SUSE LLC. All Rights Reserved.This work is an unpublished work and contains confidential, proprietary and trade secret information of SUSE LLC.Access to this work is restricted to SUSE employees who have a need to know to perform tasks within the scope of theirassignments. No part of this work may be practiced, performed, copied, distributed, revised, modified, translated,abridged, condensed, expanded, collected, or adapted without the prior written consent of SUSE.Any use or exploitation of this work without authorization could subject the perpetrator to criminal and civil liability.General DisclaimerThis document is not to be construed as a promise by any participating company to develop, deliver, or market aproduct. It is not a commitment to deliver any material, code, or functionality, and should not be relied upon in makingpurchasing decisions. SUSE makes no representations or warranties with respect to the contents of this document, andspecifically disclaims any express or implied warranties of merchantability or fitness for any particular purpose. Thedevelopment, release, and timing of features or functionality described for SUSE products remains at the sole discretionof SUSE. Further, SUSE reserves the right to revise this document and to make changes to its content, at any time,without obligation to notify any person or entity of such revisions or changes. All SUSE marks referenced in thispresentation are trademarks or registered trademarks of Novell, Inc. in the United States and other countries. All thirdparty trademarks are the property of their respective owners.36

4 Purpose and the scope of MM APIs for kernel Bootmem/memblock allocator - early initialization Page allocator - page order (2N physically contiguous pages) SLAB allocator - sub page granularity, internal fragmentation management SLOB - very rudimentary for small devices SLAB - based on Solaris design - optimized for CPU cache efficiency, NUMA aware

Related Documents:

Linux in a Nutshell Linux Network Administrator’s Guide Linux Pocket Guide Linux Security Cookbook Linux Server Hacks Linux Server Security Running Linux SELinux Understanding Linux Network Internals Linux Books Resource Center linux.oreilly.comis a complete catalog of O’Reilly’s books on Linux and Unix and related technologies .

Other Linux resources from O’Reilly Related titles Building Embedded Linux Systems Linux Device Drivers Linux in a Nutshell Linux Pocket Guide Running Linux Understanding Linux Network Internals Understanding the Linux Kernel Linux Books Resource Center linu

Perfection PC Perfection PC Inc. Philips Philips Electronics Planar Planar Systems Inc PLEXON Plexon, Inc. Pogo Linux Pogo Linux, Inc. Pogo Linux Altura M2 Pogo Linux, Inc. Pogo Linux Velocity -D50 Pogo Linux, Inc. Pogo Linux Verona 330 Pogo Linux, Inc. Pogo Linux Vor

An Introduction to Linux memory management. The basics of paging. Understanding basic hardware memory management and the difference between virtual, physical and swap memory. How do determine hardware installed and how to figure out how processes use that memory. How a process uses physical and virtual memory effectively.

Yes. Oracle Autonomous Linux, which is based on Oracle Linux, is 100% application binary compatible with IBM's Red Hat Enterprise Linux. This means that applications certified to run on Red Hat Enterprise Linux can run on Oracle Autonomous Linux unmodified. Oracle Linux binaries are provided for patching and updating Red Hat Enterprise Linux

Official Kali Linux Documentation This PDF has been autogenerated on - Apr 7, 2013 00. Introduction to Kali Linux What is Kali Linux ? Kali Linux is an advanced Penetration Testing and Security Auditing Linux distribution. Kali Linux Features Kali is a complete re-build of BackTrack Linux, adhering completely to Debian development .

Memory Management Ideally programmers want memory that is o large o fast o non volatile o and cheap Memory hierarchy o small amount of fast, expensive memory -cache o some medium-speed, medium price main memory o gigabytes of slow, cheap disk storage Memory management tasks o Allocate and de-allocate memory for processes o Keep track of used memory and by whom

will be honored within 10 days of Tour departure date. Alpventures World War II Tours P.O. Box 2079 - Clackamas, OR 97015 Toll-Free 1 (888) 991-6718 Battleground Italy Tour Printable Tour Itinerary Tour Dates: October 4 – 16, 2020 Tour Length: 12 Days / 11 Nights