Stress-ng：RAM测试命令

Question

Stress-ng：我们可以使用stress-ng测试RAM吗？用于在MIPS 32器件上测试RAM的命令是什么？

Answer 1

有许多基于内存的应激应力-NG：

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 

另外，还可以使用基于VM应激太：

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 

我建议首先看VM应激，因为这包含大量的应激方法，可以锻炼记忆模式，并可能发现破损记忆：

-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). 

因此，要运行1 vm stressor，使用所有vm压力源的75％内存，并启用详细模式进行10分钟验证，请使用：

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