iOS Purgeable 内存管理策略
XNU 内核源码深度解析：状态机 · 回收时机 · 记账模型

18565if (control == VM_PURGABLE_PURGE_ALL) {
18566	vm_purgeable_object_purge_all();
18567	return KERN_SUCCESS;
18568}

143/*
144 * Valid states of a purgeable object.
145 */
146#define VM_PURGABLE_STATE_MIN   0   /* minimum purgeable object state value */
147#define VM_PURGABLE_STATE_MAX   3   /* maximum purgeable object state value */
148#define VM_PURGABLE_STATE_MASK  3   /* mask to separate state from group */
149
150#define VM_PURGABLE_NONVOLATILE 0   /* purgeable object is non-volatile */
151#define VM_PURGABLE_VOLATILE    1   /* purgeable object is volatile */
152#define VM_PURGABLE_EMPTY       2   /* purgeable object is volatile and empty */
153#define VM_PURGABLE_DENY        3   /* (mark) object not purgeable */

265	/* boolean_t */ purgable:2,             /* Purgable state.  See
266	                                         * VM_PURGABLE_*
267	                                         */
268	/* boolean_t */ purgeable_only_by_kernel:1,
269	/* boolean_t */ purgeable_when_ripe:1,   /* Purgeable when a token
270	                                                * becomes ripe.
271	                                                */

5781 * A purgeable object may be put into a "volatile" state which will make the
5782 * object's pages elligable for being reclaimed without paging to backing
5783 * store if the system runs low on memory.  If the pages in a volatile
5784 * purgeable object are reclaimed, the purgeable object is said to have been
5785 * "emptied."  When a purgeable object is emptied the system will reclaim as
5786 * many pages from the object as it can in a convenient manner (pages already
5787 * en route to backing store or busy for other reasons are left as is).  When
5788 * a purgeable object is made volatile, its pages will generally be reclaimed
5789 * before other pages in the application's working set.  This semantic is
5790 * generally used by applications which can recreate the data in the object
5791 * faster than it can be paged in. ...
5794 * A purgeable object may be designated as "non-volatile" which means it will
5795 * behave like all other objects in the system with pages being written to and
5796 * read from backing store as needed to satisfy system memory needs.  If the
5797 * object was emptied before the object was made non-volatile, that fact will
5798 * be returned as the old state of the purgeable object (see
5799 * VM_PURGABLE_SET_STATE below).  In this case, any pages of the object which
5800 * were reclaimed as part of emptying the object will be refaulted in as
5801 * zero-fill on demand.  It is up to the application to note that an object
5802 * was emptied and recreate the objects contents if necessary.  When a
5803 * purgeable object is made non-volatile, its pages will generally not be paged
5804 * out to backing store in the immediate future.  A purgeable object may also
5805 * be manually emptied.

5833 * The process of making a purgeable object non-volatile and determining its
5834 * previous state is atomic.  Thus, if a purgeable object is made
5835 * VM_PURGABLE_NONVOLATILE and the old state is returned as
5836 * VM_PURGABLE_VOLATILE, then the purgeable object's previous contents are
5837 * completely intact and will remain so until the object is made volatile
5838 * again.  If the old state is returned as VM_PURGABLE_EMPTY then the object
5839 * was reclaimed while it was in a volatile state and its previous contents
5840 * have been lost.

5863	/*
5864	 * Get current state of the purgeable object.
5865	 */
5866	old_state = object->purgable;
5867	if (old_state == VM_PURGABLE_DENY) {
5868		return KERN_INVALID_ARGUMENT;
5869	}
...
5878	if (control == VM_PURGABLE_GET_STATE) {
5879		*state = old_state;
5880		return KERN_SUCCESS;
5881	}
...
5900	new_state = *state & VM_PURGABLE_STATE_MASK;
5901	if (new_state == VM_PURGABLE_VOLATILE) {
5902		if (old_state == VM_PURGABLE_EMPTY) {
5903			/* what's been emptied must stay empty */
5904			new_state = VM_PURGABLE_EMPTY;
5905		}
5906		if (object->volatile_empty) {
5907			/* debugging mode: go straight to empty */
5908			new_state = VM_PURGABLE_EMPTY;
5909		}
5910	}

5658	/*
5659	 * We need to set the object's state to VM_PURGABLE_EMPTY *before*
5660	 * reaping its pages.  We update vm_page_purgeable_count in bulk
5661	 * and we don't want vm_page_remove() to update it again for each
5662	 * page we reap later.
5663	 *
5664	 * For the purgeable ledgers, pages from VOLATILE and EMPTY objects
5665	 * are all accounted for in the "volatile" ledgers, so this does not
5666	 * make any difference.
5667	 * If we transitioned directly from NONVOLATILE to EMPTY,
5668	 * vm_page_purgeable_count must have been updated when the object
5669	 * was dequeued from its volatile queue ...
5671	 */
5672	if (object->purgable == VM_PURGABLE_VOLATILE) {
5673		unsigned int delta;
...
5682		OSAddAtomic(-delta,
5683		    (SInt32 *)&vm_page_purgeable_count);
...
5691		object->purgable = VM_PURGABLE_EMPTY;
5692	}
5693	assert(object->purgable == VM_PURGABLE_EMPTY);
5694
5695	object_page_count = object->resident_page_count;
5696
5697	vm_object_reap_pages(object, REAP_PURGEABLE);  /* 收割驻留页 */

2003	} else if (owner &&
2004	    (object->purgable == VM_PURGABLE_VOLATILE ||
2005	    object->purgable == VM_PURGABLE_EMPTY)) {
2006		assert(!VM_PAGE_WIRED(mem));
2007		/* more volatile bytes */
2008		ledger_credit(owner->ledger,
2009		    ledger_idx_volatile,
2010		    PAGE_SIZE);
2011	}
2012
...
2019	} else if (object->purgable == VM_PURGABLE_EMPTY &&
2020	    mem->vmp_q_state == VM_PAGE_ON_THROTTLED_Q) {
2021		/*
2022		 * This page belongs to a purged VM object but hasn't
2023		 * been purged (because it was "busy").
2024		 * It's in the "throttled" queue and hence not
2025		 * visible to vm_pageout_scan().  Move it to a pageable
2026		 * queue, so that it can eventually be reclaimed, instead
2027		 * of lingering in the "empty" object.
2028		 */
2029		...
2032		vm_page_deactivate(mem);

2999		/*
3000		 * Before anything, we check if we have any ripe volatile
3001		 * objects around. If so, try to purge the first object.
3002		 * If the purge fails, fall through to reclaim a page instead.
3003		 * If the purge succeeds, go back to the top and reevalute
3004		 * the new memory situation.
3005		 */
3006		retval = vps_purge_object();
3007
3008		if (retval == VM_PAGEOUT_SCAN_NEXT_ITERATION) {
3012			if (object != NULL) {
3013				vm_object_unlock(object);
3014				object = NULL;
3015			}
3017			lock_yield_check = FALSE;
3018			continue;  /* purge 成功 → 回到循环顶部重新评估，可能就此收手 */
3019		}

59struct token {
60	token_cnt_t     count;
61	token_idx_t     prev;
62	token_idx_t     next;
63};
...
71int32_t         token_new_pagecount = 0;  /* count of pages that will
72                                                 * be added onto token queue */
73
74int             available_for_purge = 0;  /* increase when ripe token
75                                                 * added, decrease when ripe
76                                                 * token removed.
77                                                 * protected by page_queue_lock
78                                                 */

487	/*
488	 * Decrement token counters. A token counter can be zero, this means the
489	 * object is ripe to be purged. It is not purged immediately, because that
490	 * could cause several objects to be purged even if purging one would satisfy
491	 * the memory needs. Instead, the pageout thread purges one after the other
492	 * by calling vm_purgeable_object_purge_one and then rechecking the memory
493	 * balance.
494	 *
495	 * No need to advance obsolete queue - all items are ripe there,
496	 * always
497	 */
498	for (i = PURGEABLE_Q_TYPE_FIFO; i < PURGEABLE_Q_TYPE_MAX; i++) {
499		purgeable_q_t queue = &purgeable_queues[i];
500		uint32_t num_pages = 1;
501
502		/* Iterate over tokens as long as there are unripe tokens. */
503		while (queue->token_q_unripe) {
504			if (tokens[queue->token_q_unripe].count && num_pages) {
505				tokens[queue->token_q_unripe].count -= 1;
506				num_pages -= 1;
507			}
508
509			if (tokens[queue->token_q_unripe].count == 0) {
510				queue->token_q_unripe = tokens[queue->token_q_unripe].next;
511				available_for_purge++;
512				...
521		}

730		object_task_importance = 0;
731
732		/*
733		 * We don't want to use VM_OBJECT_OWNER() here: we want to
734		 * distinguish kernel-owned and disowned objects.
735		 * Disowned objects have no owner and will have no importance...
736		 */
737		owner = object->vo_owner;
738		if (owner != NULL && owner != VM_OBJECT_OWNER_DISOWNED) {
739#if !XNU_TARGET_OS_OSX
740#if CONFIG_JETSAM
741			object_task_importance = proc_get_memstat_priority((struct proc *)get_bsdtask_info(owner), TRUE);
742#endif /* CONFIG_JETSAM */
743#else /* !XNU_TARGET_OS_OSX */
744			object_task_importance = task_importance_estimate(owner);
745#endif /* !XNU_TARGET_OS_OSX */
746		}
747
748		if (object_task_importance < best_object_task_importance) {
749			if (vm_object_lock_try(object)) {
750				try_lock_succeeded++;
...
755				best_object = object;
756				best_object_task_importance = object_task_importance;
757				best_object_skipped = num_objects_skipped;
758				if (best_object_task_importance == 0) {
759					/* can't get any better: stop looking */
760					break;

3300		if (object->copy == VM_OBJECT_NULL) {
3301			/*
3302			 * No one else can have any interest in this page.
3303			 * If this is an empty purgable object, the page can be
3304			 * reclaimed even if dirty.
3305			 * If the page belongs to a volatile purgable object, we
3306			 * reactivate it if the compressor isn't active.
3307			 */
3308			if (object->purgable == VM_PURGABLE_EMPTY) {
...
3316				if (m->vmp_dirty || m->vmp_precious) {
3317					/* we saved the cost of cleaning this page ! */
3318					vm_page_purged_count++;
3319				}
3320				goto reclaim_page;
3321			}
3322
3323			if (VM_CONFIG_COMPRESSOR_IS_ACTIVE) {
3324				/*
3325				 * With the VM compressor, the cost of
3326				 * reclaiming a page is much lower (no I/O),
3327				 * so if we find a "volatile" page, it's better
3328				 * to let it get compressed rather than letting
3329				 * it occupy a full page until it gets purged.
3330				 * So no need to check for "volatile" here.
3331				 */
3332			} else if (object->purgable == VM_PURGABLE_VOLATILE) {
3333				/*
3334				 * Avoid cleaning a "volatile" page which might
3335				 * be purged soon.
3336				 */
...
3348				goto reactivate_page;
3349			}

5506	if (cause != kMemorystatusKilledVnodes && cause != kMemorystatusKilledZoneMapExhaustion) {
5507		/*
5508		 * Genuine memory pressure and not other (vnode/zone) resource exhaustion.
5509		 */
...
5515		networking_memstatus_callout(p, cause);
5516		num_pages_purged = vm_purgeable_purge_task_owned(p->task);
5517		num_pages_reclaimed += num_pages_purged;
...
5537		if (num_pages_reclaimed) {
5542			if (cause == kMemorystatusKilledHiwat) {
5543				uint64_t footprint_in_bytes = get_task_phys_footprint(p->task);
5544				uint64_t memlimit_in_bytes  = (((uint64_t)p->p_memstat_memlimit) * 1024ULL * 1024ULL);
5545				success = (footprint_in_bytes <= memlimit_in_bytes);
5546			} else {
5547				success = (memorystatus_avail_pages_below_pressure() == FALSE);
...
5567			if (success) {
5568				memorystatus_purge_before_jetsam_success++;
...
5573				*killed = FALSE;   /* 进程免死 */
5575				return TRUE;

20568				if (VM_CONFIG_FREEZER_SWAP_IS_ACTIVE) {
20569					/*
20570					 * We skip purgeable objects during evaluation phase only.
20571					 * If we decide to freeze this process, we'll explicitly
20572					 * purge these objects before we go around again with
20573					 * 'evaluation_phase' set to FALSE.
20574					 */
20575
20576					if ((src_object->purgable == VM_PURGABLE_EMPTY) || (src_object->purgable == VM_PURGABLE_VOLATILE)) {
...
20583						if (evaluation_phase == FALSE &&
20584						    (src_object->purgable == VM_PURGABLE_VOLATILE) &&
20585						    (src_object->ref_count == 1)) {
20586							vm_object_lock(src_object);
20587							vm_object_purge(src_object, 0);
20588							vm_object_unlock(src_object);
20589						}
20590						continue;
20591					}

986 * phys_footprint
987 *   Physical footprint: This is the sum of:
988 *     + (internal - alternate_accounting)
989 *     + (internal_compressed - alternate_accounting_compressed)
990 *     + iokit_mapped
991 *     + purgeable_nonvolatile          ← NONVOLATILE 计入
992 *     + purgeable_nonvolatile_compressed  ← 压缩的 NONVOLATILE 也计入
993 *     + page_table

1545	if (old_state == VM_PURGABLE_VOLATILE ||
1546	    old_state == VM_PURGABLE_EMPTY) {
1547		/* less volatile bytes in ledger */
1548		ledger_debit(owner->ledger,
1549		    ledger_idx_volatile,
1550		    ptoa_64(resident_page_count - wired_page_count));
...
1556		/* more non-volatile bytes in ledger */
1557		ledger_credit(owner->ledger,
1558		    ledger_idx_nonvolatile,
1559		    ptoa_64(resident_page_count - wired_page_count));
...
1564		if (do_footprint) {
1565			/* more footprint */
1566			ledger_credit(owner->ledger,
1567			    task_ledgers.phys_footprint,
1568			    ptoa_64(resident_page_count
1569			    + compressed_page_count
1570			    - wired_page_count));
1571		}
1572	} else if (old_state == VM_PURGABLE_NONVOLATILE) {
...
1581		if (do_footprint) {
1582			/* less footprint */
1583			ledger_debit(owner->ledger,
1584			    task_ledgers.phys_footprint,
1585			    ptoa_64(resident_page_count
1586			    + compressed_page_count
1587			    - wired_page_count));
1588		}

/* vm_object.h:412-414 */
((object)->volatile_fault &&                                    \
 ((object)->purgable == VM_PURGABLE_VOLATILE ||                 \
  (object)->purgable == VM_PURGABLE_EMPTY))

/* vm_fault.c:722-738 (vm_fault_check) */
	if (object->shadow_severed ||
	    VM_OBJECT_PURGEABLE_FAULT_ERROR(object)) {
		/*
		 * Either:
		 * 1. the shadow chain was severed,
727		 * 2. the purgeable object is volatile or empty and is marked
728		 *    to fault on access while volatile.
729		 * Just have to return an error at this point
730		 */
...
		return VM_FAULT_MEMORY_ERROR;  /* → SIGBUS */
	}

1158	case MADV_FREE_REUSABLE:
1159		new_behavior = VM_BEHAVIOR_REUSABLE;
1160		break;
1161	case MADV_FREE_REUSE:
1162		new_behavior = VM_BEHAVIOR_REUSE;
1163		break;

/* 置 NONVOLATILE 后检查返回的旧状态 */
int state = VM_PURGABLE_NONVOLATILE;
vm_purgable_control(mach_task_self(), (vm_address_t)ptr, VM_PURGABLE_SET_STATE, &state);
if (state == VM_PURGABLE_EMPTY) {
	/* 数据已丢，必须重建 */
}