enkiTS
v1.11 Breaking C API change to Completion Actions - added Pre and Post completion functions
Dukungan Pengembangan Enkit melalui Sponsor GitHub atau Patreon
Penjadwal tugas C dan C ++ berlisensi secara permisif untuk membuat program paralel. Membutuhkan dukungan C ++ 11.
Tujuan utama Enkit adalah untuk membantu pengembang membuat program yang menangani data paralelisme data dan tingkat tugas untuk memanfaatkan kinerja penuh CPU multicore, sementara menjadi ringan (hanya sejumlah kecil kode) dan mudah digunakan.
Enkit dikembangkan untuk, dan digunakan dalam basis kode Avoyd Enkisoftware.
Enkits terutama dikembangkan pada arsitektur Intel x64 dan x86 pada Windows MS, dengan dukungan yang diuji dengan baik untuk Linux dan dukungan yang agak jarang diuji pada Mac OS dan ARM Android.
Ada beberapa contoh di folder contoh.
Untuk contoh lebih lanjut, lihat https://github.com/dougbinks/enkitsexamples
Building Enkits sederhana, cukup tambahkan file di Enkits/SRC ke sistem build Anda (_C.* File dapat diabaikan jika Anda hanya memerlukan antarmuka C ++), dan tambahkan Enkit/SRC ke jalur termasuk Anda. Unix / Linux Build kemungkinan akan membutuhkan pustaka Pthreads.
Untuk C ++
#include "TaskScheduler.h"TaskScheduler.cppUntuk c
#include "TaskScheduler_c.h"TaskScheduler.cppTaskScheduler_c.cppUntuk CMake, pada Windows / Mac OS X / Linux dengan CMake diinstal, buka prompt di direktori Enkits dan:
mkdir buildcd buildcmake ..make all atau untuk Visual Studio Open enkiTS.sln Saya sarankan menggunakan Enkit langsung dari sumber di setiap proyek daripada menginstalnya untuk penggunaan sistem yang luas. Namun skrip CMake Enkits juga dapat digunakan untuk menginstal pustaka jika variabel CMake ENKITS_INSTALL diatur ke ON (default untuk OFF ).
Ketika diinstal file header diinstal dalam subdirektori jalur include, include/enkiTS untuk memastikan bahwa mereka tidak bertentangan dengan file header dari paket lain. Saat membangun aplikasi, memastikan ini adalah bagian dari variabel INCLUDE_PATH atau memastikan bahwa Enkit berada di jalur header di file sumber, misalnya menggunakan #include "enkiTS/TaskScheduler.h" alih -alih #include "TaskScheduler.h" .
#include "TaskScheduler.h"
enki:: TaskScheduler g_TS ;
// define a task set, can ignore range if we only do one thing
struct ParallelTaskSet : enki :: ITaskSet {
void ExecuteRange ( enki :: TaskSetPartition range_ , uint32_t threadnum_ ) override {
// do something here, can issue tasks with g_TS
}
};
int main ( int argc , const char * argv []) {
g_TS . Initialize ();
ParallelTaskSet task ; // default constructor has a set size of 1
g_TS . AddTaskSetToPipe ( & task );
// wait for task set (running tasks if they exist)
// since we've just added it and it has no range we'll likely run it.
g_TS . WaitforTask ( & task );
return 0 ;
} #include "TaskScheduler.h"
enki:: TaskScheduler g_TS ;
int main ( int argc , const char * argv []) {
g_TS . Initialize ();
enki:: TaskSet task ( 1 , []( enki :: TaskSetPartition range_ , uint32_t threadnum_ ) {
// do something here
} );
g_TS . AddTaskSetToPipe ( & task );
g_TS . WaitforTask ( & task );
return 0 ;
} // See full example in Priorities.cpp
#include "TaskScheduler.h"
enki:: TaskScheduler g_TS ;
struct ExampleTask : enki :: ITaskSet
{
ExampleTask ( ) { m_SetSize = size_ ; }
void ExecuteRange ( enki :: TaskSetPartition range_ , uint32_t threadnum_ ) override {
// See full example in Priorities.cpp
}
};
// This example demonstrates how to run a long running task alongside tasks
// which must complete as early as possible using priorities.
int main ( int argc , const char * argv [])
{
g_TS . Initialize ();
ExampleTask lowPriorityTask ( 10 );
lowPriorityTask . m_Priority = enki :: TASK_PRIORITY_LOW ;
ExampleTask highPriorityTask ( 1 );
highPriorityTask . m_Priority = enki :: TASK_PRIORITY_HIGH ;
g_TS . AddTaskSetToPipe ( & lowPriorityTask );
for ( int task = 0 ; task < 10 ; ++ task )
{
// run high priority tasks
g_TS . AddTaskSetToPipe ( & highPriorityTask );
// wait for task but only run tasks of the same priority or higher on this thread
g_TS . WaitforTask ( & highPriorityTask , highPriorityTask . m_Priority );
}
// wait for low priority task, run any tasks on this thread whilst waiting
g_TS . WaitforTask ( & lowPriorityTask );
return 0 ;
} #include "TaskScheduler.h"
enki:: TaskScheduler g_TS ;
// define a task set, can ignore range if we only do one thing
struct PinnedTask : enki :: IPinnedTask {
void Execute () override {
// do something here, can issue tasks with g_TS
}
};
int main ( int argc , const char * argv []) {
g_TS . Initialize ();
PinnedTask task ; //default constructor sets thread for pinned task to 0 (main thread)
g_TS . AddPinnedTask ( & task );
// RunPinnedTasks must be called on main thread to run any pinned tasks for that thread.
// Tasking threads automatically do this in their task loop.
g_TS . RunPinnedTasks ();
// wait for task set (running tasks if they exist)
// since we've just added it and it has no range we'll likely run it.
g_TS . WaitforTask ( & task );
return 0 ;
} #include "TaskScheduler.h"
enki:: TaskScheduler g_TS ;
// define a task set, can ignore range if we only do one thing
struct TaskA : enki :: ITaskSet {
void ExecuteRange ( enki :: TaskSetPartition range_ , uint32_t threadnum_ ) override {
// do something here, can issue tasks with g_TS
}
};
struct TaskB : enki :: ITaskSet {
enki:: Dependency m_Dependency ;
void ExecuteRange ( enki :: TaskSetPartition range_ , uint32_t threadnum_ ) override {
// do something here, can issue tasks with g_TS
}
};
int main ( int argc , const char * argv []) {
g_TS . Initialize ();
// set dependencies once (can set more than one if needed).
TaskA taskA ;
TaskB taskB ;
taskB . SetDependency ( taskB . m_Dependency , & taskA );
g_TS . AddTaskSetToPipe ( & taskA ); // add first task
g_TS . WaitforTask ( & taskB ); // wait for last
return 0 ;
} #include "TaskScheduler.h"
enki:: TaskScheduler g_TS ;
struct ParallelTaskSet : ITaskSet
{
void ExecuteRange ( enki :: TaskSetPartition range_ , uint32_t threadnum_ ) override {
// Do something
}
};
void threadFunction ()
{
g_TS . RegisterExternalTaskThread ();
// sleep for a while instead of doing something such as file IO
std::this_thread::sleep_for( std ::chrono:: milliseconds ( num_ * 100 ) );
ParallelTaskSet task ;
g_TS . AddTaskSetToPipe ( & task );
g_TS . WaitforTask ( & task );
g_TS . DeRegisterExternalTaskThread ();
}
int main ( int argc , const char * argv [])
{
enki:: TaskSchedulerConfig config ;
config . numExternalTaskThreads = 1 ; // we have one extra external thread
g_TS . Initialize ( config );
std:: thread exampleThread ( threadFunction );
exampleThread . join ();
return 0 ;
}# include " TaskScheduler.h "
enki::TaskScheduler g_TS;
struct RunPinnedTaskLoopTask : enki::IPinnedTask
{
void Execute () override
{
while ( !g_TS. GetIsShutdownRequested () )
{
g_TS. WaitForNewPinnedTasks (); // this thread will 'sleep' until there are new pinned tasks
g_TS. RunPinnedTasks ();
}
}
};
struct PretendDoFileIO : enki::IPinnedTask
{
void Execute () override
{
// Do file IO
}
};
int main ( int argc, const char * argv[])
{
enki::TaskSchedulerConfig config;
// In this example we create more threads than the hardware can run,
// because the IO thread will spend most of it's time idle or blocked
// and therefore not scheduled for CPU time by the OS
config. numTaskThreadsToCreate += 1 ;
g_TS. Initialize ( config );
// in this example we place our IO threads at the end
RunPinnedTaskLoopTask runPinnedTaskLoopTasks;
runPinnedTaskLoopTasks. threadNum = g_TS. GetNumTaskThreads () - 1 ;
g_TS. AddPinnedTask ( &runPinnedTaskLoopTasks );
// Send pretend file IO task to external thread FILE_IO
PretendDoFileIO pretendDoFileIO;
pretendDoFileIO. threadNum = runPinnedTaskLoopTasks. threadNum ;
g_TS. AddPinnedTask ( &pretendDoFileIO );
// ensure runPinnedTaskLoopTasks complete by explicitly calling shutdown
g_TS. WaitforAllAndShutdown ();
return 0 ;
}Cabang C ++ 98 yang kompatibel telah digunakan karena saya tidak menyadari ada orang yang membutuhkannya.
Versi utas pengguna tidak lagi dipertahankan karena tidak lagi digunakan. Fungsi yang serupa dapat diperoleh dengan ExternalTaskThreads
Avoyd adalah permainan abstrak 6 derajat Freedom Voxel. Enkit dikembangkan untuk digunakan di mesin in-house kami yang memberi daya pada Avoyd.
Generator tekstur GPU/CPU
Kode Aras Pranckevičius untuk serialnya di jalur pelacak jalur harian dengan berbagai bahasa.
.
Buku Marco Castorina dan Gabriel Sassone tentang pengembangan mesin rendering modern dari prinsip -prinsip pertama menggunakan API Vulkan. Enkit digunakan sebagai perpustakaan tugas untuk mendistribusikan pekerjaan di seluruh inti.
Hak Cipta (C) 2013-2020 Doug Binks
Perangkat lunak ini disediakan 'Aib adanya', tanpa garansi tersirat atau tersirat. Dalam hal apa pun penulis tidak akan bertanggung jawab atas segala kerusakan yang timbul dari penggunaan perangkat lunak ini.
Izin diberikan kepada siapa pun untuk menggunakan perangkat lunak ini untuk tujuan apa pun, termasuk aplikasi komersial, dan untuk mengubahnya dan mendistribusikannya secara bebas, tunduk pada pembatasan berikut:
