Apakah ada sistem build yang memasukkan waktu tugas yang diperkirakan relatif ke dalam jadwal?

Inilah ilustrasi kecil dari pertanyaan saya:

Asumsikan sebuah pekerjaan build yang terdiri dari 4 tugas independen bernama AD. D membutuhkan waktu lebih lama daripada AC.

Sistem build yang tidak dapat menggabungkan waktu tugas relatif mungkin menjadwalkan tugas-tugas seperti ini:

---------------------------------------
CPU1: A  |    C   |
---------------------------------------
CPU2: B    | D                        |
---------------------------------------

Sebaliknya, jika penjadwal mengetahui perbedaan waktu tugas, itu bisa muncul dengan jadwal yang jauh lebih pendek ini:

---------------------------------------
CPU1: A  |  B    |   C   |
---------------------------------------
CPU2: D                        |
---------------------------------------

Pertanyaan saya:

1. Apakah ada sistem build yang memasukkan waktu tugas yang diperkirakan relatif ke dalam jadwal?
2. Penelitian akademis apa yang membangun sistem semacam ini ada?
3. Di mana sistem pembangunan ini (jika ada) mengambil informasi waktu? Heuristik, timing yang dikumpulkan selama build sebelumnya?
4. Jika sistem pembangunan seperti itu tidak ada, mengapa? Apakah ada gotcha yang akan membuat mereka kurang berharga daripada yang terlihat pada pandangan pertama?

Microsoft Visual Studio Team System (sebelumnya TFS) tidak mempertimbangkan waktu tindakan build dan build paralel; dibutuhkan data dari riwayat build sebelumnya; dan sementara saya tidak percaya Anda bisa mendapatkan perilaku yang Anda inginkan di luar kotak, Anda mungkin dapat menyesuaikannya.

Contoh beberapa tugas khusus untuk mengoptimalkan kinerja

https://veegens.wordpress.com/2013/03/26/tfs-2010-build-performance-report/

Ini didasarkan pada asumsi yang salah bahwa "membangun" suatu tugas adalah tidak paralel.

Banyak kompiler bekerja multi-threaded, jadi satu tugas A akan menggunakan semua CPU. Oleh karena itu, pesanannya tidak masalah. Untuk tugas-tugas terikat I / O, terutama yang melibatkan jaringan, lebih baik memulai semuanya secara paralel dari awal juga: sebagian besar waktu akan dihabiskan menunggu jawaban.

Dengan kata lain, pemesanan tidak menjadi masalah karena tugas-tugas individu biasanya diparalelkan (seperti mengkompilasi misalnya)

Edit:

Sebenarnya, konsep "Tugas A pada CPU 1" ini juga cacat. Bahkan untuk tugas berulir tunggal, penjadwalan OS proses / utas dapat melompat dari CPU ke CPU pada setiap konteks switch. Saya kira kebanyakan sistem build hanya akan menjalankan semua tugas secara paralel dan membiarkan OS melakukan penjadwalan. Tugas yang lebih lama akan memakan waktu lebih lama dan itu saja.

Dengan asumsi Anda memiliki tugas ulir tunggal berjalan lama yang tidak terikat I / O , akan lebih mudah bagi sistem build untuk menetapkan prioritas / kepentingan daripada mencoba untuk menunda tugas yang lebih kecil untuk mengurangi konteks switch dari OS.

Sekalipun Anda memiliki tugas aneh seperti itu , yang jarang terjadi dalam praktiknya, dan memiliki sistem pembuatan penjadwalan mewah yang bekerja berdasarkan heuristik berdasarkan proses sebelumnya (satu-satunya cara untuk mengetahui), manfaat yang Anda dapatkan dari itu mungkin agak kecil .. . Bagaimanapun Anda mendapatkan banyak kerumitan tambahan untuk dipelihara.