Linux: How to put a load on system memory?

后端 未结 12 1985
清酒与你
清酒与你 2021-02-10 07:54

I\'m working on a small function, that gives my users a picture of how occupied the CPU is.

I\'m using cat /proc/loadavg, which returns the well known 3 num

相关标签:
12条回答
  • 2021-02-10 08:15

    You can try http://code.google.com/p/stressapptest/

    0 讨论(0)
  • 2021-02-10 08:16

    Have you considered using prime95?

    I'm not sure if you can limit it to a percentage like that tho...

    0 讨论(0)
  • 2021-02-10 08:23

    I didn't understand very well if you want to generate arbitrary CPU load or CPU utilization. Yes, they are different things indeed. I'll try to cover both problems.

    First of all: load is the average number of processes in the running, runnable or waiting for CPU scheduler queues in a given amount of time, "the one that wants your CPU" so to speak.

    So, if you want to generate arbitrary load (say 0.3) you have to run a process for 30% of the time and then remove it from the run queue for 70% of the time, moving it to the sleeping queue or killing it, for example.

    You can try this script to do that:

    export LOAD=0.3
    while true
         do yes > /dev/null &
         sleep $LOAD
         killall yes
         sleep `echo "1 - $LOAD" | bc`
    done
    

    Note that you have to wait some time (1, 10 and 15 minutes) to get the respective numbers to come up, and it will be influenced by other processes in your system. The more busy your system is the more this numbers will float. The last number (15 minutes interval) tends to be the most accurate.

    CPU usage is, instead, the amount of time for which CPU was used for processing instructions of a computer program.

    So, if you want to generate arbitrary CPU usage (say 30%) you have to run a process that is CPU bound 30% of the time and sleeps 70% of it.

    I wrote an example to show you that:

    #include <stdlib.h>
    #include <unistd.h>
    #include <err.h>
    #include <math.h>
    #include <sys/time.h>
    #include <stdarg.h>
    #include <sys/wait.h>
    
    #define CPUUSAGE 0.3      /* set it to a 0 < float < 1 */
    #define PROCESSES 1       /* number of child worker processes */
    #define CYCLETIME 50000   /* total cycle interval in microseconds */
    
    #define WORKTIME (CYCLETIME * CPUUSAGE)
    #define SLEEPTIME (CYCLETIME - WORKTIME)
    
    /* returns t1-t2 in microseconds */
    static inline long timediff(const struct timeval *t1, const struct timeval *t2)
    {
      return (t1->tv_sec - t2->tv_sec) * 1000000 + (t1->tv_usec - t2->tv_usec);
    }
    
    static inline void gettime (struct timeval *t)
    {
      if (gettimeofday(t, NULL) < 0)
      {
        err(1, "failed to acquire time");
      }
    }
    
    int hogcpu (void)
    {
      struct timeval tWorkStart, tWorkCur, tSleepStart, tSleepStop;
      long usSleep, usWork, usWorkDelay = 0, usSleepDelay = 0;
    
      do
      {
        usWork = WORKTIME - usWorkDelay;
        gettime (&tWorkStart);
        do
        {
          sqrt (rand ());
          gettime (&tWorkCur);
        }
        while ((usWorkDelay = (timediff (&tWorkCur, &tWorkStart) - usWork)) < 0);
    
        if (usSleepDelay <= SLEEPTIME)
          usSleep = SLEEPTIME - usSleepDelay;
        else
          usSleep = SLEEPTIME;
    
        gettime (&tSleepStart);
        usleep (usSleep);
        gettime (&tSleepStop);
        usSleepDelay = timediff (&tSleepStop, &tSleepStart) - usSleep;
      }
      while (1);
      return 0;
    }
    
    int main (int argc, char const *argv[])
    {
      pid_t pid;
      int i;
      for (i = 0; i < PROCESSES; i++)
      {
        switch (pid = fork ())
        {
        case 0:
          _exit (hogcpu ());
        case -1:
          err (1, "fork failed");
          break;
        default:
          warnx ("worker [%d] forked", pid);
        }
      }
      wait(NULL);
      return 0;
    }
    

    If you want to eat up a fixed amount of RAM you can use the program in the cgkanchi's answer.

    0 讨论(0)
  • 2021-02-10 08:24

    Very simple actually: install stress tool and do:

    stress --vm X --vm-bytes YM
    
    • replace X with the number of worker you want to spawn and "malloc()" your RAM
    • replace Y with the amount of memory that each worker has to allocate

    Example:

    stress --vm 2 --vm-bytes 128M
    
    0 讨论(0)
  • 2021-02-10 08:24

    To eat up a fixed amount of RAM, you could just:

    #include <stdlib.h>
    #include <string.h>
    #define UNIX 1
    
    //remove the above line if running under Windows
    
    #ifdef UNIX
        #include <unistd.h>
    #else
        #include <windows.h>
    #endif
    
    int main(int argc, char** argv)
    {
        unsigned long mem;
        if(argc==1)
            mem = 1024*1024*512; //512 mb
        else if(argc==2)
            mem = (unsigned) atol(argv[1]);
        else
        {
            printf("Usage: loadmem <memory in bytes>");
            exit(1);
        }
    
        char* ptr = malloc(mem);
        while(1)
        {
            memset(ptr, 0, mem);
            #ifdef UNIX
                sleep(120);
            #else
                Sleep(120*1000);
            #endif
        }
    }
    

    The memset() call seems to be required, because at least on OS X, the actual memory doesn't seem to get used until it is actually initialised.

    EDIT: Fixed in response to comment

    0 讨论(0)
  • 2021-02-10 08:25

    The simplest way I have found to load the RAM (and SWAP) is by using Perl:

    my $allocation = "A" x (1024 * 1024 * $ARGV[0]);
    print "\nAllocated " . length($allocation) . "\n";
    
    0 讨论(0)
提交回复
热议问题