Menggunakan Linux cgroups untuk menyeimbangkan kinerja CPU

Saya memiliki dua sistem Linux dual-core yang diinstal menggunakan cgroup Linux dengan kernel yang relatif baru; satu menjalankan Debian Squeeze, yang lain Ubuntu 11,04 Natty Narwhal. Saya mendapatkan penyeimbangan beban CPU dengan cgroup yang bekerja sedikit lebih baik pada sistem Debian meskipun kernelnya lebih tua. Tapi itu tidak tepat untuk semuanya, dan keanehan spesifik yang saya tanyakan di sini terjadi pada kedua sistem.

Jika Anda membaca Manajemen Sumber Daya di Linux dengan Grup Kontrol, ini memberikan contoh yang menunjukkan cara mereproduksi masalah. Ini versi Ubuntu (jalankan ini sebagai root):

cd /sys/fs/cgroup/cpu
    [On Debian Squeeze start at /mnt/cgroups/cpu instead]
mkdir low high
echo 512 > low/cpu.shares
echo 2048 > high/cpu.shares
yes low > /dev/null &
echo $! > low/tasks
yes high > /dev/null &
echo $! > high/tasks
ps -C yes -opid,%cpu,psr,args
    [repeat that a few times]
killall -9 yes

Saya mengharapkan proses "tinggi" dialokasikan lebih banyak daripada proses "rendah"; apa yang sebenarnya terjadi dengan test case ini selalu lebih seperti ini:

root@black:/sys/fs/cgroup/cpu# ps -C yes -opid,%cpu,psr,args
  PID %CPU PSR COMMAND
 3105 88.3   1 yes low
 3106 94.5   0 yes high

Di mana waktunya hampir sama. Inilah pertanyaan saya: mengapa itu terjadi?

Dalam presentasi, masalah ini ditunjukkan hilang dengan menyematkan setiap proses ke CPU yang sama; baris tambahan untuk menguji itu:

taskset -c 1 yes high > /dev/null &
echo $! > high/tasks
taskset -c 1 yes low > /dev/null &
echo $! > low/tasks
ps -C yes -opid,%cpu,psr,args
[later, rinse, repeat]
killall -9 yes

Hasilnya kemudian adalah apa yang saya harapkan untuk dilihat sepanjang waktu: proses "tinggi" mendapatkan persentase CPU yang jauh lebih tinggi:

root@black:/sys/fs/cgroup/cpu# ps -C yes -opid,%cpu,psr,args
  PID %CPU PSR COMMAND
 3128 83.3   1 yes high
 3129 20.7   1 yes low

Menjelaskan mengapa ini berhasil akan menjadi langkah yang bermanfaat untuk mencari tahu mengapa yang sebelumnya tidak juga.

Saya mendapat penjelasan awal tentang test case ini dari Stefan Seyfried, yang menulis makalah dari contoh ini. Masalahnya di sini adalah bahwa bagian-bagian penjadwal CPU dari cgroup selalu bertujuan untuk membuat CPU yang ada sibuk; itu tidak pernah menegakkan batas keras jika semuanya akan cocok sekaligus.

Dalam kasus di mana dua proses (tinggi dan rendah di sini) berjalan pada> = 2 core, itu hanya akan tetap tinggi pada satu inti dan rendah pada yang lain. Keduanya kemudian akan berjalan sepanjang waktu, mendekati penggunaan 100%, karena mereka dapat melakukannya tanpa mengenai situasi di mana scheduler tidak memberi mereka cukup waktu pada CPU. Penjadwalan cpu.share hanya terjadi jika ada kekurangan.

Dalam kasus kedua, kedua proses disematkan ke CPU yang sama. Kemudian logika berbagi CPU harus melakukan sesuatu yang berguna dengan nomor cpu.shares relatif untuk menyeimbangkannya, dan melakukan itu seperti yang diharapkan.

Batas keras pada penggunaan CPU tidak akan muncul sampai setelah patch Kontrol Bandwidth CFS mencapai. Pada titik itu dimungkinkan untuk mendapatkan sesuatu yang lebih seperti apa yang saya harapkan.