--- Gnu-Mach/vm/vm_pageout.c 2020/09/02 04:36:57 1.1 +++ Gnu-Mach/vm/vm_pageout.c 2020/09/02 04:42:52 1.1.1.2 @@ -56,23 +56,23 @@ #ifndef VM_PAGEOUT_BURST_MAX #define VM_PAGEOUT_BURST_MAX 10 /* number of pages */ -#endif VM_PAGEOUT_BURST_MAX +#endif /* VM_PAGEOUT_BURST_MAX */ #ifndef VM_PAGEOUT_BURST_MIN #define VM_PAGEOUT_BURST_MIN 5 /* number of pages */ -#endif VM_PAGEOUT_BURST_MIN +#endif /* VM_PAGEOUT_BURST_MIN */ #ifndef VM_PAGEOUT_BURST_WAIT -#define VM_PAGEOUT_BURST_WAIT 30 /* milliseconds per page */ -#endif VM_PAGEOUT_BURST_WAIT +#define VM_PAGEOUT_BURST_WAIT 10 /* milliseconds per page */ +#endif /* VM_PAGEOUT_BURST_WAIT */ #ifndef VM_PAGEOUT_EMPTY_WAIT -#define VM_PAGEOUT_EMPTY_WAIT 200 /* milliseconds */ -#endif VM_PAGEOUT_EMPTY_WAIT +#define VM_PAGEOUT_EMPTY_WAIT 75 /* milliseconds */ +#endif /* VM_PAGEOUT_EMPTY_WAIT */ #ifndef VM_PAGEOUT_PAUSE_MAX #define VM_PAGEOUT_PAUSE_MAX 10 /* number of pauses */ -#endif VM_PAGEOUT_PAUSE_MAX +#endif /* VM_PAGEOUT_PAUSE_MAX */ /* * To obtain a reasonable LRU approximation, the inactive queue @@ -88,7 +88,7 @@ #ifndef VM_PAGE_INACTIVE_TARGET #define VM_PAGE_INACTIVE_TARGET(avail) ((avail) * 2 / 3) -#endif VM_PAGE_INACTIVE_TARGET +#endif /* VM_PAGE_INACTIVE_TARGET */ /* * Once the pageout daemon starts running, it keeps going @@ -97,7 +97,7 @@ #ifndef VM_PAGE_FREE_TARGET #define VM_PAGE_FREE_TARGET(free) (15 + (free) / 80) -#endif VM_PAGE_FREE_TARGET +#endif /* VM_PAGE_FREE_TARGET */ /* * The pageout daemon always starts running once vm_page_free_count @@ -106,19 +106,33 @@ #ifndef VM_PAGE_FREE_MIN #define VM_PAGE_FREE_MIN(free) (10 + (free) / 100) -#endif VM_PAGE_FREE_MIN +#endif /* VM_PAGE_FREE_MIN */ + +/* When vm_page_external_count exceeds vm_page_external_limit, + * allocations of externally paged pages stops. + */ + +#ifndef VM_PAGE_EXTERNAL_LIMIT +#define VM_PAGE_EXTERNAL_LIMIT(free) ((free) / 2) +#endif /* VM_PAGE_EXTERNAL_LIMIT */ + +/* Attempt to keep the number of externally paged pages less + * than vm_pages_external_target. + */ +#ifndef VM_PAGE_EXTERNAL_TARGET +#define VM_PAGE_EXTERNAL_TARGET(free) ((free) / 4) +#endif /* VM_PAGE_EXTERNAL_TARGET */ /* * When vm_page_free_count falls below vm_page_free_reserved, * only vm-privileged threads can allocate pages. vm-privilege * allows the pageout daemon and default pager (and any other * associated threads needed for default pageout) to continue - * operation by dipping into the reserved pool of pages. - */ + * operation by dipping into the reserved pool of pages. */ #ifndef VM_PAGE_FREE_RESERVED -#define VM_PAGE_FREE_RESERVED 15 -#endif VM_PAGE_FREE_RESERVED +#define VM_PAGE_FREE_RESERVED 50 +#endif /* VM_PAGE_FREE_RESERVED */ /* * When vm_page_free_count falls below vm_pageout_reserved_internal, @@ -129,8 +143,8 @@ */ #ifndef VM_PAGEOUT_RESERVED_INTERNAL -#define VM_PAGEOUT_RESERVED_INTERNAL(reserve) ((reserve) - 5) -#endif VM_PAGEOUT_RESERVED_INTERNAL +#define VM_PAGEOUT_RESERVED_INTERNAL(reserve) ((reserve) - 25) +#endif /* VM_PAGEOUT_RESERVED_INTERNAL */ /* * When vm_page_free_count falls below vm_pageout_reserved_really, @@ -141,8 +155,8 @@ */ #ifndef VM_PAGEOUT_RESERVED_REALLY -#define VM_PAGEOUT_RESERVED_REALLY(reserve) ((reserve) - 10) -#endif VM_PAGEOUT_RESERVED_REALLY +#define VM_PAGEOUT_RESERVED_REALLY(reserve) ((reserve) - 40) +#endif /* VM_PAGEOUT_RESERVED_REALLY */ extern void vm_pageout_continue(); extern void vm_pageout_scan_continue(); @@ -150,6 +164,8 @@ extern void vm_pageout_scan_continue(); unsigned int vm_pageout_reserved_internal = 0; unsigned int vm_pageout_reserved_really = 0; +unsigned int vm_page_external_target = 0; + unsigned int vm_pageout_burst_max = 0; unsigned int vm_pageout_burst_min = 0; unsigned int vm_pageout_burst_wait = 0; /* milliseconds per page */ @@ -172,6 +188,7 @@ unsigned int vm_pageout_inactive_used = unsigned int vm_pageout_inactive_clean = 0; /* debugging */ unsigned int vm_pageout_inactive_dirty = 0; /* debugging */ unsigned int vm_pageout_inactive_double = 0; /* debugging */ +unsigned int vm_pageout_inactive_cleaned_external = 0; #if NORMA_VM /* @@ -179,7 +196,7 @@ unsigned int vm_pageout_inactive_double */ extern kern_return_t memory_object_data_initialize(); extern kern_return_t memory_object_data_write(); -#endif NORMA_VM +#endif /* NORMA_VM */ /* * Routine: vm_pageout_setup @@ -272,7 +289,7 @@ vm_pageout_setup(m, paging_offset, new_o vm_external_state_set(old_object->existence_info, paging_offset, VM_EXTERNAL_STATE_EXISTS); -#endif MACH_PAGEMAP +#endif /* MACH_PAGEMAP */ vm_object_unlock(old_object); @@ -319,7 +336,7 @@ vm_pageout_setup(m, paging_offset, new_o vm_external_state_set(old_object->existence_info, paging_offset, VM_EXTERNAL_STATE_EXISTS); -#endif MACH_PAGEMAP +#endif /* MACH_PAGEMAP */ vm_object_unlock(old_object); @@ -503,6 +520,7 @@ vm_pageout_page(m, initial, flush) void vm_pageout_scan() { unsigned int burst_count; + unsigned int want_pages; /* * We want to gradually dribble pages from the active queue @@ -616,17 +634,20 @@ void vm_pageout_scan() } /* - * We are done if we have met our target *and* + * We are done if we have met our targets *and* * nobody is still waiting for a page. */ simple_lock(&vm_page_queue_free_lock); free_count = vm_page_free_count; - if ((free_count >= vm_page_free_target) & + if ((free_count >= vm_page_free_target) && + (vm_page_external_count <= vm_page_external_target) && (vm_page_free_wanted == 0)) { vm_page_unlock_queues(); break; } + want_pages = ((free_count < vm_page_free_target) || + vm_page_free_wanted); simple_unlock(&vm_page_queue_free_lock); /* @@ -637,7 +658,7 @@ void vm_pageout_scan() * consumes memory. We don't take the risk of doing * this if the default pager already has work to do. */ - + pause: if (queue_empty(&vm_page_queue_inactive) || (burst_count >= vm_pageout_burst_max) || (vm_page_laundry_count >= vm_pageout_burst_max) || @@ -680,8 +701,22 @@ void vm_pageout_scan() } vm_pageout_inactive++; - m = (vm_page_t) queue_first(&vm_page_queue_inactive); - assert(!m->active && m->inactive); + + /* Find a page we are interested in paging out. If we + need pages, then we'll page anything out; otherwise + we only page out external pages. */ + m = (vm_page_t) queue_first (&vm_page_queue_inactive); + while (1) + { + assert (!m->active && m->inactive); + if (want_pages || m->external) + break; + + m = (vm_page_t) queue_next (m); + if (!m) + goto pause; + } + object = m->object; /* @@ -727,7 +762,7 @@ void vm_pageout_scan() * If it's absent, we can reclaim the page. */ - if (m->absent) { + if (want_pages && m->absent) { vm_pageout_inactive_absent++; reclaim_page: vm_page_free(m); @@ -760,6 +795,34 @@ void vm_pageout_scan() if (!m->dirty) m->dirty = pmap_is_modified(m->phys_addr); + if (m->external) { + /* Figure out if we still care about this + page in the limit of externally managed pages. + Clean pages don't actually cause system hosage, + so it's ok to stop considering them as + "consumers" of memory. */ + if (m->dirty && !m->extcounted) { + m->extcounted = TRUE; + vm_page_external_count++; + } else if (!m->dirty && m->extcounted) { + m->extcounted = FALSE; + vm_page_external_count--; + } + } + + /* If we don't actually need more memory, and the page + is not dirty, put it on the tail of the inactive queue + and move on to the next page. */ + if (!want_pages && !m->dirty) { + queue_remove (&vm_page_queue_inactive, m, + vm_page_t, pageq); + queue_enter (&vm_page_queue_inactive, m, + vm_page_t, pageq); + vm_page_unlock_queues(); + vm_pageout_inactive_cleaned_external++; + continue; + } + /* * If it's clean and not precious, we can free the page. */ @@ -904,6 +967,14 @@ void vm_pageout() free_after_reserve = vm_page_free_count - vm_page_free_reserved; + if (vm_page_external_limit == 0) + vm_page_external_limit = + VM_PAGE_EXTERNAL_LIMIT (free_after_reserve); + + if (vm_page_external_target == 0) + vm_page_external_target = + VM_PAGE_EXTERNAL_TARGET (free_after_reserve); + if (vm_page_free_min == 0) vm_page_free_min = vm_page_free_reserved + VM_PAGE_FREE_MIN(free_after_reserve);