Commit b89462a9 authored by Dennis Zhou's avatar Dennis Zhou
Browse files

percpu: remember largest area skipped during allocation 



Percpu allocations attempt to do first fit by scanning forward from the
first_free of a block. However, fragmentation from allocation requests
can cause holes not seen by block hint update functions. To address
this, create a local version of bitmap_find_next_zero_area_off() that
remembers the largest area skipped over. The caveat is that it only sees
regions skipped over due to not fitting, not regions skipped due to
alignment.

Prior to updating the scan_hint, a scan backwards is done to try and
recover free bits skipped due to alignment. While this can cause
scanning to miss earlier possible free areas, smaller allocations will
eventually fill those holes due to first fit.

Signed-off-by: default avatarDennis Zhou <dennis@kernel.org>
parent 382b88e9

mm/percpu.c

+99 −2
Original line number Diff line number Diff line
@@ -712,6 +712,43 @@ static void pcpu_block_update(struct pcpu_block_md *block, int start, int end) 
	}

}



/*

 * pcpu_block_update_scan - update a block given a free area from a scan

 * @chunk: chunk of interest

 * @bit_off: chunk offset

 * @bits: size of free area

 *

 * Finding the final allocation spot first goes through pcpu_find_block_fit()

 * to find a block that can hold the allocation and then pcpu_alloc_area()

 * where a scan is used.  When allocations require specific alignments,

 * we can inadvertently create holes which will not be seen in the alloc

 * or free paths.

 *

 * This takes a given free area hole and updates a block as it may change the

 * scan_hint.  We need to scan backwards to ensure we don't miss free bits

 * from alignment.

 */

static void pcpu_block_update_scan(struct pcpu_chunk *chunk, int bit_off,

				   int bits)

{

	int s_off = pcpu_off_to_block_off(bit_off);

	int e_off = s_off + bits;

	int s_index, l_bit;

	struct pcpu_block_md *block;



	if (e_off > PCPU_BITMAP_BLOCK_BITS)

		return;



	s_index = pcpu_off_to_block_index(bit_off);

	block = chunk->md_blocks + s_index;



	/* scan backwards in case of alignment skipping free bits */

	l_bit = find_last_bit(pcpu_index_alloc_map(chunk, s_index), s_off);

	s_off = (s_off == l_bit) ? 0 : l_bit + 1;



	pcpu_block_update(block, s_off, e_off);

}



/**

 * pcpu_block_refresh_hint

 * @chunk: chunk of interest
@@ -1060,6 +1097,62 @@ static int pcpu_find_block_fit(struct pcpu_chunk *chunk, int alloc_bits, 
	return bit_off;

}



/*

 * pcpu_find_zero_area - modified from bitmap_find_next_zero_area_off()

 * @map: the address to base the search on

 * @size: the bitmap size in bits

 * @start: the bitnumber to start searching at

 * @nr: the number of zeroed bits we're looking for

 * @align_mask: alignment mask for zero area

 * @largest_off: offset of the largest area skipped

 * @largest_bits: size of the largest area skipped

 *

 * The @align_mask should be one less than a power of 2.

 *

 * This is a modified version of bitmap_find_next_zero_area_off() to remember

 * the largest area that was skipped.  This is imperfect, but in general is

 * good enough.  The largest remembered region is the largest failed region

 * seen.  This does not include anything we possibly skipped due to alignment.

 * pcpu_block_update_scan() does scan backwards to try and recover what was

 * lost to alignment.  While this can cause scanning to miss earlier possible

 * free areas, smaller allocations will eventually fill those holes.

 */

static unsigned long pcpu_find_zero_area(unsigned long *map,

					 unsigned long size,

					 unsigned long start,

					 unsigned long nr,

					 unsigned long align_mask,

					 unsigned long *largest_off,

					 unsigned long *largest_bits)

{

	unsigned long index, end, i, area_off, area_bits;

again:

	index = find_next_zero_bit(map, size, start);



	/* Align allocation */

	index = __ALIGN_MASK(index, align_mask);

	area_off = index;



	end = index + nr;

	if (end > size)

		return end;

	i = find_next_bit(map, end, index);

	if (i < end) {

		area_bits = i - area_off;

		/* remember largest unused area with best alignment */

		if (area_bits > *largest_bits ||

		    (area_bits == *largest_bits && *largest_off &&

		     (!area_off || __ffs(area_off) > __ffs(*largest_off)))) {

			*largest_off = area_off;

			*largest_bits = area_bits;

		}



		start = i + 1;

		goto again;

	}

	return index;

}



/**

 * pcpu_alloc_area - allocates an area from a pcpu_chunk

 * @chunk: chunk of interest
@@ -1083,6 +1176,7 @@ static int pcpu_alloc_area(struct pcpu_chunk *chunk, int alloc_bits, 
			   size_t align, int start)

{

	size_t align_mask = (align) ? (align - 1) : 0;

	unsigned long area_off = 0, area_bits = 0;

	int bit_off, end, oslot;



	lockdep_assert_held(&pcpu_lock);
@@ -1094,11 +1188,14 @@ static int pcpu_alloc_area(struct pcpu_chunk *chunk, int alloc_bits, 
	 */

	end = min_t(int, start + alloc_bits + PCPU_BITMAP_BLOCK_BITS,

		    pcpu_chunk_map_bits(chunk));

	bit_off = bitmap_find_next_zero_area(chunk->alloc_map, end, start,

					     alloc_bits, align_mask);

	bit_off = pcpu_find_zero_area(chunk->alloc_map, end, start, alloc_bits,

				      align_mask, &area_off, &area_bits);

	if (bit_off >= end)

		return -1;



	if (area_bits)

		pcpu_block_update_scan(chunk, area_off, area_bits);



	/* update alloc map */

	bitmap_set(chunk->alloc_map, bit_off, alloc_bits);

CRA Git | Maintained and supported by SUSTech CRA and CCSE