Re: [PATCH 2/5] mm/page_alloc: Add a bulk page allocator

Matthew Wilcox
2021-03-13T16:41:07Z

[-- Attachment #1: Type: text/plain, Size: 1108 bytes --]

On Sat, Mar 13, 2021 at 01:16:48PM +0000, Mel Gorman wrote:
> > I'm not claiming the pagevec is definitely a win, but it's very
> > unclear which tradeoff is actually going to lead to better performance.
> > Hopefully Jesper or Chuck can do some tests and figure out what actually
> > works better with their hardware & usage patterns.
>
> The NFS user is often going to need to make round trips to get the pages it
> needs. The pagevec would have to be copied into the target array meaning
> it's not much better than a list manipulation.

I don't think you fully realise how bad CPUs are at list manipulation.
See the attached program (and run it on your own hardware). On my
less-than-a-year-old core-i7:

$ gcc -W -Wall -O2 -g array-vs-list.c -o array-vs-list
$ ./array-vs-list
walked sequential array in 0.001765s
walked sequential list in 0.002920s
walked sequential array in 0.001777s
walked shuffled list in 0.081955s
walked shuffled array in 0.007367s

If you happen to get the objects in-order, it's only 64% worse to walk
a list as an array. If they're out of order, it's *11.1* times as bad.

[-- Attachment #2: array-vs-list.c --]
[-- Type: text/plain, Size: 3930 bytes --]

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <unistd.h>

unsigned long count = 1000 * 1000;
unsigned int verbose;

struct object {
struct object *next;
struct object *prev;
unsigned int value;
};

#define printv(level, fmt, ...) \
if (level <= verbose) { printf(fmt, ##__VA_ARGS__); }

void check_total(unsigned long total)
{
if (total * 2 != count * (count + 1))
printf("Check your staging! (%lu %lu)\n", total, count);
}

void alloc_objs(struct object **array)
{
unsigned long i;

for (i = 0; i < count; i++) {
struct object *obj = malloc(sizeof(*obj));

obj->value = i + 1;
/* Add to the array */
array[i] = obj;
}
}

void shuffle(struct object **array, unsigned long seed)
{
unsigned long i;

printv(1, "random seed %lu\n", seed);
srand48(seed);

/* Shuffle the array */
for (i = 1; i < count; i++) {
struct object *obj;
unsigned long j = (unsigned int)mrand48() % (i + 1);

if (i == j)
continue;
obj = array[j];
array[j] = array[i];
array[i] = obj;
}
}

void create_list(struct object **array, struct object *list)
{
unsigned long i;

list->next = list;
list->prev = list;

for (i = 0; i < count; i++) {
struct object *obj = array[i];
/* Add to the tail of the list */
obj->next = list;
obj->prev = list->prev;
list->prev->next = obj;
list->prev = obj;
}
}

void walk_list(struct object *list)
{
unsigned long total = 0;
struct object *obj;

for (obj = list->next; obj != list; obj = obj->next) {
total += obj->value;
}

check_total(total);
}

void walk_array(struct object **array)
{
unsigned long total = 0;
unsigned long i;

for (i = 0; i < count; i++) {
total += array[i]->value;
}

check_total(total);
}

/* time2 - time1 */
double diff_time(struct timespec *time1, struct timespec *time2)
{
double result = time2->tv_nsec - time1->tv_nsec;

return time2->tv_sec - time1->tv_sec + result / 1000 / 1000 / 1000;
}

int main(int argc, char **argv)
{
int opt;
unsigned long seed = time(NULL);
struct object **array;
struct object list;
struct timespec time1, time2;

while ((opt = getopt(argc, argv, "c:s:v")) != -1) {
if (opt == 'c')
count *= strtoul(optarg, NULL, 0);
else if (opt == 's')
seed = strtoul(optarg, NULL, 0);
else if (opt == 'v')
verbose++;
}

clock_gettime(CLOCK_MONOTONIC, &time1);
array = calloc(count, sizeof(void *));
alloc_objs(array);
clock_gettime(CLOCK_MONOTONIC, &time2);
printv(1, "allocated %lu items in %fs\n", count,
diff_time(&time1, &time2));

clock_gettime(CLOCK_MONOTONIC, &time1);
walk_array(array);
clock_gettime(CLOCK_MONOTONIC, &time2);
printf("walked sequential array in %fs\n",
diff_time(&time1, &time2));

clock_gettime(CLOCK_MONOTONIC, &time1);
create_list(array, &list);
clock_gettime(CLOCK_MONOTONIC, &time2);
printv(1, "created list in %fs\n",
diff_time(&time1, &time2));

clock_gettime(CLOCK_MONOTONIC, &time1);
walk_list(&list);
clock_gettime(CLOCK_MONOTONIC, &time2);
printf("walked sequential list in %fs\n",
diff_time(&time1, &time2));

clock_gettime(CLOCK_MONOTONIC, &time1);
walk_array(array);
clock_gettime(CLOCK_MONOTONIC, &time2);
printf("walked sequential array in %fs\n",
diff_time(&time1, &time2));

clock_gettime(CLOCK_MONOTONIC, &time1);
shuffle(array, seed);
clock_gettime(CLOCK_MONOTONIC, &time2);
printv(1, "shuffled array in %fs\n",
diff_time(&time1, &time2));

clock_gettime(CLOCK_MONOTONIC, &time1);
create_list(array, &list);
clock_gettime(CLOCK_MONOTONIC, &time2);
printv(1, "created list in %fs\n",
diff_time(&time1, &time2));

clock_gettime(CLOCK_MONOTONIC, &time1);
walk_list(&list);
clock_gettime(CLOCK_MONOTONIC, &time2);
printf("walked shuffled list in %fs\n",
diff_time(&time1, &time2));

clock_gettime(CLOCK_MONOTONIC, &time1);
walk_array(array);
clock_gettime(CLOCK_MONOTONIC, &time2);
printf("walked shuffled array in %fs\n",
diff_time(&time1, &time2));

return 0;
}