enkiTS

สนับสนุนการพัฒนาของ Enkits ผ่านผู้สนับสนุน GitHub หรือ Patreon

ตัวกำหนดตารางงานของ Enki

ตัวกำหนดตารางเวลางาน C และ C ++ ที่ได้รับอนุญาตสำหรับการสร้างโปรแกรมแบบขนาน ต้องการการสนับสนุน C ++ 11

เป้าหมายหลักของ enkits คือการช่วยให้นักพัฒนาสร้างโปรแกรมที่จัดการทั้งข้อมูลและระดับความเท่าเทียมกันในระดับงานเพื่อใช้ประสิทธิภาพเต็มรูปแบบของซีพียูมัลติคอร์ในขณะที่มีน้ำหนักเบา (มีรหัสเพียงเล็กน้อย) และใช้งานง่าย

• C ++ API ผ่าน src/taskscheduler.h
• c api ผ่าน src/taskscheduler_c.h

Enkits ได้รับการพัฒนาและใช้ใน Avoyd Codebase ของ Enkisoftware

แพลตฟอร์ม

• Windows, Linux, Mac OS, Android (ควรทำงานบน iOS)
• x64 & x86, แขน

Enkits ได้รับการพัฒนาเป็นหลักในสถาปัตยกรรม X64 และ X86 Intel บน MS Windows พร้อมการสนับสนุนที่ดีสำหรับ Linux และการสนับสนุนที่ผ่านการทดสอบบ่อยครั้งบน Mac OS และ ARM Android

ตัวอย่าง

มีหลายตัวอย่างในโฟลเดอร์ตัวอย่าง

สำหรับตัวอย่างเพิ่มเติมดูที่ https://github.com/dougbinks/enkitsexamples

อาคาร

การสร้าง Enkits นั้นง่ายเพียงเพิ่มไฟล์ใน Enkits/SRC ในระบบบิลด์ของคุณ (_c.* ไฟล์สามารถถูกละเว้นได้หากคุณต้องการอินเตอร์เฟส C ++ เท่านั้น) และเพิ่ม Enkits/SRC ลงในเส้นทางรวมของคุณ การสร้าง UNIX / LINUX อาจต้องใช้ไลบรารี PTHREADS

สำหรับ C ++

• ใช้ #include "TaskScheduler.h"
• เพิ่ม enkits/src ไปยังเส้นทางรวมของคุณ
• รวบรวม / เพิ่มในโครงการ:
  • TaskScheduler.cpp
• การสร้าง UNIX / LINUX อาจต้องใช้ไลบรารี PTHREADS

สำหรับ C

• ใช้ #include "TaskScheduler_c.h"
• เพิ่ม enkits/src ไปยังเส้นทางรวมของคุณ
• รวบรวม / เพิ่มในโครงการ:
  • TaskScheduler.cpp
  • TaskScheduler_c.cpp
• การสร้าง UNIX / LINUX อาจต้องใช้ไลบรารี PTHREADS

สำหรับ CMake บน Windows / Mac OS X / Linux ที่ติดตั้ง CMake เปิดให้บริการในไดเรกทอรี Enkits และ::

1. mkdir build
2. cd build
3. cmake ..
4. Run make all หรือสำหรับ Visual Studio Open enkiTS.sln

คุณสมบัติโครงการ

1. Lightweight - Enkits ได้รับการออกแบบให้มีความเอนเอียงเพื่อให้คุณสามารถใช้งานได้ทุกที่ได้อย่างง่ายดายและเข้าใจ
2. เร็วและปรับขนาดได้ - Enkits ได้รับการออกแบบมาสำหรับอุปกรณ์ผู้บริโภคก่อนดังนั้นประสิทธิภาพของเธรดจำนวนน้อยจึงมีความสำคัญตามด้วยความสามารถในการปรับขนาด
3. Parallelism Braided - Enkits สามารถออกงานจากงานอื่นรวมถึงจากเธรดที่สร้างระบบงานและมีส่วนต่อประสานงานง่าย ๆ สำหรับทั้งข้อมูลขนานและคู่ขนานงาน
4. การจัดสรรล่วงหน้าเป็นมิตร - Enkits ได้รับการออกแบบมาสำหรับการจัดสรรเป็นศูนย์ระหว่างการกำหนดเวลา
5. สามารถตรึงงานกับเธรดที่กำหนด - Enkits สามารถกำหนดเวลางานที่จะทำงานบนเธรดที่ระบุเท่านั้น
6. สามารถตั้งค่าลำดับความสำคัญของงาน - สามารถกำหนดค่าลำดับความสำคัญของงานได้สูงสุด 5 รายการผ่าน define enkits_task_priorities_num (ค่าเริ่มต้นเป็น 3) งานลำดับความสำคัญที่สูงขึ้นจะทำงานก่อนที่จะมีลำดับความสำคัญต่ำกว่า
7. สามารถลงทะเบียนเธรดภายนอกเพื่อใช้กับ Enkits - สามารถกำหนดค่า enkits ด้วย numexternaltaskthreads ซึ่งสามารถลงทะเบียนเพื่อใช้กับ Enkits API
8. Custom Allocator API - สามารถกำหนดค่า enkits ด้วยการจัดสรรแบบกำหนดเองดูตัวอย่าง/customallocator.cpp และตัวอย่าง/customallocator_c.c
9. การพึ่งพา - สามารถตั้งค่าการพึ่งพาระหว่างงานดูตัวอย่าง/การพึ่งพา.CPPและตัวอย่าง/การอ้างอิง _C.C
10. การกระทำที่เสร็จสมบูรณ์ - สามารถดำเนินการเกี่ยวกับการทำงานให้เสร็จสมบูรณ์ สิ่งนี้จะหลีกเลี่ยงการกระทำที่มีราคาแพงในการเพิ่มงานลงในตารางเวลาและสามารถใช้เพื่อลบงานที่เสร็จสมบูรณ์ได้อย่างปลอดภัย ดูตัวอย่าง/completeionAction.cpp และตัวอย่าง/completeionaction_c.c
11. ใหม่ สามารถรองานที่ถูกตรึง - สามารถรองานที่ถูกตรึงซึ่งมีประโยชน์สำหรับการสร้างเธรด IO ที่ไม่มีงานอื่น ดูตัวอย่าง/WaitForNewPinnedTasks.cpp และตัวอย่าง/WaitforNewPinnedTasks_C.C

การติดตั้ง

ฉันขอแนะนำให้ใช้ enkits โดยตรงจากแหล่งที่มาในแต่ละโครงการแทนที่จะติดตั้งเพื่อใช้งานระบบกว้าง อย่างไรก็ตามสคริปต์ cmake ของ Enkits สามารถใช้ในการติดตั้งไลบรารีได้หากตัวแปร cmake ENKITS_INSTALL ถูกตั้งค่าเป็น ON (ค่าเริ่มต้นเป็น OFF )

เมื่อติดตั้งไฟล์ส่วนหัวจะถูกติดตั้งในไดเรกทอรีย่อยของเส้นทางรวม include/enkiTS เพื่อให้แน่ใจว่าพวกเขาจะไม่ขัดแย้งกับไฟล์ส่วนหัวจากแพ็คเกจอื่น ๆ เมื่อสร้างแอปพลิเคชันให้แน่ใจว่านี่เป็นส่วนหนึ่งของตัวแปร INCLUDE_PATH หรือตรวจสอบให้แน่ใจว่า enkits อยู่ในเส้นทางส่วนหัวในไฟล์ต้นฉบับเช่นใช้ #include "enkiTS/TaskScheduler.h" แทน #include "TaskScheduler.h"

ใช้ enkits

การใช้งาน C ++

• ตัวอย่างเต็มในตัวอย่าง/parallelesum.cpp
• c ตัวอย่างในตัวอย่าง/parallelsum_c.c

 #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 ;
}

C ++ 11 การใช้งานแลมบ์ดา

• ตัวอย่างเต็มในตัวอย่าง/lambdatask.cpp

 #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 ;
}

ลำดับความสำคัญของงานใช้ใน C ++

• ตัวอย่างเต็มในตัวอย่าง/ลำดับความสำคัญ cpp
• c ตัวอย่างในตัวอย่าง/priorities_c.c

 // 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 ;
}

การใช้งานที่ตรึงใน C ++

• ตัวอย่างเต็มในตัวอย่าง/pinnedtask.cpp
• c ตัวอย่างในตัวอย่าง/pinnedtask_c.c

 #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 ;
}

การใช้การพึ่งพาใน C ++

• ตัวอย่างเต็มในตัวอย่าง/การพึ่งพา
• c ตัวอย่างในตัวอย่าง/การพึ่งพา _c.c

 #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 ;
}

การใช้เธรดงานภายนอกใน C ++

• ตัวอย่างเต็มในตัวอย่าง/externaltaskthread.cpp
• c ตัวอย่างในตัวอย่าง/externaltaskthread_c.c

 #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 ;
}

WaitforpinnedTasks การใช้ด้ายใน C ++ (มีประโยชน์สำหรับเธรด IO)

• ตัวอย่างเต็มในตัวอย่าง/WaitforNewPinnedTasks.cpp
• c ตัวอย่างในตัวอย่าง/waitfornewpinnedtasks_c.c

# 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 ;
}

การผูกมัด

• c# enkitasks c#

ซึ่งเลิกใช้แล้ว

สาขาที่เข้ากันได้ของ C ++ 98 ได้เลิกใช้แล้วเนื่องจากฉันไม่ทราบว่ามีใครต้องการ

รุ่นเธรดผู้ใช้จะไม่ได้รับการดูแลอีกต่อไปเนื่องจากไม่ได้ใช้งานอีกต่อไป ฟังก์ชั่นที่คล้ายกันสามารถรับได้ด้วย externaltaskthreads

• เวอร์ชันเธรดผู้ใช้บน Branch UserThread สำหรับการเรียกใช้ enkits บนระบบการทำงาน / เธรดอื่น ๆ ดังนั้นจึงสามารถใช้เช่นเดียวกับในเครื่องยนต์อื่น ๆ เช่นเดียวกับแบบสแตนด์อโลน
• C ++ 11 รุ่นของเธรดผู้ใช้บน Branch UserThread_c ++ 11

โครงการที่ใช้ Enkits

Avoyd

Avoyd เป็นเกม Freedom Voxel ที่เป็นนามธรรม 6 องศา Enkits ได้รับการพัฒนาเพื่อใช้ใน Avoyd เครื่องยนต์ภายในของเรา

Imogen

เครื่องกำเนิดพื้นผิว GPU/CPU

toypathracer

รหัส Aras Pranckevičius 'สำหรับซีรี่ส์ของเขาในการทดลอง Daily Path Tracer ด้วยภาษาต่างๆ

-

การเขียนโปรแกรมกราฟิกกับ Vulkan

Marco Castorina และหนังสือของ Gabriel Sassone เกี่ยวกับการพัฒนากลไกการเรนเดอร์ที่ทันสมัยจากหลักการแรกโดยใช้ Vulkan API Enkits ใช้เป็นไลบรารีงานเพื่อแจกจ่ายงานข้ามแกน

ใบอนุญาต (zlib)

ลิขสิทธิ์ (c) 2013-2020 Doug Binks

ซอฟต์แวร์นี้มีให้ 'เป็น' โดยไม่มีการรับประกันโดยชัดแจ้งหรือโดยนัย ไม่ว่าในกรณีใดผู้เขียนจะต้องรับผิดชอบต่อความเสียหายใด ๆ ที่เกิดขึ้นจากการใช้ซอฟต์แวร์นี้

ได้รับอนุญาตให้ทุกคนใช้ซอฟต์แวร์นี้เพื่อวัตถุประสงค์ใด ๆ รวมถึงแอปพลิเคชันเชิงพาณิชย์และเพื่อแก้ไขและแจกจ่ายซ้ำได้อย่างอิสระภายใต้ข้อ จำกัด ดังต่อไปนี้:

1. ที่มาของซอฟต์แวร์นี้จะต้องไม่ถูกบิดเบือน คุณต้องไม่อ้างว่าคุณเขียนซอฟต์แวร์ดั้งเดิม หากคุณใช้ซอฟต์แวร์นี้ในผลิตภัณฑ์การรับทราบในเอกสารประกอบผลิตภัณฑ์จะได้รับการชื่นชม แต่ไม่จำเป็น
2. เวอร์ชันแหล่งที่เปลี่ยนแปลงจะต้องทำเครื่องหมายไว้อย่างชัดเจนและจะต้องไม่ถูกบิดเบือนว่าเป็นซอฟต์แวร์ดั้งเดิม
3. ประกาศนี้อาจไม่ถูกลบหรือเปลี่ยนแปลงจากการกระจายแหล่งใด ๆ