/*
 * Approximate time in seconds from the creation of a set of unused
 * dirty pages until an equivalent set of unused dirty pages is purged
 * and/or reused.
 */
ssize_t			decay_time;	// 产生的 dirty pages 会在 decay_time 时间后全部 purge，默认为 10s。
/* decay_time / SMOOTHSTEP_NSTEPS. */
nstime_t		decay_interval; // decay 分为 SMOOTHSTEP_NSTEPS(200) 组，这是每组的时间间隔。
/*
 * Time at which the current decay interval logically started.  We do
 * not actually advance to a new epoch until sometime after it starts
 * because of scheduling and computation delays, and it is even possible
 * to completely skip epochs.  In all cases, during epoch advancement we
 * merge all relevant activity into the most recently recorded epoch.
 */
nstime_t		decay_epoch; // 每组 decay 的起始时间
/* decay_deadline randomness generator. */
uint64_t		decay_jitter_state; // 随机种子，用于计算下面的 decay_deadline
/*
 * Deadline for current epoch.  This is the sum of decay_interval and
 * per epoch jitter which is a uniform random variable in
 * [0..decay_interval).  Epochs always advance by precise multiples of
 * decay_interval, but we randomize the deadline to reduce the
 * likelihood of arenas purging in lockstep.
 */
nstime_t		decay_deadline; // 每组 decay 的终止时间
/*
 * Number of dirty pages at beginning of current epoch.  During epoch
 * advancement we use the delta between decay_ndirty and ndirty to
 * determine how many dirty pages, if any, were generated, and record
 * the result in decay_backlog.
 */
size_t			decay_ndirty; // 每组 decay 开始时的 arena->ndirty(dirty page 数量)
/*
 * Memoized result of arena_decay_backlog_npages_limit() corresponding
 * to the current contents of decay_backlog, i.e. the limit on how many
 * pages are allowed to exist for the decay epochs.
 */
size_t			decay_backlog_npages_limit; // 每次 purge 能够剩下的 dirty page 数量
/*
 * Trailing log of how many unused dirty pages were generated during
 * each of the past SMOOTHSTEP_NSTEPS decay epochs, where the last
 * element is the most recent epoch.  Corresponding epoch times are
 * relative to decay_epoch.
 */
size_t			decay_backlog[SMOOTHSTEP_NSTEPS]; // 倒序(最后的为最新的 decay)保存了每组 decay 产生的 dirty page 数量，
                                                    // 根据这个计算能够保存的 dirty page 数量。

JEMALLOC_ALWAYS_INLINE void
arena_decay_ticks(tsd_t *tsd, arena_t *arena, unsigned nticks)
{
	ticker_t *decay_ticker;

	if (unlikely(tsd == NULL))
		return;
	decay_ticker = decay_ticker_get(tsd, arena->ind);
	if (unlikely(decay_ticker == NULL))
		return;
        // 当 tick 为0时，才 purge，默认是1000次
	if (unlikely(ticker_ticks(decay_ticker, nticks)))
		arena_purge(arena, false);
}

static void
arena_maybe_purge_decay(arena_t *arena)
{
	nstime_t time;
	size_t ndirty_limit;

	assert(opt_purge == purge_mode_decay);

	/* Purge all or nothing if the option is disabled. */
	if (arena->decay_time <= 0) {
		if (arena->decay_time == 0)
			arena_purge_to_limit(arena, 0);
		return;
	}

	nstime_copy(&time, &arena->decay_epoch);
	if (unlikely(nstime_update(&time))) { // 设置 time 为当前时间
		/* Time went backwards.  Force an epoch advance. */
		nstime_copy(&time, &arena->decay_deadline); // 当时间回退时，设置时间为 deadline
	}

	if (arena_decay_deadline_reached(arena, &time)) // arena->decay_deadline <= time 到达 deadline
		arena_decay_epoch_advance(arena, &time);  // 更新 epoch 和 统计

	ndirty_limit = arena_decay_npages_limit(arena); // 计算这次 purge 能够剩下的 dirty page 数量

	/*
	 * Don't try to purge unless the number of purgeable pages exceeds the
	 * current limit.
	 */
	if (arena->ndirty <= ndirty_limit)
		return;
	arena_purge_to_limit(arena, ndirty_limit); // 进行 purge，purge 之后剩下的数量为 ndirty_limit
}

static void
arena_decay_epoch_advance(arena_t *arena, const nstime_t *time)
{
	uint64_t nadvance;
	nstime_t delta;
	size_t ndirty_delta;

	assert(opt_purge == purge_mode_decay);
	assert(arena_decay_deadline_reached(arena, time));

	nstime_copy(&delta, time);
	nstime_subtract(&delta, &arena->decay_epoch);
	nadvance = nstime_divide(&delta, &arena->decay_interval); // 计算过去了多少 interval
	assert(nadvance > 0);

	/* Add nadvance decay intervals to epoch. */
	nstime_copy(&delta, &arena->decay_interval);
	nstime_imultiply(&delta, nadvance);
	nstime_add(&arena->decay_epoch, &delta); // 设置 decay_epoch 为这次 decay 的起始时间

	/* Set a new deadline. */
	arena_decay_deadline_init(arena);

	/* Update the backlog. */
        /* arena->decay_backlog[] 保存了每组 decay 产生的 dirty page 数量，最后的为最新的(因为 smootherstep 是从0~1)
         * 当过去 interval 时，decay_backlog[] 中的数据会左移，相当于时间窗口移动
         */
	if (nadvance >= SMOOTHSTEP_NSTEPS) {
		memset(arena->decay_backlog, 0, (SMOOTHSTEP_NSTEPS-1) *
		    sizeof(size_t));
	} else {
		memmove(arena->decay_backlog, &arena->decay_backlog[nadvance],
		    (SMOOTHSTEP_NSTEPS - nadvance) * sizeof(size_t));
		if (nadvance > 1) {
			memset(&arena->decay_backlog[SMOOTHSTEP_NSTEPS -
			    nadvance], 0, (nadvance-1) * sizeof(size_t));
		}
	}
        // 这次 decay 时间间隔内产生的 dirty page 数量
	ndirty_delta = (arena->ndirty > arena->decay_ndirty) ? arena->ndirty -
	    arena->decay_ndirty : 0;
	arena->decay_ndirty = arena->ndirty; // 保留当前的 dirty page 数量，为了下一次计算 ndirty_delta
	arena->decay_backlog[SMOOTHSTEP_NSTEPS-1] = ndirty_delta; // 保存这次 decay 产生的 dirty page 数量
	arena->decay_backlog_npages_limit =
	    arena_decay_backlog_npages_limit(arena); // 根据 smootherstep 计算这次 decay 之后能够剩下的 dirty page 数量
}