Я задав попереднє запитання, щоб спробувати виділити джерело збільшення використання процесора при переміщенні програми з RHEL 5 на RHEL 6. Аналіз, який я зробив для цього, схоже, вказує на те, що це викликане CFS в ядрі. Я написав тестову заявку, щоб спробувати перевірити, чи це було так (оригінальна тестова програма видалена, щоб відповідати обмеженню розміру, але все ще доступна в git repo .
Я склав її за допомогою наступної команди на RHEL 5:
cc test_select_work.c -O2 -DSLEEP_TYPE=0 -Wall -Wextra -lm -lpthread -o test_select_work
Потім я грав з параметрами, поки на Dell Precision m6500 час виконання за одну ітерацію не становив близько 1 мс.
Я отримав такий результат на 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
І наступне про 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
В обох версіях ці результати стосувались того, що я очікував із середньою кількістю часу за ітерацію порівняно лінійно. Потім я перекомпілював -DSLEEP_TYPE=1і отримав такі результати на 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
І наступні результати на 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
На RHEL 5 результати були приблизно те, що я очікував (4 нитки займали вдвічі довше через 1 мс сну, але 8 ниток забирали стільки ж часу, оскільки кожна нитка зараз спить близько половини часу, і все ще досить лінійне збільшення).
Однак із RHEL 6 час, взятий за допомогою 4-х потоків, збільшився приблизно на 15% більше, ніж очікувалося подвоєння, а 8-річний випадок збільшився приблизно на 45% більше, ніж очікувалося незначне збільшення. Зростання випадків 4-х потоків здається таким, що RHEL 6 насправді спить на жменю мікросекунд більше 1 мс, тоді як RHEL 5 спить лише близько 900 нас, але це не пояснює несподівано велике збільшення 8 і 40 ниткові корпуси.
Я бачив подібні типи поведінки з усіма значеннями 3 -DSLEEP_TYPE. Я також спробував грати з параметрами планувальника в sysctl, але нічого, здавалося, не мало суттєвого впливу на результати. Будь-які ідеї, як я можу далі діагностувати це питання?
ОНОВЛЕННЯ: 2012-05-07
Я додав вимірювання використання користувачем та системним процесором з / proc / stat // task // stat як результат тесту, щоб спробувати отримати ще одну точку спостереження. Я також знайшов проблему з тим, як оновлювалося середнє та стандартне відхилення, яке було введено, коли я додав зовнішню цикл ітерації, тому я додаю нові графіки, які мають виправлене середнє та стандартне відхилення. Я включив оновлену програму. Я також зробив git repo для відстеження коду, і він доступний тут.
#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 <jens.axboe@oracle.com>)
#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;
}
Я повторно провів тести на Dell Vostro 200 (двоядерний процесор) з кількома різними версіями ОС. Я розумію, що для декількох із них будуть застосовані різні виправлення, і це не буде "чистим кодом ядра", але це був найпростіший спосіб, що я міг запускати тести на різних версіях ядра та отримувати порівняння. Я генерував сюжети за допомогою gnuplot і включив версію bugzilla про цю проблему .
Усі ці тести виконувались із наступною командою із наступним сценарієм та цією командою ./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
Ось підсумок того, що я спостерігав. Цього разу я порівняю їх у парах, бо вважаю, що це трохи більш інформативно.
CentOS 5.6 проти CentOS 6.2
Час настінного годинника (gettimeofday) за ітерацію на CentOS 5.6 відрізняється більше ніж 6,2, але це має сенс, оскільки CFS повинен робити кращу роботу, надаючи процесам рівний час процесора, що призводить до більш послідовних результатів. Цілком очевидно також, що CentOS 6.2 є більш точним і послідовним за час, який він спить, за допомогою різних механізмів сну.
"Штраф", безумовно, очевидний у 6.2 із малою кількістю потоків (видно на графіках часу та дня користувача), але він, здається, зменшується з більшою кількістю потоків (різниця у часі користувача може бути просто бухгалтерською справою, оскільки вимірювання часу користувача - це звичайно).
Системний часовий графік показує, що механізми сну в 6.2 споживають більше системи, ніж у 5.6, що відповідає попереднім результатам простого тесту 50 процесів, що вимагає вибору, що споживає нетривіальну кількість процесора на 6,2, але не 5,6 .
Що, на мою думку, заслуговує на увагу, це те, що використання sched_yield () не спричиняє такого ж покарання, як бачать методи сну. Мій висновок з цього полягає в тому, що джерелом проблеми є не сам планувальник, а взаємодія методів сну з планувальником.
Ubuntu 7.10 проти Ubuntu 8.04-4
Різниця у версії ядра між цими двома менша, ніж у CentOS 5.6 та 6.2, але вони все ще охоплюють часовий період, коли було введено CFS. Перший цікавий результат полягає в тому, що вибір і опитування, здається, є єдиними механізмами сну, які мають "покарання" 8.04, і цей показник продовжує перевищувати кількість потоків, ніж те, що було помічено у CentOS 6.2.
Час користувача для вибору та опитування та Ubuntu 7.10 невиправдано низький, тому, здається, це була якась проблема бухгалтерського обліку, яка існувала тоді, але я вважаю, що це не стосується поточного питання / обговорення.
Час роботи системи на Ubuntu 8.04 здається вищим, ніж у Ubuntu 7.10, але ця різниця є FAR менш чіткою, ніж те, що спостерігалося з CentOS 5.6 проти 6.2.
Примітки щодо Ubuntu 11.10 та Ubuntu 12.04
Перше, що тут слід зазначити, це те, що сюжети для Ubuntu 12.04 були порівнянні з тими з 11.10, тому вони не показали, щоб запобігти зайвій надмірності.
Загалом, графіки для Ubuntu 11.10 демонструють таку саму тенденцію, що спостерігалася у CentOS 6.2 (що вказує на те, що це проблема ядра в цілому, а не лише проблема RHEL). Єдиним винятком є те, що системний час здається трохи більшим для Ubuntu 11.10, ніж для CentOS 6.2, але ще раз, дозвіл на це вимірювання дуже звичайно, тому я думаю, що будь-який висновок, окрім ", здається, трохи більший "буде наступати на тонкий лід.
Ubuntu 11.10 проти Ubuntu 11.10 з BFS
PPA, який використовує BFS з ядром Ubuntu, можна знайти на веб- сайті https://launchpad.net/~chogydan/+archive/ppa, і цей файл було встановлено для створення цього порівняння. Я не міг знайти простий спосіб запустити CentOS 6.2 з BFS, тому я зіткнувся з цим порівнянням, і оскільки результати Ubuntu 11.10 так добре порівнюються з CentOS 6.2, я вважаю, що це справедливе і змістовне порівняння.
Основний момент зауваження полягає в тому, що при BFS лише вибір і наноспі викликають "штраф" при малій кількості потоків, але це, здається, індукує подібний "штраф" (якщо не більший), як той, що спостерігається з CFS для вищого кількість ниток.
Іншим цікавим моментом є те, що системний час здається меншим для BFS, ніж для CFS. Знову ж таки, це починає наступати на тонкий лід через грубість даних, але деяка різниця, мабуть, присутня, і цей результат співпадає з простим тестом циклу вибору 50 процесів, показав менше використання CPU з BFS, ніж з CFS .
Висновок, який я роблю з цих двох моментів, полягає в тому, що BFS не вирішує проблему, але, принаймні, зменшує її вплив у деяких сферах.
Висновок
Як було сказано раніше, я не вірю, що це проблема з самим планувальником, а з взаємодією між сплячими механізмами та планувальником. Я вважаю, що це збільшує використання процесора в процесах, які повинні бути сплячими і використовувати малоефективний процесор, регресія від CentOS 5.6 та головне перешкода для будь-якої програми, яка хоче використовувати цикл подій або механізм опитування.
Чи є інші дані, які я можу отримати, або тести, які я можу запустити для подальшого діагностування проблеми?
Оновлення 29 червня 2012 року
Я трохи спростив програму тестування, і її можна знайти тут (Публікація починала перевищувати межу довжини, тому довелося її перемістити).