enkiTS

Apoie o desenvolvimento de Enkits através de patrocinadores do GitHub ou Patreon

Agendador de tarefas enki

Um agendador de tarefas C e C ++ licenciado permissivamente para criar programas paralelos. Requer suporte C ++ 11.

O objetivo principal do ENKITS é ajudar os desenvolvedores a criar programas que lidam com o paralelismo de dados e níveis de tarefas para utilizar o desempenho completo das CPUs multicore, sendo leves (apenas uma pequena quantidade de código) e fácil de usar.

• API C ++ via SRC/TaskScheduler.h
• C API via SRC/TaskScheduler_C.H

O Enkits foi desenvolvido para e é usado na base de código Avoyd da Enkisoftware.

Plataformas

• Windows, Linux, Mac OS, Android (deve funcionar no iOS)
• x64 e x86, braço

O ENKITS é desenvolvido principalmente nas arquiteturas Intel X64 e X86 no MS Windows, com suporte bem testado para Linux e suporte um pouco com menos frequência no Mac OS e ARM Android.

Exemplos

Vários exemplos existem na pasta Exemplo.

Para mais exemplos, consulte https://github.com/dougbinks/enkitsexamples

Prédio

Construir enkits é simples, basta adicionar os arquivos no enkits/src ao seu sistema de compilação (os arquivos _c. As compilações Unix / Linux provavelmente exigirão a biblioteca Pthreads.

Para C ++

• Use #include "TaskScheduler.h"
• Adicione enkits/src ao seu caminho de incluir
• Compilar / Adicionar ao Projeto:
  • TaskScheduler.cpp
• As compilações Unix / Linux provavelmente exigirão a biblioteca Pthreads.

Para c

• Use #include "TaskScheduler_c.h"
• Adicione enkits/src ao seu caminho de incluir
• Compilar / Adicionar ao Projeto:
  • TaskScheduler.cpp
  • TaskScheduler_c.cpp
• As compilações Unix / Linux provavelmente exigirão a biblioteca Pthreads.

Para CMake, no Windows / Mac OS X / Linux com CMake instalado, abra um prompt no diretório Enkits e:

1. mkdir build
2. cd build
3. cmake ..
4. Run make all ou para o Visual Studio Open enkiTS.sln

Recursos do projeto

1. Lightweight - Enkits foi projetado para ser magro, para que você possa usá -lo em qualquer lugar facilmente e entendê -lo.
2. Rápido, então escalável - o Enkits foi projetado para dispositivos de consumo primeiro, portanto, o desempenho em um número baixo de encadeamentos é importante, seguido de escalabilidade.
3. Paralelismo trançado - Enkits pode emitir tarefas de outra tarefa, bem como do encadeamento que criou o sistema de tarefas e possui uma interface de tarefa simples para o paralelismo de dados paralelo e da tarefa.
4. Friendly de alocação inicial - Enkits foi projetado para alocações zero durante a programação.
5. Pode definir tarefas em um determinado thread - os enkits podem agendar uma tarefa que será executada apenas no thread especificado.
6. Pode definir prioridades de tarefas - até 5 prioridades de tarefas podem ser configuradas via define enkits_task_priorities_num (padrão para 3). Tarefas de prioridade mais alta são executadas antes de mais baixa prioridade.
7. Pode registrar threads externos a serem usados ​​com enkits - pode configurar Enkits com o numExternalTaskthreads, que podem ser registrados para usar na API Enkits.
8. API de alocador personalizado - pode configurar Enkits com alocadores personalizados, consulte Exemplo/CustomAllocator.cpp e exemplo/customallocator_c.c.
9. Dependências - pode definir dependências entre tarefas, consulte Exemplo/dependências.cpp e exemplo/dependências_c.c.
10. Ações de conclusão - pode executar uma ação na conclusão da tarefa. Isso evita a ação cara de adicionar a tarefa ao agendador e pode ser usada para excluir com segurança uma tarefa concluída. Consulte Exemplo/ConclusãoAction.cpp e Exemplo/Conclusãoaction_c.c
11. O novo pode aguardar tarefas fixadas - pode aguardar tarefas fixadas, úteis para criar threads de IO que não fazem outro trabalho. Consulte Exemplo/WaitforNewPinnedTasks.cpp e Exemplo/WaitforNewPinnedTasks_C.C.

Instalação

Eu recomendo o uso do enkits diretamente da fonte em cada projeto, em vez de instalá -lo para uso amplo do sistema. No entanto, o script cMake da Enkits também pode ser usado para instalar a biblioteca se a variável ENKITS_INSTALL cmake estiver definida como ON (o padrão é OFF ).

Quando instalados, os arquivos do cabeçalho são instalados em um subdiretório do caminho incluir, include/enkiTS para garantir que eles não entrem em conflito com os arquivos de cabeçalho de outros pacotes. Ao criar aplicativos, certifique -se de que isso faça parte da variável INCLUDE_PATH ou verifique se o Enkits está no caminho do cabeçalho nos arquivos de origem, por exemplo, use #include "enkiTS/TaskScheduler.h" em vez de #include "TaskScheduler.h" .

Usando enkits

Uso de C ++

• Exemplo completo em exemplo/parallelsum.cpp
• C exemplo no exemplo/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 Uso lambda

• Exemplo completo no exemplo/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 ;
}

Uso de prioridades de tarefas em C ++

• Exemplo completo em exemplo/priorities.cpp
• C Exemplo no exemplo/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 ;
}

Tarefas fixadas no uso em C ++

• Exemplo completo no exemplo/pinnedtask.cpp
• C Exemplo no exemplo/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 ;
}

Uso de dependência em C ++

• Exemplo completo em exemplo/dependências.cpp
• C Exemplo em exemplo/dependências_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 ;
}

Uso do thread de tarefas externas em C ++

• Exemplo completo em exemplo/externaltaskthread.cpp
• C Exemplo no exemplo/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 ;
}

Uso do tópico WaitForpinnedTasks em C ++ (útil para threads de IO)

• Exemplo completo em exemplo/waitfornewpinnedtasks.cpp
• C Exemplo em exemplo/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 ;
}

Ligações

• C# enkitasks c#

Descontinuado

A filial compatível com C ++ 98 foi presa, pois não estou ciente de alguém que precisa.

As versões do thread do usuário não estão mais sendo mantidas, pois não estão mais em uso. Funcionalidade semelhante pode ser obtida com o Externaltaskthreads

• Versão do thread do usuário no Branch UserThread para executar enkits em outros sistemas de tarefas / encadeamento, para que possa ser usado como em outros motores e independentes, por exemplo.
• C ++ 11 Versão dos threads de usuário no ramo userThread_c ++ 11

Projetos usando enkits

Avoyd

Avoyd é um jogo abstrato de 6 graus de liberdade voxel. O Enkits foi desenvolvido para uso em nosso motor interno, alimentando o Avoyd.

Imogen

Gerador de textura GPU/CPU

TOYPATHRACER

O código de Aras Pranckevičius para sua série em experimentos diários de rastreamento de caminhos com vários idiomas.

.

Mastering gráficos programação com vulkan

O livro de Marco Castorina e Gabriel Sassone sobre o desenvolvimento de um mecanismo de renderização moderno a partir dos primeiros princípios usando a API Vulkan. O ENKITS é usado como biblioteca de tarefas para distribuir trabalhos entre núcleos.

Licença (Zlib)

Copyright (c) 2013-2020 Doug Binks

Este software é fornecido 'como está', sem qualquer garantia expressa ou implícita. Em nenhum caso os autores serão responsabilizados por quaisquer danos decorrentes do uso deste software.

A permissão é concedida a qualquer pessoa para usar este software para qualquer finalidade, incluindo aplicativos comerciais, e alterá -lo e redistribuí -lo livremente, sujeito às seguintes restrições:

1. A origem deste software não deve ser deturpada; Você não deve afirmar que escreveu o software original. Se você usar este software em um produto, um reconhecimento na documentação do produto será apreciado, mas não será necessário.
2. As versões de origem alterada devem ser claramente marcadas como tal e não devem ser deturpadas como sendo o software original.
3. Este aviso não pode ser removido ou alterado de qualquer distribuição de origem.