Migrating the libhugetlbfs/testcases/fallocate_stress.c
PATCH 1/1 Migrating the libhugetlbfs/testcases/fallocate_stress.c
This test stress tests fallocate. This test starts three threads. First thread will continually punch/fill holes via falloc. Second thread will continually fault in those same pages. Third thread will continually mmap/munmap that page range.
--- runtest/hugetlb | 1 + testcases/kernel/mem/.gitignore | 1 + .../hugetlb/hugefallocate/hugefallocate03.c | 210 ++++++++++++++++++ 3 files changed, 212 insertions(+) create mode 100644 testcases/kernel/mem/hugetlb/hugefallocate/hugefallocate03.c
runtest/hugetlb +1 -0
@@ -1,5 +1,6 @@ hugefallocate01 hugefallocate01 hugefallocate02 hugefallocate02 +hugefallocate03 hugefallocate03 hugefork01 hugefork01 hugefork02 hugefork02
testcases/kernel/mem/.gitignore +1 -0
@@ -1,6 +1,7 @@ /cpuset/cpuset01 /hugetlb/hugefallocate/hugefallocate01 /hugetlb/hugefallocate/hugefallocate02 +/hugetlb/hugefallocate/hugefallocate03 /hugetlb/hugefork/hugefork01 /hugetlb/hugefork/hugefork02 /hugetlb/hugemmap/hugemmap01
testcases/kernel/mem/hugetlb/hugefallocate/hugefallocate03.c new file +210 -0
210 lines not on this page · raw message
Signature · 5 lines
2.39.2 (Apple Git-143) -- Mailing list info: https://lists.linux.it/listinfo/ltp
Hello,
Quoted 74 lines · Geetika
This test stress tests fallocate. This test starts three threads. First thread will continually punch/fill holes via falloc. Second thread will continually fault in those same pages. Third thread will continually mmap/munmap that page range.
Signed-off-by Geetika <[email protected]>--- runtest/hugetlb | 1 + testcases/kernel/mem/.gitignore | 1 + .../hugetlb/hugefallocate/hugefallocate03.c | 210 ++++++++++++++++++ 3 files changed, 212 insertions(+) create mode 100644 testcases/kernel/mem/hugetlb/hugefallocate/hugefallocate03.cruntest/hugetlb +1
-0@@ -1,5 +1,6 @@ hugefallocate01 hugefallocate01 hugefallocate02 hugefallocate02 +hugefallocate03 hugefallocate03 hugefork01 hugefork01 hugefork02 hugefork02testcases/kernel/mem/.gitignore +1
-0@@ -1,6 +1,7 @@ /cpuset/cpuset01 /hugetlb/hugefallocate/hugefallocate01 /hugetlb/hugefallocate/hugefallocate02 +/hugetlb/hugefallocate/hugefallocate03 /hugetlb/hugefork/hugefork01 /hugetlb/hugefork/hugefork02 /hugetlb/hugemmap/hugemmap01testcases/kernel/mem/hugetlb/hugefallocate/hugefallocate03.c new file +32
-0@@ -0,0 +1,210 @@ +// SPDX-License-Identifier: LGPL-2.1-or-later +/* +* Copyright (C) 2015 Oracle Corporation +* Author: Mike Kravetz +*/ + +/*\ +* [Description] +* +* Stress test fallocate. This test starts three threads. +* Thread one will continually punch/fill holes via falloc. +* Thread two will continually fault in those same pages. +* Thread three will continually mmap/munmap that page range. +* +*/ + +#define _GNU_SOURCE +#include <stdio.h> +#include <sys/mount.h> +#include <limits.h> +#include <sys/param.h> +#include <sys/types.h> +#include <pthread.h> + +#include "hugetlb.h" +#include "lapi/fallocate.h" +#include "tst_safe_pthread.h" + +#define MNTPOINT "hugetlbfs/" +#define min (a, b) (((a) < (b)) ? (a) : (b)) +#define MAX_PAGES_TO_USE 100 +#define FALLOCATE_ITERATIONS 100000
testcases/kernel/mem/hugetlb/hugefallocate/hugefallocate03.c line 42
Quoted 10 lines
testcases/kernel/mem/hugetlb/hugefallocate/hugefallocate03.c new file +10
-0+ +static int fd =-1 ; +static long nr_hpages_free; +static long max_hpages; +static int err; +static long hpage_size; +static unsigned long free_before, free_after; +static unsigned long rsvd_before, rsvd_after; + +static void *thread_fallocate (void *arg)
We never use arg so don't you get a compiler warning?
testcases/kernel/mem/hugetlb/hugefallocate/hugefallocate03.c line 51
Quoted 9 lines
testcases/kernel/mem/hugetlb/hugefallocate/hugefallocate03.c new file +9
-0+{ +int i, err; +long tpage; + +for (i =0 ; i <FALLOCATE_ITERATIONS ; i++) { + tpage = ((long long )random ()) % (max_hpages); + err =fallocate (fd, +FALLOC_FL_PUNCH_HOLE |FALLOC_FL_KEEP_SIZE , + tpage * hpage_size, hpage_size);
You can use the TEST macro here with TST_RET and TST_ERRNO.
Quoted 3 lines
testcases/kernel/mem/hugetlb/hugefallocate/hugefallocate03.c new file +2
-0+if (err) + tst_res(TFAIL, "fallocate(): %s",strerror(errno));
You can use TERRNO or TTERRNO (with the TEST macro).
This produces better output for log parsing and manual debugging.
testcases/kernel/mem/hugetlb/hugefallocate/hugefallocate03.c line 63
Quoted 10 lines
testcases/kernel/mem/hugetlb/hugefallocate/hugefallocate03.c new file +10
-0+ err =fallocate (fd,0 , tpage * hpage_size, hpage_size); +if (err) +tst_res (TFAIL ,"fallocate(): %s" ,strerror (errno)); + } +return NULL ; +} + +static void *fault_mmap_addr; + +static void thread_fault_cleanup (void *arg)
Same with arg.
testcases/kernel/mem/hugetlb/hugefallocate/hugefallocate03.c line 69
Quoted 6 lines
testcases/kernel/mem/hugetlb/hugefallocate/hugefallocate03.c new file +6
-0+{ +if (fault_mmap_addr) +munmap (fault_mmap_addr, max_hpages * hpage_size); +} + +static void *thread_fault (void *arg)
Same with arg
Quoted 10 lines
testcases/kernel/mem/hugetlb/hugefallocate/hugefallocate03.c new file +10
-0+{ +long tpage; +char foo; +struct timespec ts; + + fault_mmap_addr =SAFE_MMAP (NULL , max_hpages * hpage_size, +PROT_READ |PROT_WRITE ,MAP_SHARED , + fd,0 ); + +pthread_cleanup_push (thread_fault_cleanup,NULL );
testcases/kernel/mem/hugetlb/hugefallocate/hugefallocate03.c line 89
Quoted 10 lines
testcases/kernel/mem/hugetlb/hugefallocate/hugefallocate03.c new file +10
-0+ + ts.tv_sec =0 ; + ts.tv_nsec =0 ; + +while (1 ) { + tpage = ((long long )random ()) % (max_hpages); + foo = *((char *)(fault_mmap_addr + (tpage * hpage_size))); + *((char *)(fault_mmap_addr + (tpage * hpage_size))) = foo; + +nanosleep (&ts,NULL );/* thread cancellation point */
Could we just use sched_yield instead?
testcases/kernel/mem/hugetlb/hugefallocate/hugefallocate03.c line 99
Quoted 10 lines
testcases/kernel/mem/hugetlb/hugefallocate/hugefallocate03.c new file +10
-0+ } + +pthread_cleanup_pop (1 ); + +return NULL ; +} + +static void *mmap_munmap_addr; + +static void thread_mmap_munmap_cleanup (void *arg)
and so on
Quoted 24 lines
testcases/kernel/mem/hugetlb/hugefallocate/hugefallocate03.c new file +24
-0+{ +if (mmap_munmap_addr) +munmap (mmap_munmap_addr, max_hpages * hpage_size); +} + +static void *thread_mmap_munmap (void *arg) +{ +int err; +struct timespec ts; + +pthread_cleanup_push (thread_mmap_munmap_cleanup,NULL ); + + ts.tv_sec =0 ; + ts.tv_nsec =0 ; + +while (1 ) { + mmap_munmap_addr =SAFE_MMAP (NULL , max_hpages * hpage_size, +PROT_READ |PROT_WRITE ,MAP_SHARED , fd,0 ); +SAFE_MUNMAP (mmap_munmap_addr, max_hpages * hpage_size); + mmap_munmap_addr =NULL ; + +nanosleep (&ts,NULL );/* thread cancellation point */ + } +pthread_cleanup_pop (1 );
testcases/kernel/mem/hugetlb/hugefallocate/hugefallocate03.c line 133
Quoted 10 lines
testcases/kernel/mem/hugetlb/hugefallocate/hugefallocate03.c new file +10
-0+return NULL ; +} + +static void run_test (void ) +{ + fd =tst_creat_unlinked (MNTPOINT ,0 ); +pthread_t falloc_th, fault_th, mmap_munmap_th; +void *falloc_th_ret, *fault_th_ret, *mmap_munmap_th_ret; + +srandom ((int )getpid () *time (NULL ));
Does this need to be random? Would it be better if the test results were reproducible?
If it does need to be random then we should print the seed. So that it can be used when trying to reproduce a failure.
testcases/kernel/mem/hugetlb/hugefallocate/hugefallocate03.c line 141
Quoted 8 lines
testcases/kernel/mem/hugetlb/hugefallocate/hugefallocate03.c new file +8
-0+ + nr_hpages_free =SAFE_READ_MEMINFO (MEMINFO_HPAGE_FREE ); + max_hpages =min (nr_hpages_free,MAX_PAGES_TO_USE ); + free_before =SAFE_READ_MEMINFO (MEMINFO_HPAGE_FREE ); + rsvd_before =SAFE_READ_MEMINFO (MEMINFO_HPAGE_RSVD ); + +/* First preallocate file with max_hpages pages */ + err =fallocate (fd,0 ,0 , hpage_size * max_hpages);
Also here; TEST and TTERRNO.
Quoted 18 lines
testcases/kernel/mem/hugetlb/hugefallocate/hugefallocate03.c new file +18
-0+if (err) { +if (errno ==EOPNOTSUPP ) +tst_brk (TCONF ,"fallocate() Operation is not supported" ); +if (err) { +tst_res (TFAIL ,"fallocate(): %s" ,strerror (errno)); + goto windup; + } + } + + free_after =SAFE_READ_MEMINFO (MEMINFO_HPAGE_FREE ); +if (free_before - free_after != max_hpages) { +tst_res (TFAIL ,"fallocate did not preallocate %ld huge pages\n" , + max_hpages); + goto windup; + } + +SAFE_PTHREAD_CREATE (&falloc_th,NULL , thread_fallocate,NULL ); +
testcases/kernel/mem/hugetlb/hugefallocate/hugefallocate03.c line 169
Quoted 10 lines
testcases/kernel/mem/hugetlb/hugefallocate/hugefallocate03.c new file +10
-0+SAFE_PTHREAD_CREATE (&fault_th,NULL , thread_fault,NULL ); + +SAFE_PTHREAD_CREATE (&mmap_munmap_th,NULL , thread_mmap_munmap,NULL ); + +SAFE_PTHREAD_JOIN (falloc_th, &falloc_th_ret); + +if (falloc_th_ret) { +tst_res (TFAIL ,"thread_fallocate unexpected exit code" ); + goto windup; + }
If it is worth checking this at all, we should print the exit code.
Note that we have the TST_EXP_* macro's in tst_test_macros.h to help with this. These are incompatible with the goto, but I'm not sure that is needed?
testcases/kernel/mem/hugetlb/hugefallocate/hugefallocate03.c line 177
Quoted 8 lines
testcases/kernel/mem/hugetlb/hugefallocate/hugefallocate03.c new file +8
-0+ +SAFE_PTHREAD_CANCEL (fault_th); + +SAFE_PTHREAD_JOIN (fault_th, &fault_th_ret); + +SAFE_PTHREAD_CANCEL (mmap_munmap_th); + +SAFE_PTHREAD_JOIN (mmap_munmap_th, &mmap_munmap_th_ret);
Can't the exit code pointer just be NULL? We don't seem to check it.
Quoted 5 lines
testcases/kernel/mem/hugetlb/hugefallocate/hugefallocate03.c new file +5
-0+ +windup: +SAFE_CLOSE (fd); + + free_after =SAFE_READ_MEMINFO (MEMINFO_HPAGE_FREE );
testcases/kernel/mem/hugetlb/hugefallocate/hugefallocate03.c line 192
Quoted 10 lines
testcases/kernel/mem/hugetlb/hugefallocate/hugefallocate03.c new file +10
-0+ rsvd_after =SAFE_READ_MEMINFO (MEMINFO_HPAGE_RSVD ); +if (free_after != free_before || rsvd_after != rsvd_before) +tst_res (TFAIL ,"free or reserve counts incorrect after fallocate stress test" ); +else +tst_res (TPASS ,"fallocate stress test passed" ); +} + +static void setup (void ) +{ + hpage_size =SAFE_READ_MEMINFO (MEMINFO_HPAGE_SIZE )*1024 ;
Can we use tst_get_hugepage_size instead?
Quoted 20 lines
testcases/kernel/mem/hugetlb/hugefallocate/hugefallocate03.c new file +18
-0+} + +static void cleanup (void ) +{ +if (fd >0 ) +SAFE_CLOSE (fd); +} + +static struct tst_test test = { + .needs_root =1 , + .mntpoint =MNTPOINT , + .needs_hugetlbfs =1 , + .needs_tmpdir =1 , + .setup = setup, + .cleanup = cleanup, + .test_all = run_test, + .hugepages = {2 ,TST_NEEDS }, +};Signature · 1 line
2.39.2 (Apple Git-143)
Signature · 5 lines
Thank you, Richard. -- Mailing list info: https://lists.linux.it/listinfo/ltp