首页>编程相关>C#源码
下载

通过GitHub赞助商或Patreon来支持Enkits的开发

建立分支的状态：开发人员

ENKI任务调度程序

用于创建并行程序的允许许可的C和C ++任务调度程序。需要C ++ 11支持。

ENKIT的主要目标是帮助开发人员创建处理数据和任务级别并行性的程序，以利用多核CPU的全部性能，同时轻巧（仅少量代码）且易于使用。

  • C ++ API通过src/taskscheduler.h
  • c api通过src/taskscheduler_c.h

Enkits是为Enkisoftware的Avoyd Codebase开发的。

平台

  • Windows，Linux，Mac OS，Android（应在iOS上使用）
  • x64＆x86，手臂

Enkits主要是在MS Windows上的X64和X86 Intel架构上开发的，对Linux的测试支持进行了经过良好测试，并且在Mac OS和ARM Android上进行了较少测试的支持。

例子

示例文件夹中存在几个示例。

有关进一步的示例，请参见https://github.com/dougbinks/enkitsexamples

建筑

构建enkit很简单，只需将enkit/src中的文件添加到您的构建系统（_C。*如果您只需要C ++接口，就可以忽略文件），然后将enkits/src添加到您的INCLUCE路径。 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，在安装CMAKE的Windows / Mac OS X / Linux上，在Enkits目录中打开一个提示

  1. mkdir build
  2. cd build
  3. cmake ..
  4. 运行make all或用于Visual Studio Open enkiTS.sln

项目功能

  1. 轻量级- Enkits设计为瘦身，因此您可以轻松地使用它并理解它。
  2. 快速，然后可扩展- enkits首先是为消费设备设计的，因此在较低的线程上的性能很重要，其次是可扩展性。
  3. 编织的并行性- Enkits可以从另一个任务以及创建任务系统的线程中发布任务，并具有简单的任务接口，用于数据并行和任务并行性。
  4. 前期分配友好- ENKITS是在安排期间为零分配而设计的。
  5. 可以将任务固定到给定的线程- Enkits可以安排仅在指定线程上运行的任务。
  6. 可以设置任务优先级- 最多可以通过define enkits_task_priorities_num（默认为3）来配置最多5个任务优先级。更高的优先任务是在较低的优先级之前运行的。
  7. 可以注册用于与Enkits一起使用的外部线程- 可以用NumexternalTask​​Threads配置Enkits，可以注册以与Enkits API一起使用。
  8. 自定义分配器API-可以使用自定义分配器配置ENKIT，请参见示例/customallocator.cpp和example/customallocator_c.c.c。
  9. 依赖项- 可以在任务之间设置依赖项，请参见示例/依赖项.cpp和example/dependencies_c.c。
  10. 完成操作- 可以对任务完成执行动作。这避免了将任务添加到调度程序的昂贵动作，并且可以用来安全删除完成的任务。请参阅示例/ploteionAction.cpp和example/ploteionAction_c.c.c
  11. 新的可以等待固定任务- 可以等待固定任务，这对于创建没有其他工作的IO线程很有用。请参阅示例/waitfornewpinnedtasks.cpp和example/waitfornewpinnedtasks_c.c。

安装

我建议直接在每个项目中直接使用Enkits，而不是将其安装以进行系统大量使用。但是，如果ENKITS_INSTALL cmake变量设置为ON （默认为OFF ），则ENKITS的CMAKE脚本也可用于安装库。

安装后，将标头文件安装在Include路径的子目录中， include/enkiTS以确保它们不会与其他软件包中的标头文件冲突。当构建应用程序确保这是INCLUDE_PATH变量的一部分时，或者确保Enkits在源文件中的标头路径中，例如使用#include "enkiTS/TaskScheduler.h" ，而不是#include "TaskScheduler.h" 。

使用enkit

C ++用法

  • 示例/parellelsum.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 ++中的任务优先级使用

  • 示例/优先级中的完整示例
  • c示例中的示例/优先级_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.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 ++的依赖性用法

  • 示例/依赖项中的完整示例.cpp
  • 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示例中的示例/externalTask​​Thread_c.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.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兼容分支已被弃用，因为我不知道有人需要它。

用户线程版本不再使用，因为它们不再使用。可以使用外部词法读物获得类似的功能

  • Branch用户线上的用户线程版本用户线程在其他任务 /线程系统上运行ENKIT，因此可以像其他引擎一样使用它，例如在其他引擎中使用。
  • C ++ 11版的用户线程在分支UserThread_c ++ 11

使用Enkits的项目

雅芳

Avoyd是一种抽象的6度自由度Voxel游戏。 Enkits是开发用于我们的内部发动机供电Avoyd的。

Avoyd屏幕截图

Imogen

GPU/CPU纹理发生器

TOYPATHRACER

ArasPranckevičius的代码在每日路径示踪剂上使用各种语言进行实验。

TOYPATHTRACER屏幕截图 。

使用Vulkan掌握图形编程

Marco Castorina和Gabriel Sassone的书关于使用Vulkan API从第一原理开发现代渲染引擎的书。 Enkits用作任务库来跨内核分发工作。

许可证（Zlib）

版权（C）2013-2020 Doug Binks

该软件提供了“原样”，而无需任何明示或暗示的保证。在任何情况下，作者都不应对使用此软件造成的任何损害负责。

授予任何人，包括任何目的，包括商业应用程序，并将其更改并自由重新分配，但要予以自由限制：

  1. 该软件的起源不得歪曲；您不得声称自己编写了原始软件。如果您在产品中使用此软件，则将对产品文档的确认表示赞赏，但不需要。
  2. 更改的源版本必须明确标记为此类版本，并且不得将其歪曲为原始软件。
  3. 本通知不得从任何源分布中删除或更改。
展开
附加信息
相关应用
为您推荐
相关资讯 全部