SC::AsyncLoopWork Struct Reference

Executes work in a thread pool and then invokes a callback on the event loop thread. More...

#include <Async.h>

Inheritance diagram for SC::AsyncLoopWork:

Public Types
using	CompletionData = AsyncCompletionData
	Completion data for AsyncLoopWakeUp.
using	Result = AsyncResultOf<AsyncLoopWork, CompletionData>
	Callback result for AsyncLoopWakeUp.
Public Types inherited from SC::AsyncRequest
enum class	Type : uint8_t {   LoopTimeout ,   LoopWakeUp ,   LoopWork ,   ProcessExit ,   SocketAccept ,   SocketConnect ,   SocketSend ,   SocketReceive ,   SocketClose ,   FileRead ,   FileWrite ,   FileClose ,   FilePoll }
	Type of async request. More...

Public Member Functions
SC::Result	setThreadPool (ThreadPool &threadPool)
	Sets the ThreadPool that will supply the thread to run the async work on.
Public Member Functions inherited from SC::AsyncRequest
void	setDebugName (const char *newDebugName)
void	executeOn (AsyncSequence &sequence)
	Adds the request to be executed on a specific AsyncSequence.
Result	executeOn (AsyncTaskSequence &task, ThreadPool &pool)
	Adds the request to be executed on a specific AsyncTaskSequence.
void	disableThreadPool ()
	Disables the thread-pool usage for this request.
	AsyncRequest (Type type)
	Constructs a free async request of given type.
Result	stop (AsyncEventLoop &eventLoop, Function< void(AsyncResult &)> *afterStopped=nullptr)
	Ask to stop current async operation.
bool	isFree () const
	Returns true if this request is free.
bool	isCancelling () const
	Returns true if this request is being cancelled.
bool	isActive () const
	Returns true if this request is active or being reactivated.
Type	getType () const
	Returns request type.
Result	start (AsyncEventLoop &eventLoop)
	Shortcut for AsyncEventLoop::start.
void	setUserFlags (uint16_t externalFlags)
	Sets user flags, holding some meaningful data for the caller.
uint16_t	getUserFlags () const
	Gets user flags, holding some meaningful data for the caller.
Function< void(AsyncResult &)> *	getCloseCallback ()
	Returns currently set close callback (if any) passed to AsyncRequest::stop.
const Function< void(AsyncResult &)> *	getCloseCallback () const

Public Attributes
Function< SC::Result()>	work
Function< void(Result &)>	callback
	Called to execute the work in a background threadpool thread.
Public Attributes inherited from SC::AsyncRequest
AsyncRequest *	next = nullptr
AsyncRequest *	prev = nullptr

Friends
struct	AsyncEventLoop
	Called after work is done, on the thread calling EventLoop::run()

Additional Inherited Members
Protected Member Functions inherited from SC::AsyncRequest
Result	checkState ()
void	queueSubmission (AsyncEventLoop &eventLoop)
AsyncTaskSequence *	getTask ()
Protected Attributes inherited from SC::AsyncRequest
AsyncSequence *	sequence = nullptr

Detailed Description

Executes work in a thread pool and then invokes a callback on the event loop thread.

AsyncLoopWork::work is invoked on one of the thread supplied by the ThreadPool passed during AsyncLoopWork::start. AsyncLoopWork::callback will be called as a completion, on the event loop thread AFTER work callback is finished.

    // This test creates a thread pool with 4 thread and 16 AsyncLoopWork.
    // All the 16 AsyncLoopWork are scheduled to do some work on a background thread.
    // After work is done, their respective after-work callback is invoked on the event loop thread.
 
    static constexpr int NUM_THREADS = 4;
    static constexpr int NUM_WORKS   = NUM_THREADS * NUM_THREADS;
 
    ThreadPool threadPool;
    SC_TEST_EXPECT(threadPool.create(NUM_THREADS));
 
    AsyncEventLoop eventLoop;
    SC_TEST_EXPECT(eventLoop.create());
 
    AsyncLoopWork works[NUM_WORKS];
 
    int         numAfterWorkCallbackCalls = 0;
    Atomic<int> numWorkCallbackCalls      = 0;
 
    for (int idx = 0; idx < NUM_WORKS; ++idx)
    {
        works[idx].work = [&]
        {
            // This work callback is called on some random threadPool thread
            Thread::Sleep(50);                 // Execute some work on the thread
            numWorkCallbackCalls.fetch_add(1); // Atomically increment this counter
            return Result(true);
        };
        works[idx].callback = [&](AsyncLoopWork::Result&)
        {
            // This after-work callback is invoked on the event loop thread.
            // More precisely this runs on the thread calling eventLoop.run().
            numAfterWorkCallbackCalls++; // No need for atomics here, callback is run inside loop thread
        };
        // Must always call setThreadPool at least once before start
        SC_TEST_EXPECT(works[idx].setThreadPool(threadPool));
        SC_TEST_EXPECT(works[idx].start(eventLoop));
    }
    int numRequests = 0;
    eventLoop.enumerateRequests([&](AsyncRequest&) { numRequests++; });
    SC_TEST_EXPECT(eventLoop.run());
    SC_TEST_EXPECT(numRequests == NUM_WORKS);
 
    // Check that callbacks have been actually called
    SC_TEST_EXPECT(numWorkCallbackCalls.load() == NUM_WORKS);
    SC_TEST_EXPECT(numAfterWorkCallbackCalls == NUM_WORKS);

Member Typedef Documentation

CompletionData

using SC::AsyncLoopWork::CompletionData = AsyncCompletionData

Completion data for AsyncLoopWakeUp.

Result

using SC::AsyncLoopWork::Result = AsyncResultOf<AsyncLoopWork, CompletionData>

Callback result for AsyncLoopWakeUp.

Member Function Documentation

setThreadPool()

SC::Result SC::AsyncLoopWork::setThreadPool

(

ThreadPool &

threadPool

)

Sets the ThreadPool that will supply the thread to run the async work on.

Note

Always call this method at least once before AsyncLoopWork::start

Friends And Related Symbol Documentation

AsyncEventLoop

friend struct AsyncEventLoop

friend

Called after work is done, on the thread calling EventLoop::run()

Member Data Documentation

callback

Function<void(Result&)> SC::AsyncLoopWork::callback

Called to execute the work in a background threadpool thread.

---

The documentation for this struct was generated from the following file:

• Async.h