Linux: Wie belastet man den Systemspeicher?

Question

Ich arbeite an einer kleinen Funktion, die meinen Benutzern ein Bild davon gibt, wie stark die CPU ausgelastet ist.

Ich benutze cat /proc/loadavg , die die bekannten 3 Zahlen liefert.

Mein Problem ist, dass die CPU im Moment nichts tut, während ich entwickle.

Gibt es einen guten Weg, um etwas Last auf der CPU zu erzeugen, ich dachte an etwas wie makecpudosomething 30 für eine Last von 0,3 oder ähnlich. Gibt es eine solche Anwendung?

Gibt es außerdem eine Möglichkeit, RAM kontrolliert zu verbrauchen?

Answer 1

while true;
    do openssl speed;
done

Außerdem können Sie mit dem Stressprogramm die CPU/Mem/Disk auf die zu simulierenden Werte einstellen:

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

Stress ist eine bewusst einfach gehaltene Workload-Generator für POSIX-Systeme. Er erlegt eine konfigurierbare Menge an CPU-, Speicher-, E/A- und Festplattenbelastung auf das System. Er ist in C geschrieben und ist freie Software, die unter der Lizenz der GPLv2.

um ein bestimmtes Niveau der CPU-Auslastung aufrechtzuerhalten, sagen wir 30%, versuchen Sie cpulimit:

• http://cpulimit.sourceforge.net/

Es passt sich an die aktuelle Systemumgebung an und stellt sich auf alle anderen Aktivitäten im System ein.

Es gibt auch einen Patch für den Kernel für native CPU-Ratenbegrenzungen hier: http://lwn.net/Articles/185489/

Answer 2

Ich habe nicht ganz verstanden, ob man willkürliche CPU-Last oder CPU-Auslastung . Ja, das sind in der Tat unterschiedliche Dinge. Ich werde versuchen, beide Probleme zu behandeln.

Zuallererst: laden ist die durchschnittliche Anzahl der Prozesse in der läuft , lauffähig o Warten auf CPU Scheduler-Warteschlangen in einer bestimmten Zeitspanne, sozusagen "derjenige, der Ihre CPU will".

Wenn Sie also willkürliche laden (z. B. 0,3) müssen Sie einen Prozess 30 % der Zeit laufen lassen und ihn dann 70 % der Zeit aus der Ausführungswarteschlange entfernen, indem Sie ihn z. B. in die Warteschlange für den Ruhezustand verschieben oder ihn abschalten.

Dazu können Sie dieses Skript verwenden:

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

Beachten Sie, dass Sie einige Zeit (1, 10 und 15 Minuten) warten müssen, bis die entsprechenden Zahlen angezeigt werden, und dass dies durch andere Prozesse in Ihrem System beeinflusst wird. Je stärker Ihr System ausgelastet ist, desto mehr schwanken diese Zahlen. Die letzte Zahl (15-Minuten-Intervall) ist in der Regel die genaueste.

CPU-Last ist stattdessen die Zeitspanne, in der die CPU für die Verarbeitung von Anweisungen eines Computerprogramms verwendet wurde.

Wenn Sie also willkürliche CPU-Last (sagen wir 30 %) müssen Sie einen Prozess laufen lassen, der 30 % der Zeit an die CPU gebunden ist und 70 % der Zeit schläft.

Ich habe ein Beispiel geschrieben, um Ihnen das zu zeigen:

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

Wenn Sie eine feste Menge an RAM verbrauchen wollen, können Sie das Programm im cgkanchi 's Antwort .

Answer 3

1G Speicher

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

Answer 4

Um eine feste Menge an RAM zu verbrauchen, könnten Sie einfach:

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

Der memset()-Aufruf scheint erforderlich zu sein, da zumindest unter OS X der tatsächliche Speicher nicht verwendet zu werden scheint, bis er tatsächlich initialisiert wird.

EDIT: Als Antwort auf einen Kommentar korrigiert

Answer 5

Eigentlich ganz einfach: installieren Stress Werkzeug und tun:

stress --vm X --vm-bytes YM

• ersetzen Sie X durch die Anzahl der Arbeiter, die Sie erzeugen wollen, und " malloc() " Ihr RAM
• Y durch die Menge an Speicher ersetzen, die jeder Arbeiter zuweisen muss

例

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