duckdb::StateWithBlockableTasks Class Reference

Inheritance diagram for duckdb::StateWithBlockableTasks:

Collaboration diagram for duckdb::StateWithBlockableTasks:

Public Member Functions
unique_lock< mutex >	Lock ()
void	PreventBlocking (const unique_lock< mutex > &guard)
bool	BlockTask (const unique_lock< mutex > &guard, const InterruptState &interrupt_state)
	Add a task to 'blocked_tasks' before returning SourceResultType::BLOCKED (must hold the lock)
bool	CanBlock (const unique_lock< mutex > &guard) const
bool	UnblockTasks (const unique_lock< mutex > &guard)
	Unblock all tasks (must hold the lock)
SinkResultType	BlockSink (const unique_lock< mutex > &guard, const InterruptState &interrupt_state)
SourceResultType	BlockSource (const unique_lock< mutex > &guard, const InterruptState &interrupt_state)
void	VerifyLock (const unique_lock< mutex > &guard) const

Private Attributes
atomic< bool >	can_block {true}
	Whether we can block tasks.
mutex	lock
	Global lock, acquired by calling Lock()
vector< InterruptState >	blocked_tasks
	Tasks that are currently blocked.

Member Function Documentation

Lock()

unique_lock< mutex > duckdb::StateWithBlockableTasks::Lock ( )

inline

                              {
        return unique_lock<mutex>(lock);
    }

PreventBlocking()

void duckdb::StateWithBlockableTasks::PreventBlocking ( const unique_lock< mutex > &  guard )

inline

                                                          {
        VerifyLock(guard);
        can_block = false;
    }

BlockTask()

bool duckdb::StateWithBlockableTasks::BlockTask ( const unique_lock< mutex > &  guard, const InterruptState &  interrupt_state  )

inline

Add a task to 'blocked_tasks' before returning SourceResultType::BLOCKED (must hold the lock)

                                                                                           {
        VerifyLock(guard);
        if (can_block) {
            blocked_tasks.push_back(interrupt_state);
            return true;
        }
        return false;
    }

CanBlock()

bool duckdb::StateWithBlockableTasks::CanBlock ( const unique_lock< mutex > &  guard ) const

inline

                                                         {
        VerifyLock(guard);
        return can_block;
    }

UnblockTasks()

bool duckdb::StateWithBlockableTasks::UnblockTasks ( const unique_lock< mutex > &  guard )

inline

Unblock all tasks (must hold the lock)

                                                       {
        VerifyLock(guard);
        if (blocked_tasks.empty()) {
            return false;
        }
        for (auto &entry : blocked_tasks) {
            entry.Callback();
        }
        blocked_tasks.clear();
        return true;
    }

BlockSink()

SinkResultType duckdb::StateWithBlockableTasks::BlockSink ( const unique_lock< mutex > &  guard, const InterruptState &  interrupt_state  )

inline

                                                                                                     {
        return BlockTask(guard, interrupt_state) ? SinkResultType::BLOCKED : SinkResultType::FINISHED;
    }

BlockSource()

SourceResultType duckdb::StateWithBlockableTasks::BlockSource ( const unique_lock< mutex > &  guard, const InterruptState &  interrupt_state  )

inline

                                                                                                         {
        return BlockTask(guard, interrupt_state) ? SourceResultType::BLOCKED : SourceResultType::FINISHED;
    }

VerifyLock()

void duckdb::StateWithBlockableTasks::VerifyLock ( const unique_lock< mutex > &  guard ) const

inline

                                                           {
#ifdef DEBUG
        D_ASSERT(guard.mutex() && RefersToSameObject(*guard.mutex(), lock));
#endif
    }

Member Data Documentation

can_block

atomic<bool> duckdb::StateWithBlockableTasks::can_block {true}

private

Whether we can block tasks.

{true};

---

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

• external/duckdb/duckdb.hpp