Alto uso de CPU com CFS?

25

Eu fiz uma pergunta anterior para tentar isolar a fonte de um aumento no uso da CPU ao mover um aplicativo do RHEL 5 para o RHEL 6. A análise que fiz para isso parece indicar que está sendo causada pelo CFS no kernel. Eu escrevi um aplicativo de teste para tentar verificar se era esse o caso (aplicativo de teste original removido para caber no limite de tamanho, mas ainda disponível no repositório git .

Eu o compilei com o seguinte comando no RHEL 5:

cc test_select_work.c -O2 -DSLEEP_TYPE=0 -Wall -Wextra -lm -lpthread -o test_select_work

Em seguida, joguei com os parâmetros até que o tempo de execução por iteração fosse de aproximadamente 1 ms em um Dell Precision m6500.

Obtive o seguinte resultado no RHEL 5:

./test_select_work 1000 10000 300 4
time_per_iteration: min: 911.5 us avg: 913.7 us max: 917.1 us stddev: 2.4 us
./test_select_work 1000 10000 300 8
time_per_iteration: min: 1802.6 us avg: 1803.9 us max: 1809.1 us stddev: 2.1 us
./test_select_work 1000 10000 300 40
time_per_iteration: min: 7580.4 us avg: 8567.3 us max: 9022.0 us stddev: 299.6 us

E o seguinte no RHEL 6:

./test_select_work 1000 10000 300 4
time_per_iteration: min: 914.6 us avg: 975.7 us max: 1034.5 us stddev: 50.0 us
./test_select_work 1000 10000 300 8
time_per_iteration: min: 1683.9 us avg: 1771.8 us max: 1810.8 us stddev: 43.4 us
./test_select_work 1000 10000 300 40
time_per_iteration: min: 7997.1 us avg: 8709.1 us max: 9061.8 us stddev: 310.0 us

Em ambas as versões, esses resultados foram sobre o que eu esperava com o tempo médio por iteração dimensionado de forma relativamente linear. Em seguida, recompilei -DSLEEP_TYPE=1e obtive os seguintes resultados no RHEL 5:

./test_select_work 1000 10000 300 4
time_per_iteration: min: 1803.3 us avg: 1902.8 us max: 2001.5 us stddev: 113.8 us
./test_select_work 1000 10000 300 8
time_per_iteration: min: 1997.1 us avg: 2002.0 us max: 2010.8 us stddev: 5.0 us
./test_select_work 1000 10000 300 40
time_per_iteration: min: 6958.4 us avg: 8397.9 us max: 9423.7 us stddev: 619.7 us

E os seguintes resultados no RHEL 6:

./test_select_work 1000 10000 300 4
time_per_iteration: min: 2107.1 us avg: 2143.1 us max: 2177.7 us stddev: 30.3 us
./test_select_work 1000 10000 300 8
time_per_iteration: min: 2903.3 us avg: 2903.8 us max: 2904.3 us stddev: 0.3 us
./test_select_work 1000 10000 300 40
time_per_iteration: min: 8877.7.1 us avg: 9016.3 us max: 9112.6 us stddev: 62.9 us

No RHEL 5, os resultados foram parecidos com o que eu esperava (4 threads demorando o dobro do tempo por causa do sono de 1 ms, mas os 8 threads demoram o mesmo tempo, pois cada thread agora dorme pela metade do tempo e ainda é bastante razoável aumento linear).

No entanto, com o RHEL 6, o tempo gasto com 4 threads aumentou cerca de 15% a mais do que a duplicação esperada e a caixa de 8 threads aumentou cerca de 45% a mais do que o leve aumento esperado. O aumento no caso de 4 threads parece que o RHEL 6 está realmente dormindo por um punhado de microssegundos mais de 1 ms, enquanto o RHEL 5 dorme apenas cerca de 900 nós, mas isso não explica o aumento inesperadamente grande nos 8 e 40 casos de rosca.

Vi tipos semelhantes de comportamento com todos os valores de 3-DSLEEP_TYPE. Eu também tentei brincar com os parâmetros do agendador no sysctl, mas nada parecia ter um impacto significativo nos resultados. Alguma idéia de como posso diagnosticar ainda mais esse problema?

UPDATE: 2012-05-07

Adicionei medições do uso da CPU do usuário e do sistema em / proc / stat // tarefas // stat como uma saída do teste para tentar obter outro ponto de observação. Também encontrei um problema com o modo como a média e o desvio padrão estavam sendo atualizados quando foi adicionado o loop de iteração externa; portanto, adicionarei os novos gráficos que têm as medidas corrigidas de média e desvio padrão. Eu incluí o programa atualizado. Também fiz um repositório git para rastrear o código e ele está disponível aqui.

#include <limits.h>
#include <math.h>
#include <poll.h>
#include <pthread.h>
#include <sched.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <unistd.h>
#include <sys/select.h>
#include <sys/syscall.h>
#include <sys/time.h>


// Apparently GLIBC doesn't provide a wrapper for this function so provide it here
#ifndef HAS_GETTID
pid_t gettid(void)
{
  return syscall(SYS_gettid);
}
#endif


// The different type of sleep that are supported
enum sleep_type {
  SLEEP_TYPE_NONE,
  SLEEP_TYPE_SELECT,
  SLEEP_TYPE_POLL,
  SLEEP_TYPE_USLEEP,
  SLEEP_TYPE_YIELD,
  SLEEP_TYPE_PTHREAD_COND,
  SLEEP_TYPE_NANOSLEEP,
};

// Information returned by the processing thread
struct thread_res {
  long long clock;
  long long user;
  long long sys;
};

// Function type for doing work with a sleep
typedef struct thread_res *(*work_func)(const int pid, const int sleep_time, const int num_iterations, const int work_size);

// Information passed to the thread
struct thread_info {
  pid_t pid;
  int sleep_time;
  int num_iterations;
  int work_size;
  work_func func;
};


inline void get_thread_times(pid_t pid, pid_t tid, unsigned long long *utime, unsigned long long *stime)
{
  char filename[FILENAME_MAX];
  FILE *f;

  sprintf(filename, "/proc/%d/task/%d/stat", pid, tid);
  f = fopen(filename, "r");
  if (f == NULL) {
    *utime = 0;
    *stime = 0;
    return;
  }

  fscanf(f, "%*d %*s %*c %*d %*d %*d %*d %*d %*u %*u %*u %*u %*u %Lu %Lu", utime, stime);

  fclose(f);
}

// In order to make SLEEP_TYPE a run-time parameter function pointers are used.
// The function pointer could have been to the sleep function being used, but
// then that would mean an extra function call inside of the "work loop" and I
// wanted to keep the measurements as tight as possible and the extra work being
// done to be as small/controlled as possible so instead the work is declared as
// a seriees of macros that are called in all of the sleep functions. The code
// is a bit uglier this way, but I believe it results in a more accurate test.

// Fill in a buffer with random numbers (taken from latt.c by Jens Axboe <[email protected]>)
#define DECLARE_FUNC(NAME) struct thread_res *do_work_##NAME(const int pid, const int sleep_time, const int num_iterations, const int work_size)

#define DECLARE_WORK() \
  int *buf; \
  int pseed; \
  int inum, bnum; \
  pid_t tid; \
  struct timeval clock_before, clock_after; \
  unsigned long long user_before, user_after; \
  unsigned long long sys_before, sys_after; \
  struct thread_res *diff; \
  tid = gettid(); \
  buf = malloc(work_size * sizeof(*buf)); \
  diff = malloc(sizeof(*diff)); \
  get_thread_times(pid, tid, &user_before, &sys_before); \
  gettimeofday(&clock_before, NULL)

#define DO_WORK(SLEEP_FUNC) \
  for (inum=0; inum<num_iterations; ++inum) { \
    SLEEP_FUNC \
     \
    pseed = 1; \
    for (bnum=0; bnum<work_size; ++bnum) { \
      pseed = pseed * 1103515245 + 12345; \
      buf[bnum] = (pseed / 65536) % 32768; \
    } \
  } \

#define FINISH_WORK() \
  gettimeofday(&clock_after, NULL); \
  get_thread_times(pid, tid, &user_after, &sys_after); \
  diff->clock = 1000000LL * (clock_after.tv_sec - clock_before.tv_sec); \
  diff->clock += clock_after.tv_usec - clock_before.tv_usec; \
  diff->user = user_after - user_before; \
  diff->sys = sys_after - sys_before; \
  free(buf); \
  return diff

DECLARE_FUNC(nosleep)

{
  DECLARE_WORK();

  // Let the compiler know that sleep_time isn't used in this function
  (void)sleep_time;

  DO_WORK();

  FINISH_WORK();
}

DECLARE_FUNC(select)
{
  struct timeval ts;
  DECLARE_WORK();

  DO_WORK(
    ts.tv_sec = 0;
    ts.tv_usec = sleep_time;
    select(0, 0, 0, 0, &ts);
    );

  FINISH_WORK();
}

DECLARE_FUNC(poll)
{
  struct pollfd pfd;
  const int sleep_time_ms = sleep_time / 1000;
  DECLARE_WORK();

  pfd.fd = 0;
  pfd.events = 0;

  DO_WORK(
    poll(&pfd, 1, sleep_time_ms);
    );

  FINISH_WORK();
}

DECLARE_FUNC(usleep)
{
  DECLARE_WORK();

  DO_WORK(
    usleep(sleep_time);
    );

  FINISH_WORK();
}

DECLARE_FUNC(yield)
{
  DECLARE_WORK();

  // Let the compiler know that sleep_time isn't used in this function
  (void)sleep_time;

  DO_WORK(
    sched_yield();
    );

  FINISH_WORK();
}

DECLARE_FUNC(pthread_cond)
{
  pthread_cond_t cond  = PTHREAD_COND_INITIALIZER;
  pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
  struct timespec ts;
  const int sleep_time_ns = sleep_time * 1000;
  DECLARE_WORK();

  pthread_mutex_lock(&mutex);

  DO_WORK(
    clock_gettime(CLOCK_REALTIME, &ts);
    ts.tv_nsec += sleep_time_ns;
    if (ts.tv_nsec >= 1000000000) {
      ts.tv_sec += 1;
      ts.tv_nsec -= 1000000000;
    }
    pthread_cond_timedwait(&cond, &mutex, &ts);
    );

  pthread_mutex_unlock(&mutex);

  pthread_cond_destroy(&cond);
  pthread_mutex_destroy(&mutex);

  FINISH_WORK();
}

DECLARE_FUNC(nanosleep)
{
  struct timespec req, rem;
  const int sleep_time_ns = sleep_time * 1000;
  DECLARE_WORK();

  DO_WORK(
    req.tv_sec = 0;
    req.tv_nsec = sleep_time_ns;
    nanosleep(&req, &rem);
    );

  FINISH_WORK();
}

void *do_test(void *arg)
{
  const struct thread_info *tinfo = (struct thread_info *)arg;

  // Call the function to do the work
  return (*tinfo->func)(tinfo->pid, tinfo->sleep_time, tinfo->num_iterations, tinfo->work_size);
}

struct thread_res_stats {
  double min;
  double max;
  double avg;
  double stddev;
  double prev_avg;
};

#ifdef LLONG_MAX
  #define THREAD_RES_STATS_INITIALIZER {LLONG_MAX, LLONG_MIN, 0, 0, 0}
#else
  #define THREAD_RES_STATS_INITIALIZER {LONG_MAX, LONG_MIN, 0, 0, 0}
#endif

void update_stats(struct thread_res_stats *stats, long long value, int num_samples, int num_iterations, double scale_to_usecs)
{
  // Calculate the average time per iteration
  double value_per_iteration = value * scale_to_usecs / num_iterations;

  // Update the max and min
  if (value_per_iteration < stats->min)
    stats->min = value_per_iteration;
  if (value_per_iteration > stats->max)
    stats->max = value_per_iteration;
  // Update the average
  stats->avg += (value_per_iteration - stats->avg) / (double)(num_samples);
  // Update the standard deviation
  stats->stddev += (value_per_iteration - stats->prev_avg) * (value_per_iteration - stats->avg);
  // And record the current average for use in the next update
  stats->prev_avg= stats->avg;
}

void print_stats(const char *name, const struct thread_res_stats *stats)
{
  printf("%s: min: %.1f us avg: %.1f us max: %.1f us stddev: %.1f us\n",
      name,
      stats->min,
      stats->avg,
      stats->max,
      stats->stddev);
}

int main(int argc, char **argv)
{
  if (argc <= 6) {
    printf("Usage: %s <sleep_time> <outer_iterations> <inner_iterations> <work_size> <num_threads> <sleep_type>\n", argv[0]);
    printf("  outer_iterations: Number of iterations for each thread (used to calculate statistics)\n");
    printf("  inner_iterations: Number of work/sleep cycles performed in each thread (used to improve consistency/observability))\n");
    printf("  work_size: Number of array elements (in kb) that are filled with psuedo-random numbers\n");
    printf("  num_threads: Number of threads to spawn and perform work/sleep cycles in\n");
    printf("  sleep_type: 0=none 1=select 2=poll 3=usleep 4=yield 5=pthread_cond 6=nanosleep\n");
    return -1;
  }

  struct thread_info tinfo;
  int outer_iterations;
  int sleep_type;
  int s, inum, tnum, num_samples, num_threads;
  pthread_attr_t attr;
  pthread_t *threads;
  struct thread_res *res;
  struct thread_res **times;
  // Track the stats for each of the measurements
  struct thread_res_stats stats_clock = THREAD_RES_STATS_INITIALIZER;
  struct thread_res_stats stats_user = THREAD_RES_STATS_INITIALIZER;
  struct thread_res_stats stats_sys = THREAD_RES_STATS_INITIALIZER;
  // Calculate the conversion factor from clock_t to seconds
  const long clocks_per_sec = sysconf(_SC_CLK_TCK);
  const double clocks_to_usec = 1000000 / (double)clocks_per_sec;

  // Get the parameters
  tinfo.pid = getpid();
  tinfo.sleep_time = atoi(argv[1]);
  outer_iterations = atoi(argv[2]);
  tinfo.num_iterations = atoi(argv[3]);
  tinfo.work_size = atoi(argv[4]) * 1024;
  num_threads = atoi(argv[5]);
  sleep_type = atoi(argv[6]);
  switch (sleep_type) {
    case SLEEP_TYPE_NONE:   tinfo.func = &do_work_nosleep; break;
    case SLEEP_TYPE_SELECT: tinfo.func = &do_work_select;  break;
    case SLEEP_TYPE_POLL:   tinfo.func = &do_work_poll;    break;
    case SLEEP_TYPE_USLEEP: tinfo.func = &do_work_usleep;  break;
    case SLEEP_TYPE_YIELD:  tinfo.func = &do_work_yield;   break;
    case SLEEP_TYPE_PTHREAD_COND:  tinfo.func = &do_work_pthread_cond;   break;
    case SLEEP_TYPE_NANOSLEEP:  tinfo.func = &do_work_nanosleep;   break;
    default:
      printf("Invalid sleep type: %d\n", sleep_type);
      return -7;
  }

  // Initialize the thread creation attributes
  s = pthread_attr_init(&attr);
  if (s != 0) {
    printf("Error initializing thread attributes\n");
    return -2;
  }

  // Allocate the memory to track the threads
  threads = calloc(num_threads, sizeof(*threads));
  times = calloc(num_threads, sizeof(*times));
  if (threads == NULL) {
    printf("Error allocating memory to track threads\n");
    return -3;
  }

  // Initialize the number of samples
  num_samples = 0;
  // Perform the requested number of outer iterations
  for (inum=0; inum<outer_iterations; ++inum) {
    // Start all of the threads
    for (tnum=0; tnum<num_threads; ++tnum) {
      s = pthread_create(&threads[tnum], &attr, &do_test, &tinfo);

      if (s != 0) {
        printf("Error starting thread\n");
        return -4;
      }
    }

    // Wait for all the threads to finish
    for (tnum=0; tnum<num_threads; ++tnum) {
      s = pthread_join(threads[tnum], (void **)(&res));
      if (s != 0) {
        printf("Error waiting for thread\n");
        return -6;
      }

      // Save the result for processing when they're all done
      times[tnum] = res;
    }

    // For each of the threads
    for (tnum=0; tnum<num_threads; ++tnum) {
      // Increment the number of samples in the statistics
      ++num_samples;
      // Update the statistics with this measurement
      update_stats(&stats_clock, times[tnum]->clock, num_samples, tinfo.num_iterations, 1);
      update_stats(&stats_user, times[tnum]->user, num_samples, tinfo.num_iterations, clocks_to_usec);
      update_stats(&stats_sys, times[tnum]->sys, num_samples, tinfo.num_iterations, clocks_to_usec);
      // And clean it up
      free(times[tnum]);
    }
  }

  // Clean up the thread creation attributes
  s = pthread_attr_destroy(&attr);
  if (s != 0) {
    printf("Error cleaning up thread attributes\n");
    return -5;
  }

  // Finish the calculation of the standard deviation
  stats_clock.stddev = sqrtf(stats_clock.stddev / (num_samples - 1));
  stats_user.stddev = sqrtf(stats_user.stddev / (num_samples - 1));
  stats_sys.stddev = sqrtf(stats_sys.stddev / (num_samples - 1));

  // Print out the statistics of the times
  print_stats("gettimeofday_per_iteration", &stats_clock);
  print_stats("utime_per_iteration", &stats_user);
  print_stats("stime_per_iteration", &stats_sys);

  // Clean up the allocated threads and times
  free(threads);
  free(times);

  return 0;
}

Executei novamente os testes em um Dell Vostro 200 (CPU dual core) com várias versões diferentes do sistema operacional. Percebo que vários deles terão patches diferentes aplicados e não serão "código puro do kernel", mas essa foi a maneira mais simples de executar os testes em diferentes versões do kernel e obter comparações. Eu criei gráficos com o gnuplot e incluí a versão do bugzilla sobre esse problema .

Todos esses testes foram executados com o seguinte comando, com o seguinte script e este comando ./run_test 1000 10 1000 250 8 6 <os_name>.

#!/bin/bash

if [ $# -ne 7 ]; then
  echo "Usage: `basename $0` <sleep_time> <outer_iterations> <inner_iterations> <work_size> <max_num_threads> <max_sleep_type> <test_name>"
  echo "  max_num_threads: The highest value used for num_threads in the results"
  echo "  max_sleep_type: The highest value used for sleep_type in the results"
  echo "  test_name: The name of the directory where the results will be stored"
  exit -1
fi

sleep_time=$1
outer_iterations=$2
inner_iterations=$3
work_size=$4
max_num_threads=$5
max_sleep_type=$6
test_name=$7

# Make sure this results directory doesn't already exist
if [ -e $test_name ]; then
  echo "$test_name already exists";
  exit -1;
fi
# Create the directory to put the results in
mkdir $test_name
# Run through the requested number of SLEEP_TYPE values
for i in $(seq 0 $max_sleep_type)
do
  # Run through the requested number of threads
  for j in $(seq 1 $max_num_threads)
  do
    # Print which settings are about to be run
    echo "sleep_type: $i num_threads: $j"
    # Run the test and save it to the results file
    ./test_sleep $sleep_time $outer_iterations $inner_iterations $work_size $j $i >> "$test_name/results_$i.txt"
  done
done

Aqui está o resumo do que eu observei. Desta vez, vou compará-los em pares, porque acho que é um pouco mais informativo.

CentOS 5.6 vs CentOS 6.2

O tempo do relógio de parede (gettimeofday) por iteração no CentOS 5.6 é mais variado que 6.2, mas isso faz sentido, pois o CFS deve fazer um trabalho melhor ao fornecer aos processos o mesmo tempo de CPU, resultando em resultados mais consistentes. Também está bem claro que o CentOS 6.2 é mais preciso e consistente na quantidade de tempo que dorme com os diferentes mecanismos de suspensão. gettimeofday CentOS 5.6 gettimeofday CentOS 6.2

A "penalidade" é definitivamente aparente no 6.2 com um número baixo de threads (visível nos gráficos gettimeofday e time do usuário), mas parece ser reduzida com um número maior de threads (a diferença no tempo do usuário pode ser apenas uma questão de contabilidade, pois o as medições de tempo do usuário são tão claras).

utime CentOS 5.6 utime CentOS 6.2

O gráfico de hora do sistema mostra que os mecanismos de suspensão no 6.2 estão consumindo mais sistema do que no 5.6, o que corresponde aos resultados anteriores do teste simples de 50 processos que apenas chamam select consumindo uma quantidade não trivial de CPU no 6.2, mas não no 5.6 .

CentOS 5.6 CentOS 6.2

Algo que acredito que vale a pena notar é que o uso de sched_yield () não induz a mesma penalidade vista pelos métodos de suspensão. Minha conclusão é que não é o próprio agendador que é a fonte do problema, mas a interação dos métodos de suspensão com o agendador que é o problema.

Ubuntu 7.10 vs Ubuntu 8.04-4

A diferença na versão do kernel entre esses dois é menor que a do CentOS 5.6 e 6.2, mas eles ainda abrangem o período em que o CFS foi introduzido. O primeiro resultado interessante é que a seleção e a pesquisa parecem ser os únicos mecanismos de suspensão que têm a "penalidade" em 8.04 e essa penalidade continua com um número maior de threads do que o que foi visto no CentOS 6.2.

gettimeofday Ubuntu 7.10 gettimeofday Ubuntu 8.04-4

O tempo do usuário para selecionar e pesquisar e o Ubuntu 7.10 é irracionalmente baixo, então isso parece ser algum tipo de problema contábil que existia na época, mas acredito que não seja relevante para o problema / discussão atual.

utime Ubuntu 7.10 utime Ubuntu 8.04-4

O tempo do sistema parece ser maior no Ubuntu 8.04 do que no Ubuntu 7.10, mas essa diferença é MUITO menos distinta do que o observado no CentOS 5.6 vs 6.2.

stime Ubuntu 7.10 stime Ubuntu 8.04-4

Notas no Ubuntu 11.10 e Ubuntu 12.04

A primeira coisa a observar aqui é que os gráficos do Ubuntu 12.04 eram comparáveis ​​aos do 11.10, portanto, eles não mostram para evitar redundância desnecessária.

No geral, os gráficos para o Ubuntu 11.10 mostram o mesmo tipo de tendência observado no CentOS 6.2 (o que indica que esse é um problema de kernel em geral e não apenas um problema de RHEL). A única exceção é que o tempo do sistema parece ser um pouco maior no Ubuntu 11.10 do que no CentOS 6.2, mas mais uma vez, a resolução dessa medição é muito clara, então acho que qualquer conclusão diferente de "parece ser um pouco maior" "estaria pisando em gelo fino.

Ubuntu 11.10 vs Ubuntu 11.10 com BFS

Um PPA que usa BFS com o kernel do Ubuntu pode ser encontrado em https://launchpad.net/~chogydan/+archive/ppa e este foi instalado para gerar essa comparação. Não consegui encontrar uma maneira fácil de executar o CentOS 6.2 com BFS, então fiz essa comparação e, como os resultados do Ubuntu 11.10 se comparam tão bem ao CentOS 6.2, acredito que seja uma comparação justa e significativa.

gettimeofday Ubuntu 11.10 gettimeofday Ubuntu 11.10 com BFS

O ponto principal de observação é que, com o BFS, apenas select e nanosleep induzem a "penalidade" em baixos números de threads, mas isso parece induzir uma "penalidade" semelhante (se não maior) que a observada no CFS para um valor mais alto. número de processos.

utime Ubuntu 11.10 utime Ubuntu 11.10 com BFS

O outro ponto interessante é que o tempo do sistema parece ser menor com o BFS do que com o CFS. Mais uma vez, isso está começando a pisar no gelo fino por causa da grosseria dos dados, mas alguma diferença parece estar presente e esse resultado corresponde ao teste simples de loop de seleção de 50 processos que mostrou menos uso da CPU com BFS do que com CFS .

stime Ubuntu 11.10 stime Ubuntu 11.10 com BFS

A conclusão que tirei desses dois pontos é que o BFS não resolve o problema, mas pelo menos parece reduzir seus efeitos em algumas áreas.

Conclusão

Como afirmado anteriormente, não acredito que esse seja um problema com o próprio planejador, mas com a interação entre os mecanismos de suspensão e o planejador. Considero esse aumento no uso da CPU em processos que deveriam estar inativos e usando pouca ou nenhuma CPU, uma regressão do CentOS 5.6 e um grande obstáculo para qualquer programa que queira usar um mecanismo de loop de evento ou estilo de pesquisa.

Existem outros dados que posso obter ou testes que posso executar para ajudar a diagnosticar ainda mais o problema?

Atualização em 29 de junho de 2012

Eu simplifiquei um pouco o programa de testes e pode ser encontrado aqui (o post estava começando a exceder o limite de comprimento, então tivemos que movê-lo).

Dave Johansen
fonte
3
Uau, análise completa - mas com tantos dados, a pergunta original está ficando mais confusa para mim. Você pode resumir 1) um único teste 2) uma única distribuição 3) dois núcleos diferentes 4) a desaceleração de 15%? Se sua hipótese no último parágrafo estiver correta, é hora de começar a diferenciar as fontes do kernel, mas parece que as outras variáveis ​​devem ser eliminadas primeiro.
Ckhan
Adicionei algumas saídas do aplicativo de teste e agora faço a comparação em pares para tentar facilitar a digestão de todas as informações.
Dave Johansen
Tentei dar uma olhada no bugzilla, mas Redhat está dizendo que é "um bugzilla interno e não é visível ao público". Houve alguma atualização sobre isso?
Eu sou novo na coisa toda sobre bug do RedHat, então isso pode ter sido algo que eu fiz (ou não) ao criar o bug que fez isso, mas a única atualização que ouvi até agora é uma atualização para um parâmetro que faz com que ele se comporte melhor com processadores hiperencadeados, mas nenhuma correção real ainda.
Dave Johansen
2
CFS é o agendador completamente justo? Isso parece interessante - também encontrei um problema de desempenho com um aplicativo baseado em java no SLES11 SP2. A diferença (para o SP1) é a mudança na CFS ...
Nils

Respostas:

1

De acordo com as notas de versão do SLES 11 SP2, isso pode ser uma alteração introduzida na maneira como o CFS está sendo implementado.

Como o SLES 11 SP2 é a versão atual do SLES, esse comportamento ainda é válido (como parece para todos os kernels 3.x).

Essa mudança foi planejada - mas pode ter efeitos colaterais "ruins". Talvez uma das soluções alternativas descritas o ajude ...

Nils
fonte
Parece que há algo errado com o link e o correto está aqui , mas vou tentar essas soluções alternativas e ver se elas ajudam no desempenho.
Dave Johansen
Mais alguma notícia sobre isso?
vonbrand
@vonbrand Você provavelmente terá de pedir Dave ...
Nils