Linux: Comment mettre une charge sur le système de mémoire?

Je ne comprenais pas très bien si vous voulez générer des La charge du PROCESSEUR ou de l'utilisation de l'UC. Oui, ils sont différents des choses en effet. Je vais essayer de couvrir à la fois les problèmes.

Tout d'abord: charge est le nombre moyen de processus dans le de course, praticable ou d'attente pour le CPU planificateur de files d'attente dans un laps de temps donné, "celui qui veut votre CPU" pour ainsi dire.

Donc, si vous voulez générer des charge (dire 0.3), vous devez exécuter un processus de 30% du temps, et puis la retirer de la file d'attente d'exécution pour 70% du temps, en le déplaçant vers la file d'attente de couchage ou de le tuer, par exemple.

Vous pouvez essayer ce script pour faire ça:

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

Noter que vous devez attendre un certain temps (1, 10 et 15 minutes) pour obtenir le nombre de venir, et il sera influencé par d'autres processus dans votre système. Le plus occupé de votre système est plus ce nombre flottant. Le dernier numéro (15 minutes d'intervalle) a tendance à être le plus précis.

Utilisation de l'UC est, au lieu de cela, la quantité de temps pendant lequel la CPU a été utilisé pour le traitement des instructions d'un programme informatique.

Donc, si vous voulez générer des utilisation de l'UC (disons 30%) vous devez exécuter un processus qui est lié de l'UC 30% du temps, capacité de 70%.

J'ai écrit un exemple pour vous montrer que:

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

Si vous voulez manger une quantité fixe de RAM, vous pouvez utiliser le programme dans le cgkanchi's réponse.

OriginalL'auteur Carmine Paolino

De manger jusqu'à un montant fixe de RAM, vous pouvez simplement:

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

Le memset() appel semble être nécessaire, parce que, au moins sur OS X, la mémoire réelle ne semble pas obtenir utilisé jusqu'à ce qu'il est réellement initialisé.

EDIT: Fixe en réponse au commentaire

OriginalL'auteur Chinmay Kanchi

Utiliser "memtester" pour faire de votre mémoire, des tests de régression dans Linux.

OriginalL'auteur Janaka

Très simple en fait: installer le stress de l'outil et de le faire:

stress --vm X --vm-bytes YM

• remplacer X par le nombre de travailleurs que vous voulez lancer et "malloc()" votre RAM
• remplacer Y par la quantité de mémoire que chaque travailleur a allouer

Exemple:

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

OriginalL'auteur thermz

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

Est une simple analyse comparative de commande qui donnera à votre unité centrale rousting, postez votre temps 😀

OriginalL'auteur Question Mark

Espérons que cette application sera utile:

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

Étapes d'installation et d'utilisation est trouvé dans github du projet qui utilise lookbusy.

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

Extrait à partir de Github page:

Pour générer une séquence de 20%, 90%, et 50% d'utilisation du PROCESSEUR pendant 20 secondes chacune sur 2 cœurs à l'aide de test.fichier de données,

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

OriginalL'auteur dkb

1G de mémoire

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

OriginalL'auteur Feng