Question

我正在开发一个小功能，它可以让我的用户了解CPU的占用情况。我正在使用cat /proc/loadavg，它会返回众所周知的3个数字。

我的问题是，当我正在开发时，CPU现在没有做任何事情。

有没有一种很好的方法可以在CPU上生成som负载，我想的是像makecpudosomething 30这样的负载为0.3或类似的负载。这样的应用程序是否存在？

另外，有没有办法以受控的方式吃掉RAM？

由于

迈克尔

Answer 1

while true;
    do openssl speed;
done

压力程序还可以让你将cpu / mem / disk加载到你想要模拟的级别：

http://weather.ou.edu/~apw/projects/stress/

压力是故意的简单 POSIX系统的工作负载生成器。它强加了可配置的数量 CPU，内存，I / O和磁盘压力系统。它是用C语言编写的免费软件根据的GPLv2。

维持特定级别的cpu利用率，比如说30％，试试cpulimit：

http://cpulimit.sourceforge.net/

它将适应当前的系统环境并调整系统上的任何其他活动。

这里还有针对本机cpu速率限制的内核补丁：http://lwn.net/Articles/185489/

Answer 2

如果你想生成任意CPU load or CPU utilization，我不太了解。是的，它们确实是不同的东西。我会尽力解决这两个问题。

首先： load 是正在运行， runnable 或等待的平均进程数CPU 调度程序在给定的时间内排队，“想要你的CPU”可以说。

因此，如果你想生成任意加载（比如0.3），你必须在30％的时间内运行一个进程，然后在70％的时间内将它从运行队列中删除，例如，将其移至睡眠队列或将其杀死。

您可以尝试使用此脚本执行此操作：

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

请注意，您必须等待一段时间（1分钟，10分钟和15分钟）才能获得相应的数字，并且它会受到系统中其他进程的影响。系统越繁忙，这个数字就越漂浮。最后一个数字（间隔15分钟）往往是最准确的。

相反，

CPU usage 是CPU用于处理计算机程序指令的时间。

因此，如果你想生成任意 CPU使用率（比如说30％），你必须运行一个30％的CPU占用CPU的进程，并且占用70％的进程。

我写了一个例子来告诉你：

#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;
}

如果您想吃掉固定数量的RAM，可以使用cgkanchi答案中的程序。

Answer 3

要吃掉固定数量的RAM，你可以：

#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
    }
}

似乎需要调用memset（），因为至少在OS X上，实际内存在实际初始化之前似乎没有被使用。

编辑：已修复以回复评论

Answer 4

您可以尝试http://code.google.com/p/stressapptest/

Answer 5

使用“memtester”在Linux中进行内存回归测试。

Answer 6

我接受了这个程序并修改了这行：mem = 1024 * 1024 * 512; // 512 MB 这样说：mem = 1 * 1024 * 1024 * 1024; // 1 GB 并编译它。

$ gcc iss_mem.c -o iss_mem

在上面的C程序的编译版本周围编写一个bash包装器。它可以帮助我在服务器中产生大量的内存负载。

#!/bin/bash
# Author: Mamadou Lamine Diatta
#         Senior Principal Consultant / Infrastructure Architect
# Email:  diatta at post dot harvard dot edu
# --------------------------------------------------------------------------------------
# *************************************************************************************

memsize_kb=`grep -i MemTotal /proc/meminfo | awk '{print $2}'`
MemTotal=$(($memsize_kb*1024))
for i in `seq 1 50`
do

        echo "`date +"%F:%H:%M:%S"` ----------------- Running [ $i ] iteration(s)"
        MemToAlloc=$((1*1024*1204*1204))
            # 1Gb of memory per iss_mem call
        TRESHOLD=$(($MemTotal/$MemToAlloc))
             # We are not supposed to make the system
             # run out of memory
        rand=1000
            # High enough to force a new one
        while (( $rand > $TRESHOLD ))
        do
                rand=$(($RANDOM/1000))
        done
        if [ $rand -eq 0 ]
        then
                rand=1
        fi

        echo `date +"%F:%H:%M:%S"` Running $rand iss_mem in parallel ...
        for j in `seq 1 $rand`
        do
             ${ISSHOME}/bin/iss_mem > /dev/null &
                # NOTE: gcc iss_mem.c -o iss_mem
        done

        sleep 180
        jobs -p
        kill `jobs -p`

        sleep 30


done
# -------------------------------------------------------------------------------------
# *************************************************************************************

Answer 7

实际上很简单：安装stress工具并执行：

stress --vm X --vm-bytes YM

将X替换为您要生成的工作人员数量和“malloc()”RAM
将Y替换为每个工作人员必须分配的内存量

示例：

stress --vm 2 --vm-bytes 128M

Answer 8

您是否考虑过使用prime95？

我不确定你是否可以将它限制在像这样的百分比......

Answer 9

mark@localhost$ time pi 1048576 | egrep '.*total$'

是一个简单的基准测试命令，可以让你的cpu成为一个烦恼，发布你的时间：D

Answer 10

我发现加载RAM（和SWAP）的最简单方法是使用Perl：

my $allocation = "A" x (1024 * 1024 * $ARGV[0]);
print "\nAllocated " . length($allocation) . "\n";

Answer 11

希望这个应用程序有用：

https://www.devin.com/lookbusy/

安装和使用的步骤可以在使用lookbusy的github项目中找到。

https://github.com/beloglazov/cpu-load-generator

来自Github的

片段：

使用test.data文件在2个核心上生成20％，90％和50％CPU利用率的序列，每次20秒，

python cpu-load-generator.py -n 2 20 test.data

Answer 12

你可以强调实用程序，因为它是一个工作负载生成器工具，旨在使系统受到CPU，内存，I / O和磁盘压力的可配置测量。

要使用1GB虚拟内存运行1 vm压力源60秒，请输入：

压力--vm 1 --vm-bytes 1G --vm-keep -t 60s

Answer 13

1G内存

python -c 'a="a"*1024**3;raw_input()'

Answer 14

我认为这篇文章对此很有创意。 Credit to solution

例如，这应“强调” 100 MB 2分钟

cat <(yes | tr \\n x | head -c $((1024*1024*100))) <(sleep 120) | grep n

Linux：如何加载系统内存？

14 个答案: