-
-
Notifications
You must be signed in to change notification settings - Fork 140
/
ExternalTaskThread.cpp
95 lines (75 loc) · 2.9 KB
/
ExternalTaskThread.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
// Copyright (c) 2019 Doug Binks
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it
// freely, subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented; you must not
// claim that you wrote the original software. If you use this software
// in a product, an acknowledgement in the product documentation would be
// appreciated but is not required.
// 2. Altered source versions must be plainly marked as such, and must not be
// misrepresented as being the original software.
// 3. This notice may not be removed or altered from any source distribution.
#include "TaskScheduler.h"
#include <stdio.h>
#include <thread>
using namespace enki;
TaskScheduler g_TS;
static std::atomic<int32_t> g_Run;
struct ParallelTaskSet : ITaskSet
{
ParallelTaskSet() { m_SetSize = 100; }
void ExecuteRange( TaskSetPartition range_, uint32_t threadnum_ ) override
{
printf(" Run %d: This could run on any thread, currently thread %d\n", g_Run.load(), threadnum_);
// sleep used as a 'pretend' workload
std::chrono::milliseconds sleepTime( range_.end - range_.start );
std::this_thread::sleep_for( sleepTime );
}
};
// Example thread function
// May want to use threads for blocking IO, during which enkiTS task threads can do work
void threadFunction( uint32_t num_ )
{
bool bRegistered = g_TS.RegisterExternalTaskThread();
assert( bRegistered );
if( bRegistered )
{
// 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();
}
}
static const int REPEATS = 5;
static const uint32_t NUMEXTERNALTHREADS = 5;
int main(int argc, const char * argv[])
{
enki::TaskSchedulerConfig config;
config.numExternalTaskThreads = NUMEXTERNALTHREADS;
std::thread threads[NUMEXTERNALTHREADS];
g_TS.Initialize( config );
for( g_Run = 0; g_Run< REPEATS; ++g_Run )
{
printf("Run %d\n", g_Run.load() );
for( uint32_t iThread = 0; iThread < NUMEXTERNALTHREADS; ++iThread )
{
threads[ iThread ] = std::thread( threadFunction, iThread );
}
// check that out of order Deregister / Register works...
threads[ 0 ].join();
threads[ 0 ] = std::thread( threadFunction, 0 );
for( uint32_t iThread = 0; iThread < NUMEXTERNALTHREADS; ++iThread )
{
threads[ iThread ].join();
}
}
return 0;
}