Difference between revisions of "OS: Complete Teori Tuning Kernel Scheduler"

From OnnoWiki
Jump to navigation Jump to search
 
(44 intermediate revisions by the same user not shown)
Line 56: Line 56:
 
Scheduler menghitung timeslices secara dinamis. Namun, untuk menentukan proses timeslice yang tepat adalah tugas yang kompleks: timeslices Terlalu lama menyebabkan sistem menjadi kurang interaktif dan responsif, sementara yang terlalu pendek membuat prosesor membuang banyak waktu di overhead switching proses yang terlalu sering. proses timeslice standar biasanya agak rendah, misalnya 20ms . scheduler menentukan proses timeslice berdasarkan prioritas dari proses, yang memungkinkan proses dengan prioritas yang lebih tinggi untuk menjalankan lebih sering dan untuk waktu yang lama.
 
Scheduler menghitung timeslices secara dinamis. Namun, untuk menentukan proses timeslice yang tepat adalah tugas yang kompleks: timeslices Terlalu lama menyebabkan sistem menjadi kurang interaktif dan responsif, sementara yang terlalu pendek membuat prosesor membuang banyak waktu di overhead switching proses yang terlalu sering. proses timeslice standar biasanya agak rendah, misalnya 20ms . scheduler menentukan proses timeslice berdasarkan prioritas dari proses, yang memungkinkan proses dengan prioritas yang lebih tinggi untuk menjalankan lebih sering dan untuk waktu yang lama.
  
−
A process does not have to utilize all its timeslice at once. For instance, a process with a timeslice of 150ms does not have to be running for 150ms in one go. It can be running in five different schedule slots for 30ms instead. Interactive tasks typically benefit from this approach because they do not need such a large timeslice at once while they need to be responsive as long as possible.
+
Sebuah proses tidak harus memanfaatkan semua proses timeslice sekaligus. Misalnya, dengan proses timeslice dari 150ms tidak harus berjalan selama 150ms dalam satu kali. Hal ini dapat berjalan di lima slot jadwal yang berbeda untuk 30ms . task interaktif biasanya memperoleh manfaat dari pendekatan ini karena mereka tidak perlu seperti proses timeslice besar sekaligus saat mereka harus responsif selama mungkin.
  
−
The scheduler also assigns process priorities dynamically. It monitors the processes' behavior and, if needed, adjusts its priority. For example, a process which is being suspended for a long time is brought up by increasing its priority.
+
Scheduler juga menetapkan prioritas proses secara dinamis. Scheduler memonitor perilaku proses dan, jika diperlukan, menyesuaikan prioritas. Sebagai contoh, proses yang diskors untuk waktu yang lama dinyalakan dengan meningkatkan prioritas.
  
−
==Completely Fair Scheduler==
+
==Completely Fair Scheduler (CFQ)==
  
−
Since the Linux kernel version 2.6.23, a new approach has been taken to the scheduling of runnable processes. Completely Fair Scheduler (CFS) became the default Linux kernel scheduler. Since then, important changes and improvements have been made. The information in this chapter applies to openSUSE with kernel version 2.6.32 and higher (including 3.x kernels). The scheduler environment was divided into several parts, and three main new features were introduced:
+
Sejak kernel Linux 2.6.23, pendekatan baru telah dibawa ke proses task scheduling . Completely Fair Scheduler (CFS) menjadi default Linux kernel scheduler. Sejak itu, perubahan-perubahan penting dan perbaikan telah dibuat. Informasi dalam bagian berlaku untuk Linux dengan versi kernel 2.6.32 dan yang lebih tinggi (termasuk kernel 3.x). Lingkungan scheduler dibagi menjadi beberapa bagian, dan tiga fitur utama baru yang diperkenalkan:
  
−
Modular Scheduler Core
+
===Modular Scheduler Core===
 +
Inti dari scheduler ditingkatkan dengan kelas task scheduling. Kelas-kelas yang modular dan merepresentasikan kebijakan task scheduling.
  
−
    The core of the scheduler was enhanced with scheduling classes. These classes are modular and represent scheduling policies.
+
===Completely Fair Scheduler===
−
Completely Fair Scheduler
+
Diperkenalkan pada kernel 2.6.23 dan diperpanjang di 2.6.24, CFS mencoba untuk memastikan bahwa setiap proses memperoleh bagian yang "fair" dari waktu prosesor.
  
−
    Introduced in kernel 2.6.23 and extended in 2.6.24, CFS tries to assure that each process obtains its “fair” share of the processor time.  
+
===Group Scheduling===
 +
Misalnya, jika kita membagi proses menjadi kelompok-kelompok yang berdasarkan group tersebut pengguna menjalankan proses tersebut, CFS mencoba untuk memberikan masing-masing kelompok dengan jumlah waktu prosesor yang sama.
  
−
Group Scheduling
+
Akibatnya, CFS membawa task scheduling lebih dioptimalkan untuk server dan desktop.
  
−
    For example, if you split processes into groups according to which user is running them, CFS tries to provide each of these groups with the same amount of processor time.
+
===Bagaimana CFS Bekerja===
  
−
As a result, CFS brings more optimized scheduling for both servers and desktops.
+
CFS mencoba untuk menjamin pendekatan yang adil untuk setiap task . Untuk menemukan cara yang paling seimbang penjadwalan tugas, menggunakan konsep pohon merah-hitam . Sebuah pohon merah-hitam adalah jenis self-balancing pohon pencarian data yang menyediakan memasukkan dan menghapus entri dalam cara yang wajar sehingga tetap seimbang. Untuk informasi lebih lanjut, lihat halaman wiki Pohon Merah-hitam http://en.wikipedia.org/wiki/Red_black_tree.
  
−
===How CFS Works===
+
Ketika task masuk ke dalam antrian run (timeline rencana proses yang akan dieksekusi berikutnya), scheduler mencatat waktu saat tersebut. Saat proses menunggu waktu prosesor, Nilai "wait / tunggu" akan bertambah dengan jumlah yang berasal dari banyaknya task saat ini dalam antrian run dan prioritas proses. Segera setelah prosesor menjalankan tugas, Nilai "wait / tunggu" akan dikurangi. Jika nilai turun di bawah tingkat tertentu, tugas yang ditunda eksekusinya oleh scheduler dan tugas-tugas lain akan menjadi lebih dekat untuk dieksekusi oleh prosesor. Dengan algoritma ini, CFS mencoba untuk mencapai kondisi ideal di mana nilai "wait / tunggu" selalu nol.
  
−
CFS tries to guarantee a fair approach to each runnable task. To find the most balanced way of task scheduling, it uses the concept of red-black tree. A red-black tree is a type of self-balancing data search tree which provides inserting and removing entries in a reasonable way so that it remains well balanced. For more information, see the wiki pages of Red-black tree.
+
===Grouping Proses===
  
−
When a task enters into the run queue (a planned time line of processes to be executed next), the scheduler records the current time. While the process waits for processor time, its “wait” value gets incremented by an amount derived from the total number of tasks currently in the run queue and the process priority. As soon as the processor runs the task, its “wait” value gets decremented. If the value drops below a certain level, the task is preempted by the scheduler and other tasks get closer to the processor. By this algorithm, CFS tries to reach the ideal state where the “wait” value is always zero.
+
Sejak kernel Linux 2.6.24, CFS dapat disetel untuk bersikap adil kepada pengguna atau group dan bukan hanya task saja. task runnable kemudian dikelompokkan untuk membentuk entitas, dan CFS mencoba untuk bersikap adil terhadap entitas bukan task individu. scheduler juga mencoba untuk bersikap adil terhadap task individu dalam entitas.
−
14.4.2. Grouping Processes¶
 
  
−
Since the Linux kernel version 2.6.24, CFS can be tuned to be fair to users or groups rather than to tasks only. Runnable tasks are then grouped to form entities, and CFS tries to be fair to these entities instead of individual runnable tasks. The scheduler also tries to be fair to individual tasks within these entities.
+
Task dapat dikelompokkan dalam dua kategori yang saling eksklusif:
  
−
Tasks can be grouped in two mutually exclusive ways:
+
* Berdasarkan user ID
 +
* Berdasarkan kernel control group.
  
−
    By user IDs
+
Kernel scheduler kernel memungkinkan kita mengelompokan task tergantung pada pengaturan pilihan kernel compile-time yaitu CONFIG_FAIR_USER_SCHED dan CONFIG_FAIR_CGROUP_SCHED. Pengaturan default biasanya menggunakan group kontrol, yang memungkinkan kita membuat grup sesuai kebutuhan.
  
−
    By kernel control groups.
+
===Pilihan Konfigurasi Kernel===
  
−
The way the kernel scheduler lets you group the runnable tasks depends on setting the kernel compile-time options CONFIG_FAIR_USER_SCHED and CONFIG_FAIR_CGROUP_SCHED. The default setting in openSUSE® 12.3 is to use control groups, which lets you create groups as needed. For more information, see Chapter 10, Kernel Control Groups.
+
Basic aspects of the task scheduler behavior can be set through the kernel configuration options. Setting these options is part of the kernel compilation process. Because kernel compilation process is a complex task and out of this document's scope, refer to relevant source of information (for example http://en.opensuse.org/Configure,_Build_and_Install_a_Custom_Linux_Kernel).
−
14.4.3. Kernel Configuration Options¶
+
 
 +
==Berbagai Istilah==
 +
 
 +
Dokumen tentang task scheduling policy kadang kala menggunakan beberapa istilah teknik yang perlu kita ketahui dengan benar. Berikut adalaha beberapa diantara istilah tersebut:
 +
 
 +
===Latency===
 +
Delay antara waktu sebuah proses di jadwalkan untuk di run vs. waktu eksekusi proses yang sebenarnya.
 +
 
 +
===Granularity===
 +
Hubungan antara granularity dengan latency dapat di tulis dengan persamaan berikut:
 +
 
 +
gran = ( lat / rtasks ) - ( lat / rtasks / rtasks )
 +
 
 +
dimana
 +
* gran adalah granularity
 +
* lat adalah latency
 +
* rtasks adalah jumlah task  yang running / berjalan
  
−
Basic aspects of the task scheduler behavior can be set through the kernel configuration options. Setting these options is part of the kernel compilation process. Because kernel compilation process is a complex task and out of this document's scope, refer to relevant source of information (for example http://en.opensuse.org/Configure,_Build_and_Install_a_Custom_Linux_Kernel).
+
===Scheduling Policies===
−
[Warning] Kernel Compilation
 
  
−
If you run openSUSE on a kernel that was not shipped with it, for example on a self-compiled kernel, you loose the entire support entitlement.
+
Kernel Linux mendukung kebijakan scheduling berikut:
  
−
===Terminology===
+
* SCHED_FIFO - kebijakan scheduling yang di rancang untuk aplikasi yang time-critical. Kebijakan ini menggunakan algoritma scheduling First In-First Out.
  
−
Documents regarding task scheduling policy often use several technical terms which you need to know to understand the information correctly. Here are some of them:
+
* SCHED_BATCH - kebijakan scheduling di rancang untuk task yang CPU-intensive.
  
−
Latency
+
* SCHED_IDLE - kebijakan scheduling yang di rancang untuk task yang prioritasnya sangat rendah.
  
−
    Delay between the time a process is scheduled to run and the actual process execution.  
+
* SCHED_OTHER - kebijakan default Linux time-sharing scheduling yang digunakan oleh sebagian besar proses.
−
Granularity
 
  
−
    The relation between granularity and latency can be expressed by the following equation:
+
* SCHED_RR - mirip dengan SCHED_FIFO, tapi menggunakan algoritma Round Robin scheduling.
  
−
    gran = ( lat / rtasks ) - ( lat / rtasks / rtasks )
+
==Mengubah Atribut Real-time dari proses dengan chrt==
  
−
    where gran stands for granularity, lat stand for latency, and rtasks is the number of running tasks.  
+
Perintah chrt digunakan untuk set atau melihat atribute real-time scheduling dari sebuah proses yang sedang running, atau menjalankan sebuah perintah dengan atribut tertentu. Kita dapat mengambil baik kebijakan scheduling maupun prioritas proses.
  
−
14.4.4.1. Scheduling Policies¶
+
Pada contoh berikut, sebuah proses dengan PID 11652 akan dijadikan contoh.
  
−
The Linux kernel supports the following scheduling policies:
+
Untuk melihat atribut real-time dari task yang ada:
  
−
SCHED_FIFO
+
chrt -p 11652
  
−
    Scheduling policy designed for special time-critical applications. It uses the First In-First Out scheduling algorithm.
+
Contoh keluaran:
−
SCHED_BATCH
 
  
−
    Scheduling policy designed for CPU-intensive tasks.
+
pid 11652's current scheduling policy: SCHED_OTHER
−
SCHED_IDLE
+
pid 11652's current scheduling priority: 0
  
−
    Scheduling policy intended for very low prioritized tasks.
+
Sebelum menset ke kebijakan scheduling yang baru pada sebuah proses, kita perlu melihat prioritas minimum dan maximum yang valid untuk setiap algoritma scheduling melalui perintah:
−
SCHED_OTHER
 
  
−
    Default Linux time-sharing scheduling policy used by the majority of processes.
+
chrt -m
−
SCHED_RR
 
  
−
    Similar to SCHED_FIFO, but uses the Round Robin scheduling algorithm.
+
Contoh keluaran:
  
−
14.4.5. Changing Real-time Attributes of Processes with chrt¶
+
SCHED_OTHER min/max priority : 0/0
 +
SCHED_FIFO min/max priority : 1/99
 +
SCHED_RR min/max priority : 1/99
 +
SCHED_BATCH min/max priority : 0/0
 +
SCHED_IDLE min/max priority : 0/0
  
−
The chrt command sets or retrieves the real-time scheduling attributes of a running process, or runs a command with the specified attributes. You can get or retrieve both the scheduling policy and priority of a process.
+
Pada contoh di atas, kebijakan SCHED_OTHER, SCHED_BATCH, SCHED_IDLE hanya mengijinkan prioritas 0, sementara SCHED_FIFO dan SCHED_RR dapat di set antara 1 sampai dengan 99.
  
−
In the following examples, a process whose PID is 16244 is used.
+
Untuk menset agar menjadi SCHED_BATCH scheduling:
  
−
To retrieve the real-time attributes of an existing task:
+
chrt -b -p 0 11652
 +
chrt -p 11652
  
−
saturn.example.com:~ # chrt -p 16244
+
Contoh keluaran:
−
pid 16244's current scheduling policy: SCHED_OTHER
 
−
pid 16244's current scheduling priority: 0
 
  
−
Before setting a new scheduling policy on the process, you need to find out the minimum and maximum valid priorities for each scheduling algorithm:
+
pid 11652's current scheduling policy: SCHED_BATCH
 +
pid 11652's current scheduling priority: 0
  
−
saturn.example.com:~ # chrt -m
+
Untuk info lebih lanjut tentang chrt, kita dapat menulis
−
SCHED_OTHER min/max priority : 0/0
 
−
SCHED_FIFO min/max priority : 1/99
 
−
SCHED_RR min/max priority : 1/99
 
−
SCHED_BATCH min/max priority : 0/0
 
−
SCHED_IDLE min/max priority : 0/0
 
  
−
In the above example, SCHED_OTHER, SCHED_BATCH, SCHED_IDLE polices only allow for priority 0, while that of SCHED_FIFO and SCHED_RR can range from 1 to 99.
+
chrt -h
  
−
To set SCHED_BATCH scheduling policy:
+
Contoh keluaran:
  
−
  saturn.example.com:~ # chrt -b -p 0 16244
+
  chrt - manipulate real-time attributes of a process
−
  saturn.example.com:~ # chrt -p 16244
+
−
  pid 16244's current scheduling policy: SCHED_BATCH
+
Set policy:
−
pid 16244's current scheduling priority: 0
+
  chrt [options] <policy> <priority> {<pid> | <command> [<arg> ...]}
 +
 +
Get policy:
 +
  chrt [options] {<pid> | <command> [<arg> ...]}
 +
 +
Scheduling policies:
 +
  -b | --batch        set policy to SCHED_BATCH
 +
  -f | --fifo          set policy to SCHED_FIFO
 +
  -i | --idle          set policy to SCHED_IDLE
 +
  -o | --other        set policy to SCHED_OTHER
 +
  -r | --rr            set policy to SCHED_RR (default)
 +
 +
  Scheduling flags:
 +
  -R | --reset-on-fork set SCHED_RESET_ON_FORK for FIFO or RR
 +
 +
  Options:
 +
  -a | --all-tasks    operate on all the tasks (threads) for a given pid
 +
  -h | --help          display this help
 +
  -m | --max          show min and max valid priorities
 +
  -p | --pid          operate on existing given pid
 +
  -v | --verbose      display status information
 +
  -V | --version      output version information
  
−
For more information on chrt, see its man page (man 1 chrt).
+
==Tuning Runtime menggunakan sysctl==
−
14.4.6. Runtime Tuning with sysctl¶
 
  
−
The sysctl interface for examining and changing kernel parameters at runtime introduces important variables by means of which you can change the default behavior of the task scheduler. The syntax of the sysctl is simple, and all the following commands must be entered on the command line as root.
+
Interface sysctl dapat digunakan untuk melihat dan mengubah parameter kernel saat runtime yang mana kita dapat mengubah perilaku default dari task scheduler. Sintax dari sysctl sangat sederhana, dan harus di ketik oleh root.
  
−
To read a value from a kernel variable, enter
+
Untuk membaca nilai dari variable kernel, ketik,
  
 
  sysctl variable
 
  sysctl variable
  
−
To assign a value, enter
+
Untuk menset nilai variable, ketik,
  
 
  sysctl variable=value
 
  sysctl variable=value
  
−
To get a list of all scheduler related sysctl variables, enter
+
Untuk memperoleh daftar dari semua variable sysctl yang berhubungan dengan scheduler, ketik,
 +
 
 +
sysctl -A | grep "sched" | grep -v "domain"
  
−
sysctl -A | grep "sched" | grep -v"domain"
+
Contoh hasilnya:
  
−
saturn.example.com:~ # sysctl -A | grep "sched" | grep -v "domain"
 
 
  kernel.sched_child_runs_first = 0
 
  kernel.sched_child_runs_first = 0
−
  kernel.sched_min_granularity_ns = 1000000
+
  kernel.sched_min_granularity_ns = 1500000
−
  kernel.sched_latency_ns = 5000000
+
  kernel.sched_latency_ns = 12000000
−
  kernel.sched_wakeup_granularity_ns = 1000000
+
  kernel.sched_wakeup_granularity_ns = 2000000
−
kernel.sched_shares_ratelimit = 250000
 
 
  kernel.sched_tunable_scaling = 1
 
  kernel.sched_tunable_scaling = 1
−
kernel.sched_shares_thresh = 4
 
−
kernel.sched_features = 15834238
 
 
  kernel.sched_migration_cost = 500000
 
  kernel.sched_migration_cost = 500000
 
  kernel.sched_nr_migrate = 32
 
  kernel.sched_nr_migrate = 32
 
  kernel.sched_time_avg = 1000
 
  kernel.sched_time_avg = 1000
 +
kernel.sched_shares_window = 10000000
 
  kernel.sched_rt_period_us = 1000000
 
  kernel.sched_rt_period_us = 1000000
 
  kernel.sched_rt_runtime_us = 950000
 
  kernel.sched_rt_runtime_us = 950000
−
  kernel.sched_compat_yield = 0
+
  kernel.sched_autogroup_enabled = 1
 +
kernel.sched_cfs_bandwidth_slice_us = 5000
 +
 
 +
'''CATATAN:''' variable yang di akhiri dengan “_ns” dan “_us” menerima nilai dalam nanosecond dan microsecond.
 +
 
 +
Dafta dari variable yang paling penting untuk di tuning pada task scheduler terdapat pada /proc/sys/kernel/ dengan penjelasan pendek berikut:
 +
 
 +
'''sched_child_runs_first'''
 +
 
 +
Fork child dijalankan sebelum parent meneruskan eksekusi. Menset parameter ini menjadi 1 akan menguntungkan untuk aplikasi dimana child menjalankan eksekusi setelah fork. Contoh, make -j <JUMLAH-CPU> akan lebih baik jika sched_child_runs_first dimatikan.
 +
 
 +
Default adalah 0.
 +
 
 +
'''sched_compat_yield'''
 +
 
 +
Akan mengaktifkan perilaku yield dari scheduler 0(1) lebih agresif . Aplikasi Java yang secara ekstensif melakukan sinkronisasi akan berjalan lebih baik jika nilai ini di set ke 1. Hanya gunakan ini jika kita melihat drop dalam performance.
 +
 
 +
Default adalah 0.
 +
 
 +
Aplikasi yang bergantung pada perilaku syscall sched_yield() akan berjalan lebih baik jika nilai di set menjadi 1.
 +
 
 +
'''sched_migration_cost'''
 +
 
 +
Lama waktu sesudah eksekusi terakhir dimana sebuah task akan di perhitungkan sebagai "cache hot" dalam keputusan untuk migrasi / perubahan. Sebuah "hot" task akan kemungkinan kecil untuk di migrasi, oleh karenanya menaikan nilai variabel ini akan menurunkan migrasi task.
 +
 
 +
Default adalah 500000 (ns).
 +
 
 +
Jika waktu idle CPU lebih tinggi dari yang diharapkan jika ada proses yang bisa di jalankan, coba kecilkan nilai ini. Jika task bounce antara CPU atau node terlalu sering, coba naikan nilai ini.
 +
 
 +
'''sched_latency_ns''' -
 +
 
 +
Latency preemtion yang di ijinkan untuk task CPU bound. Menaikan nilai variable ini akan menaikan task CPU bound timeslice. Task timeslice diberi bobot pembagi secara fair dalam perioda scheduling:
  
−
Note that variables ending with “_ns” and “_us” accept values in nanoseconds and microseconds, respectively.
+
timeslice = scheduling period * (bobot task/total bobot task di antrian run)
  
−
A list of the most important task scheduler sysctl tuning variables (located at /proc/sys/kernel/) with a short description follows:
+
Bobot task tergantung pada level nice task dan kebijakan scheduling. Bobot minimal task untuk task SCHED_OTHER adalah 15, ini sama dengan nice 19. Bobot maximum task adalah 88761, ini sama dengan nice -20.
  
−
sched_child_runs_first
+
Semakin kecil timeslice maka load CPU naik. Jika jumlah task yang akan di jalankan melebihi sched_latency_ns/sched_min_granularity_ns, maka timeslice akan menjadi number_of_running_tasks * sched_min_granularity_ns. Sebelum itu terjadi, timeslice akan sama sched_latency_ns.
  
−
    A freshly forked child runs before the parent continues execution. Setting this parameter to 1 is beneficial for an application in which the child performs an execution after fork. For example make -j<NO_CPUS> performs better when sched_child_runs_first is turned off. The default value is 0.
+
Nilai ini pada dasarnya mengatur jumlah waktu maksimum untuk sebuah task yang sedang sleeping untuk di perhitungkan dalam kalkulasi ijin run. Menaikan nilai ini akan menaikan jumlah waktu bagi task yang bangun yang dapat di gunakan sebelum di preempted, ini akhirnya akan menaikan scheduler latency untuk task yang CPU bound.  
−
sched_compat_yield
 
  
−
    Enables the aggressive yield behavior of the old 0(1) scheduler. Java applications that use synchronization extensively perform better with this value set to 1. Only use it when you see a drop in performance. The default value is 0.
+
Nilai Default adalah 20000000 (ns).  
  
−
    Expect applications that depend on the sched_yield() syscall behavior to perform better with the value set to 1.
+
'''sched_min_granularity_ns'''
−
sched_migration_cost
 
  
−
    Amount of time after the last execution that a task is considered to be “cache hot” in migration decisions. A “hot” task is less likely to be migrated, so increasing this variable reduces task migrations. The default value is 500000 (ns).
+
Minimal preemption granularitas untuk task CPU bound. Baca-baca sched_latency_ns untuk lebih detail.  
  
−
    If the CPU idle time is higher than expected when there are runnable processes, try reducing this value. If tasks bounce between CPUs or nodes too often, try increasing it.
+
Nilai default adalah 4000000 (ns).  
−
sched_latency_ns
 
  
−
    Targeted preemption latency for CPU bound tasks. Increasing this variable increases a CPU bound task's timeslice. A task's timeslice is its weighted fair share of the scheduling period:
+
'''sched_wakeup_granularity_ns'''
  
−
    timeslice = scheduling period * (task's weight/total weight of tasks in the run queue)
+
Granularitas preemption untuk wake-up (bangun). Menaikan nilai variable ini akan mengurangi preemption wake-up, menggurangi gangguan bagi task yang banyak melakukan perhitungan. Menurunkan nilai ini akan memperbaiki latency wake-up dan throughput untuk task penting, terutama jika komponen dengan beban pendek harus berkompetisi dengan komponen CPU bound.
  
−
    The task's weight depends on the task's nice level and the scheduling policy. Minimum task weight for a SCHED_OTHER task is 15, corresponding to nice 19. The maximum task weight is 88761, corresponding to nice -20.
+
Nilai default adalah 5000000 (ns).
  
−
    Timeslices become smaller as the load increases. When the number of runnable tasks exceeds sched_latency_ns/sched_min_granularity_ns, the slice becomes number_of_running_tasks * sched_min_granularity_ns. Prior to that, the slice is equal to sched_latency_ns.
+
'''WARNING:'''
 +
Menset lebih besar dari setengah sched_latency_ns akan menyebabkan zero wake-up preemption dan task pendek akan tidak bisa berkompetisi secara effektif dengan task yang memakan CPU.
  
−
    This value also specifies the maximum amount of time during which a sleeping task is considered to be running for entitlement calculations. Increasing this variable increases the amount of time a waking task may consume before being preempted, thus increasing scheduler latency for CPU bound tasks. The default value is 20000000 (ns).
 
−
sched_min_granularity_ns
 
  
−
    Minimal preemption granularity for CPU bound tasks. See sched_latency_ns for details. The default value is 4000000 (ns).
+
'''sched_rt_period_us'''
−
sched_wakeup_granularity_ns
 
  
−
    The wake-up preemption granularity. Increasing this variable reduces wake-up preemption, reducing disturbance of compute bound tasks. Lowering it improves wake-up latency and throughput for latency critical tasks, particularly when a short duty cycle load component must compete with CPU bound components. The default value is 5000000 (ns).
+
Perioda dimana pelaksanaan task real-time di ukur.
−
    [Warning]
 
  
−
    Settings larger than half of sched_latency_ns will result in zero wake-up preemption and short duty cycle tasks will be unable to compete with CPU hogs effectively.  
+
Nilai default adalah 1000000 (µs).  
−
sched_rt_period_us
 
  
−
    Period over which real-time task bandwidth enforcement is measured. The default value is 1000000 (µs).
+
'''sched_rt_runtime_us'''
−
sched_rt_runtime_us
 
  
−
    Quantum allocated to real-time tasks during sched_rt_period_us. Setting to -1 disables RT bandwidth enforcement. By default, RT tasks may consume 95%CPU/sec, thus leaving 5%CPU/sec or 0.05s to be used by SCHED_OTHER tasks.  
+
Alokasi waktu untuk task real-time (RT) saat sched_rt_period_us. Menset menjadi -1 akan men-disable pelaksanaan waktu real-time (RT).  
−
sched_features
 
  
−
    Provides information about specific debugging features.  
+
Nilai default, task real-time (RT) akan mengkonsumsi 95% CPU/detik, oleh karenanya hanya akan menyisakan 5% CPU/detik atau 0.05s untuk digunakan oleh task SCHED_OTHER.  
−
sched_stat_granularity_ns
 
  
−
    Specifies the granularity for collecting task scheduler statistics.
+
'''sched_features'''
−
sched_nr_migrate
 
  
−
    Controls how many tasks can be moved across processors through migration software interrupts (softirq). If a large number of tasks is created by SCHED_OTHER policy, they will all be run on the same processor. The default value is 32. Increasing this value gives a performance boost to large SCHED_OTHER threads at the expense of increased latencies for real-time tasks.  
+
Memberikan informasi tentang fitur debugging yang spesifik.
  
−
14.4.7. Debugging Interface and Scheduler Statistics¶
 
  
−
CFS comes with a new improved debugging interface, and provides runtime statistics information. Relevant files were added to the /proc file system, which can be examined simply with the cat or less command. A list of the related /proc files follows with their short description:
+
'''sched_stat_granularity_ns'''
  
−
/proc/sched_debug
+
Menentukan granularitas untuk pengumpulan statistik task scheduler.
  
−
    Contains the current values of all tunable variables (see Section 14.4.6, “Runtime Tuning with sysctl”) that affect the task scheduler behavior, CFS statistics, and information about the run queue on all available processors.
+
'''sched_nr_migrate'''
  
−
    saturn.example.com:~ # less /proc/sched_debug
+
Mengatur berapa task yang dapat di pindahkan antar processor melalui interupsi software migrasi (softirq). Jika sebagian besar task dibuat oleh kebijakan SCHED_OTHER, mereka semua biasakan akan jalan di processor yang sama.
−
    Sched Debug Version: v0.09, 2.6.32.8-0.3-default #1
 
−
    now at 2413026096.408222 msecs
 
−
      .jiffies                                : 4898148820
 
−
      .sysctl_sched_latency                    : 5.000000
 
−
      .sysctl_sched_min_granularity            : 1.000000
 
−
      .sysctl_sched_wakeup_granularity        : 1.000000
 
−
      .sysctl_sched_child_runs_first          : 0.000000
 
−
      .sysctl_sched_features                  : 15834238
 
−
      .sysctl_sched_tunable_scaling            : 1 (logaritmic)
 
  
−
    cpu#0, 1864.411 MHz
+
Nilai default adalah 32.
−
      .nr_running                    : 1
 
−
      .load                          : 1024
 
−
      .nr_switches                  : 37539000
 
−
      .nr_load_updates              : 22950725
 
−
    [...]
 
−
    cfs_rq[0]:/
 
−
      .exec_clock                    : 52940326.803842
 
−
      .MIN_vruntime                  : 0.000001
 
−
      .min_vruntime                  : 54410632.307072
 
−
      .max_vruntime                  : 0.000001
 
−
    [...]
 
−
    rt_rq[0]:/
 
−
      .rt_nr_running                : 0
 
−
      .rt_throttled                  : 0
 
−
      .rt_time                      : 0.000000
 
−
      .rt_runtime                    : 950.000000
 
  
−
    runnable tasks:
+
Menaikan nilai ini biasakan akan menaikan performance untuk thread besar pada  SCHED_OTHER dengan mengorbankan latency yang lebih tinggi untuk task yang real-time.
−
      task PID  tree-key    switches prio exec-runtime    sum-exec sum-sleep
 
−
    --------------------------------------------------------------------------
 
−
    R cat 16884 54410632.307072    0  120  54410632.307072 13.836804 0.000000
 
  
−
/proc/schedstat
+
==Interface Debugging dan Statistik Scheduler==
  
−
    Displays statistics relevant to the current run queue. Also domain-specific statistics for SMP systems are displayed for all connected processors. Because the output format is not user-friendly, read the contents of /usr/src/linux/Documentation/scheduler/sched-stats.txt for more information.  
+
CFS digunakan dengan interface debugging yang baru, dan dapat memberikan informasi statiktik runtime. File yang relevan ada di directory /proc, yang dapat di pelajari hanya dengan printah cat atau less. Sedikit tentang file /proc dan penjelasan pendeknya:
−
/proc/PID/sched
 
  
−
    Displays scheduling information on the process with id PID.
+
===/proc/sched_debug===
  
−
    saturn.example.com:~ # cat /proc/`pidof nautilus`/sched
+
Berisi nilai saat ini dari semua variabel yang dapat di tuning yang akan mempengaruhi perilaku task scheduler, CFS statistik, dan informasi tentang antrian run di semua processor yang tersedia.
−
    nautilus (4009, #threads: 1)
 
−
    ---------------------------------------------------------
 
−
    se.exec_start                      :    2419575150.560531
 
−
    se.vruntime                        :      54549795.870151
 
−
    se.sum_exec_runtime                :      4867855.829415
 
−
    se.avg_overlap                    :            0.401317
 
−
    se.avg_wakeup                      :            3.247651
 
−
    se.avg_running                    :            0.323432
 
−
    se.wait_start                      :            0.000000
 
−
    se.sleep_start                    :    2419575150.560531
 
−
    [...]
 
−
    nr_voluntary_switches              :              938552
 
−
    nr_involuntary_switches            :                71872
 
−
    se.load.weight                    :                1024
 
−
    policy                            :                    0
 
−
    prio                              :                  120
 
−
    clock-delta                        :                  109
 
  
−
14.5. For More Information¶
+
less /proc/sched_debug
  
−
To get a compact knowledge about Linux kernel task scheduling, you need to explore several information sources. Here are some of them:
+
Hasilnya kira-kira
  
−
    For task scheduler System Calls description, see the relevant manual page (for example man 2 sched_setaffinity).
+
Sched Debug Version: v0.10, 3.2.0-29-generic #46-Ubuntu
 +
ktime                                  : 175814713.744739
 +
sched_clk                              : 152754753.141005
 +
cpu_clk                                : 175814713.743515
 +
jiffies                                : 4338845974
 +
sched_clock_stable                      : 0
 +
 +
sysctl_sched
 +
  .sysctl_sched_latency                    : 12.000000
 +
  .sysctl_sched_min_granularity            : 1.500000
 +
  .sysctl_sched_wakeup_granularity        : 2.000000
 +
  .sysctl_sched_child_runs_first          : 0
 +
  .sysctl_sched_features                  : 24119
 +
  .sysctl_sched_tunable_scaling            : 1 (logaritmic)
 +
 +
cpu#0, 1296.721 MHz
 +
  .nr_running                    : 2
 +
  .load                          : 771
 +
  .nr_switches                  : 1394812584
 +
  .nr_load_updates              : 16371163
 +
  .nr_uninterruptible            : 795487
 +
  .next_balance                  : 4338.846000
 +
  .curr->pid                    : 4702
 +
  .clock                        : 175814713.750402
 +
  .cpu_load[0]                  : 1024
 +
  .cpu_load[1]                  : 984
 +
  .cpu_load[2]                  : 1048
 +
  .cpu_load[3]                  : 1120
 +
  .cpu_load[4]                  : 1172
 +
  .yld_count                    : 310677
 +
  .sched_switch                  : 0
 +
  .sched_count                  : 1400427770
 +
  .sched_goidle                  : 526715556
 +
  .avg_idle                      : 190439
 +
  .ttwu_count                    : 1213620697
 +
  .ttwu_local                    : 693494658
 +
 +
cfs_rq[0]:/autogroup-108
 +
  .exec_clock                    : 1084323.602095
 +
  .MIN_vruntime                  : 0.000001
 +
  .min_vruntime                  : 1084318.510901
 +
  .max_vruntime                  : 0.000001
 +
  .spread                        : 0.000000
 +
  .spread0                      : -38610036.626370
 +
  .nr_spread_over                : 0
 +
  .nr_running                    : 0
 +
  .load                          : 0
 +
  .load_avg                      : 2705.524480
 +
.....
 +
rt_rq[0]:/
 +
  .rt_nr_running                : 0
 +
  .rt_throttled                  : 0
 +
  .rt_time                      : 0.000000
 +
  .rt_runtime                    : 950.000000
 +
 +
runnable tasks:
 +
            task  PID        tree-key  switches  prio    exec-runtime        sum-exec        sum-sleep
 +
----------------------------------------------------------------------------------------------------------
 +
          compiz  2710  24446058.117120  9422853  120  24446058.117120  1192860.567985 173953317.232879 /autogroup-133
 +
R        firefox  4688  24446057.988583  84022061  120  24446057.988583  40996425.370526 131036496.584050 /autogroup-133
  
−
    General information on scheduling is described in Scheduling wiki page.
+
===/proc/schedstat===
  
−
    General information on Linux task scheduling is described in Inside the Linux scheduler.
+
Menampilkan statistik relevan terhadap run queue saat itu. Juga domain-spesifik statistik dari sistem SMP untuk semua prosesor yang tersambung. Karena format output tidak terlalu user-friendly, untuk informasi lebih lanjut ada baiknya baca
  
−
    Information specific to Completely Fair Scheduler is available in Multiprocessing with the Completely Fair Scheduler
+
more /usr/src/linux/Documentation/scheduler/sched-stats.txt
  
−
    Information specific to tuning Completely Fair Scheduler is available in Tuning the Linux Kernel’s Completely Fair Scheduler
+
Untuk melihat informasi lebih detail untuk sebuah Proses ID (PID), ketik,
  
−
    A useful lecture on Linux scheduler policy and algorithm is available in http://www.inf.fu-berlin.de/lehre/SS01/OS/Lectures/Lecture08.pdf.
+
less /proc/PID/sched
  
−
    A good overview of Linux process scheduling is given in Linux Kernel Development by Robert Love (ISBN-10: 0-672-32512-8). See http://www.informit.com/articles/article.aspx?p=101760.
+
misalnya jika ada proses 10485, ketik
  
−
    A very comprehensive overview of the Linux kernel internals is given in Understanding the Linux Kernel by Daniel P. Bovet and Marco Cesati (ISBN 978-0-596-00565-8).
+
less /proc/10485/sched
  
−
    Technical information about task scheduler is covered in files under /usr/src/linux/Documentation/scheduler.
+
Akan keluar seperti
  
 +
rsync (10485, #threads: 1)
 +
---------------------------------------------------------
 +
se.exec_start                      :    176371611.333607
 +
se.vruntime                        :      2627563.353534
 +
se.sum_exec_runtime                :        141516.884079
 +
se.statistics.wait_start          :            0.000000
 +
se.statistics.sleep_start          :            0.000000
 +
se.statistics.block_start          :    176371611.333607
 +
se.statistics.sleep_max            :        60060.014521
 +
.....
 +
se.statistics.nr_wakeups_affine_attempts:              1910947
 +
se.statistics.nr_wakeups_passive  :                    0
 +
se.statistics.nr_wakeups_idle      :                    0
 +
avg_atom                          :            0.038524
 +
avg_per_cpu                        :            0.268959
 +
nr_switches                        :              3677210
 +
nr_voluntary_switches              :              3631250
 +
nr_involuntary_switches            :                45960
 +
se.load.weight                    :                1024
 +
policy                            :                    0
 +
prio                              :                  120
 +
clock-delta                        :                  150
  
 +
==Informasi Lebih Lanjut==
  
 +
Baca informasi tentang task scheduler di file di bawah /usr/src/linux/Documentation/scheduler
  
 
==Referensi==
 
==Referensi==
  
 +
* http://www.inf.fu-berlin.de/lehre/SS01/OS/Lectures/Lecture08.pdf
 
* http://doc.opensuse.org/documentation/html/openSUSE/opensuse-tuning/book.tuning.html
 
* http://doc.opensuse.org/documentation/html/openSUSE/opensuse-tuning/book.tuning.html
 
* http://doc.opensuse.org/documentation/html/openSUSE/opensuse-tuning/cha.tuning.taskscheduler.html
 
* http://doc.opensuse.org/documentation/html/openSUSE/opensuse-tuning/cha.tuning.taskscheduler.html
Line 353: Line 441:
 
* [[Linux]]
 
* [[Linux]]
 
* [[Ubuntu]]
 
* [[Ubuntu]]
 +
* [[Buku Sistem Operasi]]
 +
 +
===Secara Umum===
 +
 
* [[Sistem Operasi]]
 
* [[Sistem Operasi]]
 +
 +
===Instalasi Linux===
 +
 +
* [[Linux: CLI untuk Survival]]
 +
* [[Linux: Skema Partisi di Linux]]
 +
* [[Linux: Instalasi Sistem Operasi]]
 +
 +
===Compile Kernel===
 +
 
* [[Kernel]]
 
* [[Kernel]]
 +
* [[OS: Linux Kernel]]
 +
* [[Kernel: Anatomi Kernel Source]]
 
* [[Compile Kernel]]
 
* [[Compile Kernel]]
−
* [[OS: Linux Kernel]]
+
* [[Compile Kernel: Konfigurasi Kernel]]
 +
 
 +
===Remaster Linux===
 +
 
 +
* [[Cara Cepat Melakukan Remastering Ubuntu]]
 +
 
 +
===Sistem Operasi untuk Embedded===
 +
 
 +
* [[OpenWRT]]
 +
* [[OpenWRT: Download Firmware yang sudah jadi]]
 +
* [[OpenWRT: Source Repository Download]]
 +
* [[OpenWRT: Melihat Daftar Package]]
 +
 
 +
====Membuat Firmware Sendiri====
 +
 
 +
* [[OpenWRT: Build Firmware]]
 +
* [[OpenWRT: Build Firmware Buffalo WZRHPG450H]]
 +
* [[OpenWRT: Build Firmware Buffalo WZRHPG300N]]
 +
* [[OpenWRT: Build Firmware Ubiquiti NanoStation2]]
 +
* [[OpenWRT: Build Firmware Mikrotik RB433]]
 +
* [[OpenWRT: Build Firmware Linksys WRT160NL]]
 +
* [[OpenWRT: Build Firmware Linksys WRT54GL]]
 +
 
 +
====Flash ke Device====
 +
 
 +
* [[OpenWRT: Flash Linksys WRT54GL]]
 +
* [[OpenWRT: Flash Buffalo WZRHP450H]]
 +
* [[OpenWRT: Flash Buffalo WZRHP300N]]
 +
* [[OpenWRT: Flash UBNT NanoStation2]]
 +
 
 +
====Beberapa Tip====
 +
 
 +
* [[OpenWRT: Mikrotik RB433]]
 +
* [[OpenWRT: 3G modem]]
 +
* [[OpenWRT: Build Firmware dengan 3G Modem Support]]
 +
* [[OpenWRT: Setup Firewall]]
 +
* [[OpenWRT: Konfigurasi UBNT NanoStation2 tanpa WebGUI]]
 +
 
 +
===Tuning Kernel===
 +
 
 
* [[OS: Parameter Kernel Default]]
 
* [[OS: Parameter Kernel Default]]
 +
 +
====Tuning Kernel Scheduler====
 +
 
* [[OS: Kernel Scheduler]]
 
* [[OS: Kernel Scheduler]]
 +
* [[OS: Tuning Kernel Scheduler]]
 +
* [[OS: Tuning Completely Fair scheduler CFS]]
 
* [[OS: Complete Teori Tuning Kernel Scheduler]]
 
* [[OS: Complete Teori Tuning Kernel Scheduler]]
 +
 +
====Tuning I/O Scheduler====
 +
 +
* [[OS: Tuning Completely Fair Queueing CFQ I/O scheduler]]
 
* [[OS: Complete Teori Tuning I/O Performance]]
 
* [[OS: Complete Teori Tuning I/O Performance]]
−
* [[OS: Tuning Kernel Scheduler]]
+
 
−
* [[OS: Tuning Completely Fair Queueing CFQ I/O scheduler]]
+
====Tuning Manajemen Memory====
−
* [[OS: Tuning Completely Fair scheduler CFS]]
+
 
 +
* [[OS: Tuning Manajemen Memory]]
 +
 
 +
===Android===
 +
 
 +
* [[OS: Android - Download]]
 +
 
 +
===Membuat Kernel Module===
 +
 
 +
* [[OS: Mengerti System Call]]
 +
* [[OS: Membuat Kernel Modul]]
 +
 
 +
===Monitoring & Benchmark===
 +
 
 
* [[OS: Build in Monitoring Tool]]
 
* [[OS: Build in Monitoring Tool]]
 
* [[Linux Benchmarking]]
 
* [[Linux Benchmarking]]
 
* [[OS: Benchmarking menggunakan UnixBench]]
 
* [[OS: Benchmarking menggunakan UnixBench]]
 
* [[OS: Benchmarking menggunakan LLCBench]]
 
* [[OS: Benchmarking menggunakan LLCBench]]
−
* [[OS: Membuat Kernel Modul]]
 

Latest revision as of 13:43, 7 April 2013

Sumber: http://doc.opensuse.org/documentation/html/openSUSE/opensuse-tuning/cha.tuning.taskscheduler.html

Sistem operasi modern biasanya menjalankan tugas-tugas yang berbeda pada waktu yang bersamaan. Misalnya, Anda dapat mencari dalam sebuah file teks sambil menerima e-mail dan menyalin file besar ke hard drive eksternal. Tugas-tugas mudah tersebut memerlukan proses tambahan yang harus dijalankan oleh sistem. Untuk memberikan setiap tugas dengan sumber daya yang diperlukan , kernel Linux membutuhkan alat untuk mendistribusikan sumber daya sistem yang tersedia untuk tugas individu. Dan ini adalah tugas scheduler .

Bagian berikut menjelaskan istilah yang paling penting yang terkait dengan scheduling proses. Disini juga akan diperkenalkan informasi tentang kebijakan task scheduler , algoritma penjadwalan, deskripsi tugas scheduler yang digunakan oleh Linux, dan referensi ke sumber informasi lain yang relevan.

Pendahuluan

Kernel Linux mengontrol cara task (atau proses) dikelola dalam sistem yang berjalan. Task scheduler, kadang-kadang disebut proses scheduler, adalah bagian dari kernel yang memutuskan task mana yang akan di jalankan berikutnya. Task scheduler adalah salah satu komponen inti dari sistem operasi multitasking (seperti Linux), yang bertanggung jawab untuk memanfaatkan sumber daya sistem sebaik-baiknya untuk menjamin bahwa beberapa task dapat berjalan secara bersamaan.

Preemption

Teori di balik task scheduling sangat sederhana. Jika ada proses runnable dalam suatu sistem, setidaknya satu proses harus senantiasa berjalan. Jika ada lebih banyak runnable proses daripada prosesor dalam sistem, tidak semua proses dapat berjalan sepanjang waktu.

Oleh karena itu, beberapa proses perlu dihentikan sementara, atau ditangguhkan, sehingga proses lain dapat berjalan kembali. Task scheduler memutuskan proses mana dalam antrian akan berjalan selanjutnya.

Seperti telah disebutkan, Linux, seperti semua varian Unix lainnya, adalah sistem operasi multitasking. Ini berarti bahwa beberapa task dapat berjalan pada waktu yang sama. Linux menyediakan apa yang disebut preemptive multitasking, di mana Task scheduler memutuskan kapan proses dihentikan. Suspensi secara paksa ini disebut preemption. Semua turunan Unix telah menyediakan preemptive multitasking sejak awal.

Timeslice

Periode waktu yang digunakan suatu proses yang akan berjalan terlebih dulu didefinisikan di awal. Hal ini disebut proses timeslice dan mewakili jumlah waktu prosesor yang diberikan kepada setiap proses. Dengan menetapkan timeslices, scheduler membuat keputusan global untuk sistem berjalan, dan mencegah proses individu untuk mendominasi sumber daya prosesor.

Prioritas Process

Task scheduler mengevaluasi proses berdasarkan prioritas mereka. Untuk menghitung prioritas sebuah proses, Task Scheduler menggunakan algoritma yang komplek. Akibatnya, setiap proses diberi nilai yang berdasarkan nilai tersebiut proses itu "diperbolehkan" untuk berjalan di prosesor.

Klasifikasi Proses

Proses biasanya diklasifikasikan menurut tujuan dan perilaku mereka. Meskipun batas tersebut tidak selalu jelas, umumnya ada dua kriteria yang digunakan untuk menyortir mereka. Kriteria yang independen dan tidak mengecualikan satu sama lain.


Salah satu pendekatan adalah dengan mengklasifikasi sebuah proses apakah sebagai I/O-bound atau processor-bound.

I/O-bound

I/O adalah singkatan dari perangkat Input / Output , seperti keyboard, mouse, atau cakram optik dan harddisk. I/O-bound proses menghabiskan sebagian besar waktu untuk mengajukan dan menunggu permintaan. Mereka berjalan sangat sering, tapi untuk interval waktu yang singkat, tidak untuk memblokir proses-proses lain yang menunggu permintaan I/O.

processor-bound

Di sisi lain, prosesor-bound task menggunakan waktu mereka untuk mengeksekusi kode, dan biasanya dijalankan sampai mereka ditunda eksekusinya oleh Task scheduler. Mereka tidak menghalangi proses yang menunggu permintaan I / O, dan, karenanya, dapat dijalankan lebih jarang tetapi untuk interval waktu yang lebih lama.


Pendekatan lain adalah untuk membagi proses sebagai proses interaktif, batch atau real-time.

Proses Interaktif

Proses interaktif menghabiskan banyak waktu yang menunggu permintaan I / O, seperti operasi keyboard atau mouse. Task scheduler harus membangunkan proses tersebut dengan cepat atas permintaan pengguna, jika tidak pengguna akan menemukan lingkungan tidak tanggap. Penundaan biasanya sekitar 100 ms. Aplikasi office, editor teks atau program manipulasi gambar merupakan contoh aplikasi yang membutuhkan proses interaktif.

Proses Batch

Proses Batch sering berjalan di latar belakang dan tidak perlu responsif. Mereka biasanya mendapat prioritas lebih rendah dari Task scheduler. Konverter multimedia, mesin database pencarian, atau file log analisis adalah contoh dari proses batch.

Proses Real-Time

Proses Real-time tidak harus diblokir oleh proses prioritas rendah, dan Task scheduler menjamin waktu respon singkat kepada mereka. Aplikasi untuk mengedit konten multimedia adalah salah satu contoh-nya.

O(1) Scheduler

Versi kernel Linux 2.6 memperkenalkan Task scheduler baru, yang disebut O (1) scheduler (lihat Big notasi O), itu digunakan sebagai default Task scheduler sampai versi Kernel 2.6.22. Tugas utamanya adalah untuk menjadwalkan task dalam jumlah waktu yang tetap, tidak peduli berapa banyak proses terdapat dalam sistem.

Scheduler menghitung timeslices secara dinamis. Namun, untuk menentukan proses timeslice yang tepat adalah tugas yang kompleks: timeslices Terlalu lama menyebabkan sistem menjadi kurang interaktif dan responsif, sementara yang terlalu pendek membuat prosesor membuang banyak waktu di overhead switching proses yang terlalu sering. proses timeslice standar biasanya agak rendah, misalnya 20ms . scheduler menentukan proses timeslice berdasarkan prioritas dari proses, yang memungkinkan proses dengan prioritas yang lebih tinggi untuk menjalankan lebih sering dan untuk waktu yang lama.

Sebuah proses tidak harus memanfaatkan semua proses timeslice sekaligus. Misalnya, dengan proses timeslice dari 150ms tidak harus berjalan selama 150ms dalam satu kali. Hal ini dapat berjalan di lima slot jadwal yang berbeda untuk 30ms . task interaktif biasanya memperoleh manfaat dari pendekatan ini karena mereka tidak perlu seperti proses timeslice besar sekaligus saat mereka harus responsif selama mungkin.

Scheduler juga menetapkan prioritas proses secara dinamis. Scheduler memonitor perilaku proses dan, jika diperlukan, menyesuaikan prioritas. Sebagai contoh, proses yang diskors untuk waktu yang lama dinyalakan dengan meningkatkan prioritas.

Completely Fair Scheduler (CFQ)

Sejak kernel Linux 2.6.23, pendekatan baru telah dibawa ke proses task scheduling . Completely Fair Scheduler (CFS) menjadi default Linux kernel scheduler. Sejak itu, perubahan-perubahan penting dan perbaikan telah dibuat. Informasi dalam bagian berlaku untuk Linux dengan versi kernel 2.6.32 dan yang lebih tinggi (termasuk kernel 3.x). Lingkungan scheduler dibagi menjadi beberapa bagian, dan tiga fitur utama baru yang diperkenalkan:

Modular Scheduler Core

Inti dari scheduler ditingkatkan dengan kelas task scheduling. Kelas-kelas yang modular dan merepresentasikan kebijakan task scheduling.

Completely Fair Scheduler

Diperkenalkan pada kernel 2.6.23 dan diperpanjang di 2.6.24, CFS mencoba untuk memastikan bahwa setiap proses memperoleh bagian yang "fair" dari waktu prosesor.

Group Scheduling

Misalnya, jika kita membagi proses menjadi kelompok-kelompok yang berdasarkan group tersebut pengguna menjalankan proses tersebut, CFS mencoba untuk memberikan masing-masing kelompok dengan jumlah waktu prosesor yang sama.

Akibatnya, CFS membawa task scheduling lebih dioptimalkan untuk server dan desktop.

Bagaimana CFS Bekerja

CFS mencoba untuk menjamin pendekatan yang adil untuk setiap task . Untuk menemukan cara yang paling seimbang penjadwalan tugas, menggunakan konsep pohon merah-hitam . Sebuah pohon merah-hitam adalah jenis self-balancing pohon pencarian data yang menyediakan memasukkan dan menghapus entri dalam cara yang wajar sehingga tetap seimbang. Untuk informasi lebih lanjut, lihat halaman wiki Pohon Merah-hitam http://en.wikipedia.org/wiki/Red_black_tree.

Ketika task masuk ke dalam antrian run (timeline rencana proses yang akan dieksekusi berikutnya), scheduler mencatat waktu saat tersebut. Saat proses menunggu waktu prosesor, Nilai "wait / tunggu" akan bertambah dengan jumlah yang berasal dari banyaknya task saat ini dalam antrian run dan prioritas proses. Segera setelah prosesor menjalankan tugas, Nilai "wait / tunggu" akan dikurangi. Jika nilai turun di bawah tingkat tertentu, tugas yang ditunda eksekusinya oleh scheduler dan tugas-tugas lain akan menjadi lebih dekat untuk dieksekusi oleh prosesor. Dengan algoritma ini, CFS mencoba untuk mencapai kondisi ideal di mana nilai "wait / tunggu" selalu nol.

Grouping Proses

Sejak kernel Linux 2.6.24, CFS dapat disetel untuk bersikap adil kepada pengguna atau group dan bukan hanya task saja. task runnable kemudian dikelompokkan untuk membentuk entitas, dan CFS mencoba untuk bersikap adil terhadap entitas bukan task individu. scheduler juga mencoba untuk bersikap adil terhadap task individu dalam entitas.

Task dapat dikelompokkan dalam dua kategori yang saling eksklusif:

  • Berdasarkan user ID
  • Berdasarkan kernel control group.

Kernel scheduler kernel memungkinkan kita mengelompokan task tergantung pada pengaturan pilihan kernel compile-time yaitu CONFIG_FAIR_USER_SCHED dan CONFIG_FAIR_CGROUP_SCHED. Pengaturan default biasanya menggunakan group kontrol, yang memungkinkan kita membuat grup sesuai kebutuhan.

Pilihan Konfigurasi Kernel

Basic aspects of the task scheduler behavior can be set through the kernel configuration options. Setting these options is part of the kernel compilation process. Because kernel compilation process is a complex task and out of this document's scope, refer to relevant source of information (for example http://en.opensuse.org/Configure,_Build_and_Install_a_Custom_Linux_Kernel).

Berbagai Istilah

Dokumen tentang task scheduling policy kadang kala menggunakan beberapa istilah teknik yang perlu kita ketahui dengan benar. Berikut adalaha beberapa diantara istilah tersebut:

Latency

Delay antara waktu sebuah proses di jadwalkan untuk di run vs. waktu eksekusi proses yang sebenarnya.

Granularity

Hubungan antara granularity dengan latency dapat di tulis dengan persamaan berikut: 

gran = ( lat / rtasks ) - ( lat / rtasks / rtasks )

dimana

  • gran adalah granularity
  • lat adalah latency
  • rtasks adalah jumlah task yang running / berjalan

Scheduling Policies

Kernel Linux mendukung kebijakan scheduling berikut:

  • SCHED_FIFO - kebijakan scheduling yang di rancang untuk aplikasi yang time-critical. Kebijakan ini menggunakan algoritma scheduling First In-First Out.
  • SCHED_BATCH - kebijakan scheduling di rancang untuk task yang CPU-intensive.
  • SCHED_IDLE - kebijakan scheduling yang di rancang untuk task yang prioritasnya sangat rendah.
  • SCHED_OTHER - kebijakan default Linux time-sharing scheduling yang digunakan oleh sebagian besar proses.
  • SCHED_RR - mirip dengan SCHED_FIFO, tapi menggunakan algoritma Round Robin scheduling.

Mengubah Atribut Real-time dari proses dengan chrt

Perintah chrt digunakan untuk set atau melihat atribute real-time scheduling dari sebuah proses yang sedang running, atau menjalankan sebuah perintah dengan atribut tertentu. Kita dapat mengambil baik kebijakan scheduling maupun prioritas proses.

Pada contoh berikut, sebuah proses dengan PID 11652 akan dijadikan contoh.

Untuk melihat atribut real-time dari task yang ada: 

chrt -p 11652

Contoh keluaran: 

pid 11652's current scheduling policy: SCHED_OTHER
pid 11652's current scheduling priority: 0

Sebelum menset ke kebijakan scheduling yang baru pada sebuah proses, kita perlu melihat prioritas minimum dan maximum yang valid untuk setiap algoritma scheduling melalui perintah: 

chrt -m

Contoh keluaran: 

SCHED_OTHER min/max priority	: 0/0
SCHED_FIFO min/max priority	: 1/99
SCHED_RR min/max priority	: 1/99
SCHED_BATCH min/max priority	: 0/0
SCHED_IDLE min/max priority	: 0/0

Pada contoh di atas, kebijakan SCHED_OTHER, SCHED_BATCH, SCHED_IDLE hanya mengijinkan prioritas 0, sementara SCHED_FIFO dan SCHED_RR dapat di set antara 1 sampai dengan 99.

Untuk menset agar menjadi SCHED_BATCH scheduling: 

chrt -b -p 0 11652
chrt -p 11652

Contoh keluaran: 

pid 11652's current scheduling policy: SCHED_BATCH
pid 11652's current scheduling priority: 0

Untuk info lebih lanjut tentang chrt, kita dapat menulis 

chrt -h

Contoh keluaran: 

chrt - manipulate real-time attributes of a process

Set policy:
  chrt [options] <policy> <priority> {<pid> | <command> [<arg> ...]}

Get policy:
  chrt [options] {<pid> | <command> [<arg> ...]}

Scheduling policies:
  -b | --batch         set policy to SCHED_BATCH
  -f | --fifo          set policy to SCHED_FIFO
  -i | --idle          set policy to SCHED_IDLE
  -o | --other         set policy to SCHED_OTHER
  -r | --rr            set policy to SCHED_RR (default)

Scheduling flags:
  -R | --reset-on-fork set SCHED_RESET_ON_FORK for FIFO or RR

Options:
  -a | --all-tasks     operate on all the tasks (threads) for a given pid
  -h | --help          display this help
  -m | --max           show min and max valid priorities
  -p | --pid           operate on existing given pid
  -v | --verbose       display status information
  -V | --version       output version information

Tuning Runtime menggunakan sysctl

Interface sysctl dapat digunakan untuk melihat dan mengubah parameter kernel saat runtime yang mana kita dapat mengubah perilaku default dari task scheduler. Sintax dari sysctl sangat sederhana, dan harus di ketik oleh root.

Untuk membaca nilai dari variable kernel, ketik, 

sysctl variable

Untuk menset nilai variable, ketik, 

sysctl variable=value

Untuk memperoleh daftar dari semua variable sysctl yang berhubungan dengan scheduler, ketik, 

sysctl -A | grep "sched" | grep -v "domain"

Contoh hasilnya: 

kernel.sched_child_runs_first = 0
kernel.sched_min_granularity_ns = 1500000
kernel.sched_latency_ns = 12000000
kernel.sched_wakeup_granularity_ns = 2000000
kernel.sched_tunable_scaling = 1
kernel.sched_migration_cost = 500000
kernel.sched_nr_migrate = 32
kernel.sched_time_avg = 1000
kernel.sched_shares_window = 10000000
kernel.sched_rt_period_us = 1000000
kernel.sched_rt_runtime_us = 950000
kernel.sched_autogroup_enabled = 1
kernel.sched_cfs_bandwidth_slice_us = 5000

CATATAN: variable yang di akhiri dengan “_ns” dan “_us” menerima nilai dalam nanosecond dan microsecond.

Dafta dari variable yang paling penting untuk di tuning pada task scheduler terdapat pada /proc/sys/kernel/ dengan penjelasan pendek berikut:

sched_child_runs_first

Fork child dijalankan sebelum parent meneruskan eksekusi. Menset parameter ini menjadi 1 akan menguntungkan untuk aplikasi dimana child menjalankan eksekusi setelah fork. Contoh, make -j <JUMLAH-CPU> akan lebih baik jika sched_child_runs_first dimatikan.

Default adalah 0.

sched_compat_yield

Akan mengaktifkan perilaku yield dari scheduler 0(1) lebih agresif . Aplikasi Java yang secara ekstensif melakukan sinkronisasi akan berjalan lebih baik jika nilai ini di set ke 1. Hanya gunakan ini jika kita melihat drop dalam performance.

Default adalah 0.

Aplikasi yang bergantung pada perilaku syscall sched_yield() akan berjalan lebih baik jika nilai di set menjadi 1.

sched_migration_cost

Lama waktu sesudah eksekusi terakhir dimana sebuah task akan di perhitungkan sebagai "cache hot" dalam keputusan untuk migrasi / perubahan. Sebuah "hot" task akan kemungkinan kecil untuk di migrasi, oleh karenanya menaikan nilai variabel ini akan menurunkan migrasi task.

Default adalah 500000 (ns).

Jika waktu idle CPU lebih tinggi dari yang diharapkan jika ada proses yang bisa di jalankan, coba kecilkan nilai ini. Jika task bounce antara CPU atau node terlalu sering, coba naikan nilai ini.

sched_latency_ns -

Latency preemtion yang di ijinkan untuk task CPU bound. Menaikan nilai variable ini akan menaikan task CPU bound timeslice. Task timeslice diberi bobot pembagi secara fair dalam perioda scheduling: 

timeslice = scheduling period * (bobot task/total bobot task di antrian run)

Bobot task tergantung pada level nice task dan kebijakan scheduling. Bobot minimal task untuk task SCHED_OTHER adalah 15, ini sama dengan nice 19. Bobot maximum task adalah 88761, ini sama dengan nice -20.

Semakin kecil timeslice maka load CPU naik. Jika jumlah task yang akan di jalankan melebihi sched_latency_ns/sched_min_granularity_ns, maka timeslice akan menjadi number_of_running_tasks * sched_min_granularity_ns. Sebelum itu terjadi, timeslice akan sama sched_latency_ns.

Nilai ini pada dasarnya mengatur jumlah waktu maksimum untuk sebuah task yang sedang sleeping untuk di perhitungkan dalam kalkulasi ijin run. Menaikan nilai ini akan menaikan jumlah waktu bagi task yang bangun yang dapat di gunakan sebelum di preempted, ini akhirnya akan menaikan scheduler latency untuk task yang CPU bound.

Nilai Default adalah 20000000 (ns).

sched_min_granularity_ns

Minimal preemption granularitas untuk task CPU bound. Baca-baca sched_latency_ns untuk lebih detail.

Nilai default adalah 4000000 (ns).

sched_wakeup_granularity_ns

Granularitas preemption untuk wake-up (bangun). Menaikan nilai variable ini akan mengurangi preemption wake-up, menggurangi gangguan bagi task yang banyak melakukan perhitungan. Menurunkan nilai ini akan memperbaiki latency wake-up dan throughput untuk task penting, terutama jika komponen dengan beban pendek harus berkompetisi dengan komponen CPU bound.

Nilai default adalah 5000000 (ns).

WARNING: Menset lebih besar dari setengah sched_latency_ns akan menyebabkan zero wake-up preemption dan task pendek akan tidak bisa berkompetisi secara effektif dengan task yang memakan CPU.


sched_rt_period_us

Perioda dimana pelaksanaan task real-time di ukur.

Nilai default adalah 1000000 (µs).

sched_rt_runtime_us

Alokasi waktu untuk task real-time (RT) saat sched_rt_period_us. Menset menjadi -1 akan men-disable pelaksanaan waktu real-time (RT).

Nilai default, task real-time (RT) akan mengkonsumsi 95% CPU/detik, oleh karenanya hanya akan menyisakan 5% CPU/detik atau 0.05s untuk digunakan oleh task SCHED_OTHER.

sched_features

Memberikan informasi tentang fitur debugging yang spesifik.


sched_stat_granularity_ns

Menentukan granularitas untuk pengumpulan statistik task scheduler.

sched_nr_migrate

Mengatur berapa task yang dapat di pindahkan antar processor melalui interupsi software migrasi (softirq). Jika sebagian besar task dibuat oleh kebijakan SCHED_OTHER, mereka semua biasakan akan jalan di processor yang sama.

Nilai default adalah 32.

Menaikan nilai ini biasakan akan menaikan performance untuk thread besar pada SCHED_OTHER dengan mengorbankan latency yang lebih tinggi untuk task yang real-time.

Interface Debugging dan Statistik Scheduler

CFS digunakan dengan interface debugging yang baru, dan dapat memberikan informasi statiktik runtime. File yang relevan ada di directory /proc, yang dapat di pelajari hanya dengan printah cat atau less. Sedikit tentang file /proc dan penjelasan pendeknya:

/proc/sched_debug

Berisi nilai saat ini dari semua variabel yang dapat di tuning yang akan mempengaruhi perilaku task scheduler, CFS statistik, dan informasi tentang antrian run di semua processor yang tersedia. 

less /proc/sched_debug

Hasilnya kira-kira 

Sched Debug Version: v0.10, 3.2.0-29-generic #46-Ubuntu
ktime                                   : 175814713.744739
sched_clk                               : 152754753.141005
cpu_clk                                 : 175814713.743515
jiffies                                 : 4338845974
sched_clock_stable                      : 0

sysctl_sched
  .sysctl_sched_latency                    : 12.000000
  .sysctl_sched_min_granularity            : 1.500000
  .sysctl_sched_wakeup_granularity         : 2.000000
  .sysctl_sched_child_runs_first           : 0
  .sysctl_sched_features                   : 24119
  .sysctl_sched_tunable_scaling            : 1 (logaritmic)

cpu#0, 1296.721 MHz
  .nr_running                    : 2
  .load                          : 771
  .nr_switches                   : 1394812584
  .nr_load_updates               : 16371163
  .nr_uninterruptible            : 795487
  .next_balance                  : 4338.846000
  .curr->pid                     : 4702
  .clock                         : 175814713.750402
  .cpu_load[0]                   : 1024
  .cpu_load[1]                   : 984
  .cpu_load[2]                   : 1048
  .cpu_load[3]                   : 1120
  .cpu_load[4]                   : 1172
  .yld_count                     : 310677
  .sched_switch                  : 0
  .sched_count                   : 1400427770
  .sched_goidle                  : 526715556
  .avg_idle                      : 190439
  .ttwu_count                    : 1213620697
  .ttwu_local                    : 693494658 

cfs_rq[0]:/autogroup-108
  .exec_clock                    : 1084323.602095
  .MIN_vruntime                  : 0.000001
  .min_vruntime                  : 1084318.510901
  .max_vruntime                  : 0.000001
  .spread                        : 0.000000
  .spread0                       : -38610036.626370
  .nr_spread_over                : 0
  .nr_running                    : 0
  .load                          : 0
  .load_avg                      : 2705.524480
.....
rt_rq[0]:/
  .rt_nr_running                 : 0
  .rt_throttled                  : 0
  .rt_time                       : 0.000000
  .rt_runtime                    : 950.000000

runnable tasks:
            task   PID         tree-key  switches  prio     exec-runtime         sum-exec        sum-sleep
----------------------------------------------------------------------------------------------------------
          compiz  2710  24446058.117120   9422853   120  24446058.117120   1192860.567985 173953317.232879 /autogroup-133
R        firefox  4688  24446057.988583  84022061   120  24446057.988583  40996425.370526 131036496.584050 /autogroup-133

/proc/schedstat

Menampilkan statistik relevan terhadap run queue saat itu. Juga domain-spesifik statistik dari sistem SMP untuk semua prosesor yang tersambung. Karena format output tidak terlalu user-friendly, untuk informasi lebih lanjut ada baiknya baca 

more /usr/src/linux/Documentation/scheduler/sched-stats.txt

Untuk melihat informasi lebih detail untuk sebuah Proses ID (PID), ketik, 

less /proc/PID/sched

misalnya jika ada proses 10485, ketik 

less /proc/10485/sched

Akan keluar seperti 

rsync (10485, #threads: 1)
---------------------------------------------------------
se.exec_start                      :     176371611.333607
se.vruntime                        :       2627563.353534
se.sum_exec_runtime                :        141516.884079
se.statistics.wait_start           :             0.000000
se.statistics.sleep_start          :             0.000000
se.statistics.block_start          :     176371611.333607
se.statistics.sleep_max            :         60060.014521
.....
se.statistics.nr_wakeups_affine_attempts:              1910947
se.statistics.nr_wakeups_passive   :                    0
se.statistics.nr_wakeups_idle      :                    0
avg_atom                           :             0.038524
avg_per_cpu                        :             0.268959
nr_switches                        :              3677210
nr_voluntary_switches              :              3631250
nr_involuntary_switches            :                45960
se.load.weight                     :                 1024
policy                             :                    0
prio                               :                  120
clock-delta                        :                  150

Informasi Lebih Lanjut

Baca informasi tentang task scheduler di file di bawah /usr/src/linux/Documentation/scheduler

Referensi

Pranala Menarik

Secara Umum

Instalasi Linux

Compile Kernel

Remaster Linux

Sistem Operasi untuk Embedded

Membuat Firmware Sendiri

Flash ke Device

Beberapa Tip

Tuning Kernel

Tuning Kernel Scheduler

Tuning I/O Scheduler

Tuning Manajemen Memory

Android

Membuat Kernel Module

Monitoring & Benchmark

Retrieved from "https://onnocenter.or.id/wiki/index.php?title=OS:_Complete_Teori_Tuning_Kernel_Scheduler&oldid=36540"