Saya mengajukan pertanyaan sebelumnya untuk mencoba dan mengisolasi sumber peningkatan penggunaan CPU ketika memindahkan aplikasi dari RHEL 5 ke RHEL 6. Analisis yang saya lakukan untuk itu tampaknya menunjukkan bahwa itu disebabkan oleh CFS di kernel. Saya menulis aplikasi uji untuk mencoba dan memverifikasi apakah ini yang terjadi (aplikasi uji asli dihapus agar sesuai dengan batas ukuran, tetapi masih tersedia di git repo .
Saya mengkompilasinya dengan perintah berikut di RHEL 5:
cc test_select_work.c -O2 -DSLEEP_TYPE=0 -Wall -Wextra -lm -lpthread -o test_select_work
Saya kemudian bermain dengan parameter sampai waktu eksekusi per iterasi adalah sekitar 1 ms pada Dell Precision m6500.
Saya mendapat hasil berikut di 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
Dan yang berikut di 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
Pada kedua versi, hasil ini adalah tentang apa yang saya harapkan dengan jumlah rata-rata waktu per iterasi yang relatif linier. Saya kemudian dikompilasi ulang dengan -DSLEEP_TYPE=1dan mendapatkan hasil berikut di 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
Dan hasil berikut di 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
Pada RHEL 5, hasilnya adalah tentang apa yang saya harapkan (4 utas memakan waktu dua kali lebih lama karena 1 ms tidur tetapi 8 utas mengambil jumlah waktu yang sama karena setiap utas sekarang tidur sekitar setengah dari waktu, dan masih cukup peningkatan linear).
Namun, dengan RHEL 6, waktu yang diambil dengan 4 utas meningkat sekitar 15% lebih dari dua kali lipat yang diharapkan dan selubung 8 utas meningkat sekitar 45% lebih dari sedikit peningkatan yang diharapkan. Peningkatan pada kasus 4 ulir tampaknya bahwa RHEL 6 sebenarnya tidur untuk beberapa mikrodetik lebih dari 1 ms sementara RHEL 5 hanya tidur sekitar 900 kita, tetapi ini tidak menjelaskan peningkatan besar yang tak terduga di 8 dan 40 kasing kasus.
Saya melihat tipe perilaku yang serupa dengan semua nilai 3 -DSLEEP_TYPE. Saya juga mencoba bermain dengan parameter scheduler di sysctl, tetapi sepertinya tidak ada yang berdampak signifikan pada hasil. Adakah gagasan tentang bagaimana saya dapat mendiagnosis masalah ini lebih lanjut?
UPDATE: 2012-05-07
Saya menambahkan pengukuran pengguna dan penggunaan sistem CPU dari / proc / stat // tugas // stat sebagai output dari tes untuk mencoba dan mendapatkan titik pengamatan lain. Saya juga menemukan masalah dengan cara rata-rata dan standar deviasi sedang diperbarui yang diperkenalkan ketika saya menambahkan loop iterasi luar, jadi saya akan menambahkan plot baru yang memiliki rata-rata dikoreksi dan pengukuran standar deviasi. Saya telah memasukkan program yang diperbarui. Saya juga membuat repo git untuk melacak kode dan tersedia di sini.
#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;
}
Saya menjalankan kembali tes pada Dell Vostro 200 (CPU dual core) dengan beberapa versi OS yang berbeda. Saya menyadari bahwa beberapa di antaranya akan memiliki tambalan berbeda yang diterapkan dan tidak akan menjadi "kode kernel murni", tetapi ini adalah cara paling sederhana yang saya bisa jalankan tes pada versi berbeda dari kernel dan mendapatkan perbandingan. Saya membuat plot dengan gnuplot dan telah menyertakan versi dari bugzilla tentang masalah ini .
Semua tes ini dijalankan dengan perintah berikut dengan skrip berikut dan perintah ini ./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
Inilah ringkasan dari apa yang saya amati. Saya akan membandingkan mereka berpasangan kali ini karena saya pikir itu sedikit lebih informatif seperti itu.
CentOS 5.6 vs CentOS 6.2
Waktu jam dinding (gettimeofday) per iterasi pada CentOS 5.6 lebih bervariasi dari 6.2, tetapi ini masuk akal karena CFS harus melakukan pekerjaan yang lebih baik dalam memberikan proses waktu CPU yang sama menghasilkan hasil yang lebih konsisten. Juga cukup jelas bahwa CentOS 6.2 lebih akurat dan konsisten dalam jumlah waktu tidurnya dengan mekanisme tidur yang berbeda.
"Penalti" jelas terlihat pada 6.2 dengan jumlah utas yang rendah (terlihat pada gettimeofday dan plot waktu pengguna) tetapi tampaknya dikurangi dengan jumlah utas yang lebih tinggi (perbedaan dalam waktu pengguna mungkin hanya merupakan faktor akuntansi karena pengukuran waktu pengguna jadi tentu saja).
Plot waktu sistem menunjukkan bahwa mekanisme tidur di 6.2 mengkonsumsi lebih banyak sistem daripada yang mereka lakukan di 5.6, yang sesuai dengan hasil sebelumnya dari tes sederhana dari 50 proses hanya memanggil pilih mengkonsumsi jumlah non-sepele CPU pada 6.2 tetapi tidak 5.6 .
Sesuatu yang saya percaya yang patut dicatat adalah bahwa penggunaan sched_yield () tidak menyebabkan hukuman yang sama seperti yang terlihat pada metode sleep. Kesimpulan saya dari ini adalah bahwa bukan scheduler itu sendiri yang merupakan sumber masalah, tetapi interaksi metode tidur dengan scheduler yang menjadi masalah.
Ubuntu 7.10 vs Ubuntu 8.04-4
Perbedaan dalam versi kernel antara keduanya lebih kecil dari CentOS 5.6 dan 6.2, tetapi mereka masih rentang periode waktu ketika CFS diperkenalkan. Hasil menarik pertama adalah bahwa pemilihan dan pemilihan tampaknya menjadi satu-satunya mekanisme tidur yang memiliki "penalti" pada 8,04 dan hukuman itu berlanjut ke jumlah utas yang lebih tinggi daripada yang terlihat dengan CentOS 6.2.
Waktu pengguna untuk pemilihan dan jajak pendapat dan Ubuntu 7.10 sangat rendah, jadi ini tampaknya menjadi semacam masalah akuntansi yang ada saat itu, tapi saya percaya tidak relevan dengan masalah / diskusi saat ini.
Waktu sistem tampaknya lebih tinggi dengan Ubuntu 8.04 daripada dengan Ubuntu 7.10 tetapi perbedaan ini JAUH berbeda dari apa yang terlihat dengan CentOS 5.6 vs 6.2.
Catatan tentang Ubuntu 11.10 dan Ubuntu 12.04
Hal pertama yang perlu diperhatikan di sini adalah bahwa plot untuk Ubuntu 12,04 sebanding dengan yang dari 11,10 sehingga tidak menunjukkan untuk mencegah redundansi yang tidak perlu.
Secara keseluruhan plot untuk Ubuntu 11.10 menunjukkan jenis tren yang sama yang diamati dengan CentOS 6.2 (yang menunjukkan bahwa ini adalah masalah kernel secara umum dan bukan hanya masalah RHEL). Satu-satunya pengecualian adalah bahwa waktu sistem tampaknya sedikit lebih tinggi dengan Ubuntu 11.10 daripada dengan CentOS 6.2, tetapi sekali lagi, resolusi pada pengukuran ini sangat baik, jadi saya pikir kesimpulan apa pun selain "tampaknya sedikit lebih tinggi". "Akan melangkah ke es tipis.
Ubuntu 11.10 vs Ubuntu 11.10 dengan BFS
PPA yang menggunakan BFS dengan kernel Ubuntu dapat ditemukan di https://launchpad.net/~chogydan/+archive/ppa dan ini dipasang untuk menghasilkan perbandingan ini. Saya tidak dapat menemukan cara mudah untuk menjalankan CentOS 6.2 dengan BFS jadi saya berlari dengan perbandingan ini dan karena hasil Ubuntu 11.10 membandingkan dengan sangat baik dengan CentOS 6.2, saya percaya bahwa ini adalah perbandingan yang adil dan bermakna.
Poin utama dari catatan adalah bahwa dengan BFS hanya memilih dan nanosleep menginduksi "penalti" pada jumlah thread yang rendah, tetapi tampaknya mendorong "penalti" yang sama (jika bukan yang lebih besar) seperti yang terlihat dengan CFS untuk yang lebih tinggi jumlah utas.
Poin menarik lainnya adalah bahwa waktu sistem tampaknya lebih rendah dengan BFS daripada dengan CFS. Sekali lagi, ini mulai menginjak es tipis karena kekasaran data, tetapi beberapa perbedaan tampaknya ada dan hasil ini tidak sesuai dengan tes 50 proses pilih loop sederhana memang menunjukkan lebih sedikit penggunaan CPU dengan BFS dibandingkan dengan CFS .
Kesimpulan yang saya ambil dari dua poin ini adalah bahwa BFS tidak menyelesaikan masalah tetapi setidaknya mengurangi pengaruhnya di beberapa area.
Kesimpulan
Seperti yang dinyatakan sebelumnya, saya tidak percaya bahwa ini adalah masalah dengan penjadwal itu sendiri, tetapi dengan interaksi antara mekanisme tidur dan penjadwal. Saya menganggap ini peningkatan penggunaan CPU dalam proses yang harus tidur dan menggunakan sedikit atau tidak ada CPU regresi dari CentOS 5.6 dan rintangan utama untuk setiap program yang ingin menggunakan loop acara atau gaya mekanisme polling.
Apakah ada data lain yang bisa saya dapatkan atau tes yang dapat saya jalankan untuk membantu mendiagnosis masalah lebih lanjut?
Pembaruan pada 29 Juni 2012
Saya menyederhanakan program pengujian sedikit dan dapat ditemukan di sini (Posting sudah mulai melebihi batas panjang jadi harus pindah).