stress-ng --class memory?
class 'memory' stressors: atomic bsearch context full heapsort hsearch
lockbus lsearch malloc matrix membarrier memcpy memfd memrate memthrash
mergesort mincore null numa oom-pipe pipe qsort radixsort remap
resources rmap stack stackmmap str stream tlb-shootdown tmpfs tsearch
vm vm-rw wcs zero zlib

stress-ng --class vm?
class 'vm' stressors: bigheap brk madvise malloc mlock mmap mmapfork mmapmany
mremap msync shm shm-sysv stack stackmmap tmpfs userfaultfd vm vm-rw
vm-splice

-m N, --vm N
          start N workers continuously calling mmap(2)/munmap(2) and writ‐
          ing to the allocated memory. Note that this can cause systems to
          trip the kernel OOM killer on Linux systems if not enough physi‐
          cal memory and swap is not available.

   --vm-bytes N
          mmap  N bytes per vm worker, the default is 256MB. One can spec‐
          ify the size as % of total  available  memory  or  in  units  of
          Bytes, KBytes, MBytes and GBytes using the suffix b, k, m or g.

   --vm-ops N
          stop vm workers after N bogo operations.

   --vm-hang N
          sleep  N  seconds  before  unmapping memory, the default is zero
          seconds.  Specifying 0 will do an infinite wait.

   --vm-keep
          do not continually unmap and map memory, just keep on re-writing
          to it.

   --vm-locked
          Lock  the  pages  of  the  mapped  region into memory using mmap
          MAP_LOCKED (since Linux 2.5.37).  This  is  similar  to  locking
          memory as described in mlock(2).

   --vm-madvise advice
          Specify  the  madvise  'advice' option used on the memory mapped
          regions used in the vm stressor.  Non-linux  systems  will  only
          have  the  'normal' madvise advice, linux systems support 'dont‐
          need', 'hugepage', 'mergeable' , 'nohugepage',  'normal',  'ran‐
          dom', 'sequential', 'unmergeable' and 'willneed' advice. If this
          option is not used then the default is to  pick  random  madvise
          advice for each mmap call. See madvise(2) for more details.

   --vm-method m
          specify  a  vm stress method. By default, all the stress methods
          are exercised sequentially, however one  can  specify  just  one
          method  to  be  used if required.  Each of the vm workers have 3
          phases:

          1. Initialised. The anonymously memory mapped region is set to a
          known pattern.

          2.  Exercised.  Memory  is  modified in a known predictable way.
          Some vm workers alter memory sequentially,  some  use  small  or
          large strides to step along memory.

          3.  Checked. The modified memory is checked to see if it matches
          the expected result.

          The vm methods containing 'prime' in their name have a stride of
          the largest prime less than 2^64, allowing to them to thoroughly
          step through memory and touch all locations just once while also
          doing  without  touching  memory  cells next to each other. This
          strategy exercises the cache and page non-locality.

          Since the memory being exercised is virtually mapped then  there
          is  no  guarantee  of  touching page addresses in any particular
          physical order.  These workers should not be used to  test  that
          all  the  system's memory is working correctly either, use tools
          such as memtest86 instead.

          The vm stress methods are intended to exercise memory in ways to
          possibly find memory issues and to try to force thermal errors.

          Available vm stress methods are described as follows:

          Method                  Description
          all                     iterate  over  all the vm stress methods
                                  as listed below.
          flip                    sequentially  work  through   memory   8
                                  times,  each time just one bit in memory
                                  flipped  (inverted).  This  will  effec‐
                                  tively invert each byte in 8 passes.
          galpat-0                galloping  pattern  zeros. This sets all
                                  bits to 0 and flips just 1 in 4096  bits
                                  to  1.  It  then checks to see if the 1s
                                  are pulled down to 0 by their neighbours
                                  or of the neighbours have been pulled up
                                  to 1.
          galpat-1                galloping pattern ones.  This  sets  all
                                  bits  to 1 and flips just 1 in 4096 bits
                                  to 0. It then checks to see  if  the  0s
                                  are  pulled  up to 1 by their neighbours
                                  or of the neighbours  have  been  pulled
                                  down to 0.
          gray                    fill  the  memory  with  sequential gray
                                  codes (these only change 1 bit at a time
                                  between  adjacent  bytes) and then check
                                  if they are set correctly.
          incdec                  work sequentially through memory  twice,
                                  the first pass increments each byte by a
                                  specific  value  and  the  second   pass
                                  decrements  each byte back to the origi‐
                                  nal start value. The increment/decrement
                                  value  changes on each invocation of the
                                  stressor.
          inc-nybble              initialise memory to a set  value  (that
                                  changes on each invocation of the stres‐
                                  sor) and then sequentially work  through
                                  each byte incrementing the bottom 4 bits
                                  by 1 and the top 4 bits by 15.
          rand-set                sequentially work through memory  in  64
                                  bit chunks setting bytes in the chunk to
                                  the same 8 bit random value.  The random
                                  value changes on each chunk.  Check that
                                  the values have not changed.
          rand-sum                sequentially set all  memory  to  random
                                  values  and  then  summate the number of
                                  bits that have changed from the original
                                  set values.
          read64                  sequentially  read  memory using 32 x 64
                                  bit  reads  per  bogo  loop.  Each  loop
                                  equates  to  one  bogo  operation.  This
                                  exercises raw memory reads.
          ror                     fill memory with a  random  pattern  and
                                  then sequentially rotate 64 bits of mem‐
                                  ory right by one  bit,  then  check  the
                                  final load/rotate/stored values.
          swap                    fill  memory in 64 byte chunks with ran‐
                                  dom patterns. Then swap  each  64  chunk
                                  with  a  randomly chosen chunk. Finally,
                                  reverse the swap to put the chunks  back
                                  to their original place and check if the
                                  data is correct. This exercises adjacent
                                  and random memory load/stores.
          move-inv                sequentially fill memory 64 bits of mem‐
                                  ory at a time with  random  values,  and
                                  then  check  if  the  memory is set cor‐
                                  rectly.  Next, sequentially invert  each
                                  64  bit  pattern  and again check if the
                                  memory is set as expected.
          modulo-x                fill memory  over  23  iterations.  Each
                                  iteration  starts one byte further along
                                  from the start of the memory  and  steps
                                  along   in  23  byte  strides.  In  each
                                  stride, the first byte is set to a  ran‐
                                  dom  pattern and all other bytes are set
                                  to the inverse.  Then it checks  see  if
                                  the  first  byte  contains  the expected
                                  random  pattern.  This  exercises  cache
                                  store/reads  as well as seeing if neigh‐
                                  bouring cells influence each other.

          prime-0                 iterate 8 times by stepping through mem‐
                                  ory in very large prime strides clearing
                                  just on bit at a  time  in  every  byte.
                                  Then check to see if all bits are set to
                                  zero.
          prime-1                 iterate 8 times by stepping through mem‐
                                  ory  in very large prime strides setting
                                  just on bit at a  time  in  every  byte.
                                  Then check to see if all bits are set to
                                  one.
          prime-gray-0            first step through memory in very  large
                                  prime   strides  clearing  just  on  bit
                                  (based on a gray code)  in  every  byte.
                                  Next,  repeat this but clear the other 7
                                  bits. Then check to see if all bits  are
                                  set to zero.
          prime-gray-1            first  step through memory in very large
                                  prime strides setting just on bit (based
                                  on  a  gray  code)  in every byte. Next,
                                  repeat this but set the  other  7  bits.
                                  Then check to see if all bits are set to
                                  one.
          rowhammer               try to force memory corruption using the
                                  rowhammer  memory stressor. This fetches
                                  two 32  bit  integers  from  memory  and
                                  forces   a   cache   flush  on  the  two
                                  addresses multiple times. This has  been
                                  known  to  force  bit  flipping  on some
                                  hardware,  especially  with  lower  fre‐
                                  quency memory refresh cycles.
          walk-0d                 for  each  byte  in memory, walk through
                                  each data line setting them to low  (and
                                  the  others are set high) and check that
                                  the written value is as  expected.  This
                                  checks if any data lines are stuck.
          walk-1d                 for  each  byte  in memory, walk through
                                  each data line setting them to high (and
                                  the  others  are set low) and check that
                                  the written value is as  expected.  This
                                  checks if any data lines are stuck.
          walk-0a                 in   the   given  memory  mapping,  work
                                  through  a  range  of  specially  chosen
                                  addresses  working through address lines
                                  to see if any address  lines  are  stuck
                                  low.  This works best with physical mem‐
                                  ory  addressing,   however,   exercising
                                  these  virtual  addresses has some value
                                  too.
          walk-1a                 in  the  given  memory   mapping,   work
                                  through  a  range  of  specially  chosen
                                  addresses working through address  lines
                                  to  see  if  any address lines are stuck
                                  high. This works best with physical mem‐
                                  ory   addressing,   however,  exercising
                                  these virtual addresses has  some  value
                                  too.
          write64                 sequentially  write memory using 32 x 64
                                  bit writes  per  bogo  loop.  Each  loop
                                  equates  to  one  bogo  operation.  This
                                  exercises raw memory writes.  Note  that
                                  memory writes are not checked at the end
                                  of each test iteration.
          zero-one                set all memory bits  to  zero  and  then
                                  check  if  any  bits are not zero. Next,
                                  set all the memory bits to one and check
                                  if any bits are not one.

   --vm-populate
          populate  (prefault)  page  tables for the memory mappings; this
          can stress swapping. Only  available  on  systems  that  support
          MAP_POPULATE (since Linux 2.5.46).

stress-ng --vm 1 --vm-bytes 75% --vm-method all --verify -t 10m -v