Skip to content

GitLab

T
tangled
Commit 651b0c34 authored by Victor Miura's avatar Victor Miura Committed by Commit Bot
Browse files
Options

Reland "gpu scheduler: Compute stream priorities based on priority of waiters." 

This is a reland of 56eadad0
Original change's description:
> gpu scheduler: Compute stream priorities based on priority of waiters.
> 
> Previously, a stream tracked all of it's fences that had waiting streams
> in 'release_fences'.  If 'release_fences' was non-empty, the stream's
> priority got bumped up to High.  This means a stream with Normal priority
> waiting on Low priority stream could bump that stream up to High priority.
> 
> This change removes that tracking, and instead keeps count of the number
> of waiting streams at each StreamPriority.  The highest priority with non-
> zero count becomes the stream's priority.
> 
> When a stream changes priority, it recursively propagates it's new priority
> to all streams it's waiting on.
> 
> BUG=781585
> 
> Cq-Include-Trybots: master.tryserver.chromium.android:android_optional_gpu_tests_rel;master.tryserver.chromium.linux:linux_optional_gpu_tests_rel;master.tryserver.chromium.mac:mac_optional_gpu_tests_rel;master.tryserver.chromium.win:win_optional_gpu_tests_rel
> Change-Id: I1fc96f6ca065a8e1f83ddaa61ae4f9725c324bcb
> Reviewed-on: https://chromium-review.googlesource.com/754415
> Commit-Queue: Victor Miura <vmiura@chromium.org>
> Reviewed-by: Sunny Sachanandani <sunnyps@chromium.org>
> Reviewed-by: Antoine Labour <piman@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#515097}

Bug: 781585
Change-Id: I67055fe2887a8ffcc8032af32ab221a3d66bedac
Cq-Include-Trybots: master.tryserver.chromium.android:android_optional_gpu_tests_rel;master.tryserver.chromium.linux:linux_optional_gpu_tests_rel;master.tryserver.chromium.mac:mac_optional_gpu_tests_rel;master.tryserver.chromium.win:win_optional_gpu_tests_rel
Reviewed-on: https://chromium-review.googlesource.com/762145
Commit-Queue: Victor Miura <vmiura@chromium.org>
Reviewed-by: default avatarSunny Sachanandani <sunnyps@chromium.org>
Reviewed-by: default avatarAntoine Labour <piman@chromium.org>
Cr-Commit-Position: refs/heads/master@{#517702}
parent 10686d89
Hide whitespace changes
Inline Side-by-side
Showing with 757 additions and 357 deletions
gpu/command_buffer/service/scheduler.cc
View file @ 651b0c34
......@@ -7,8 +7,6 @@
#include <algorithm>
#include "base/callback.h"
#include "base/containers/circular_deque.h"
#include "base/containers/flat_set.h"
#include "base/memory/ptr_util.h"
#include "base/stl_util.h"
#include "base/trace_event/trace_event.h"
......@@ -17,134 +15,6 @@
namespace gpu {
class Scheduler::Sequence {
public:
Sequence(SequenceId sequence_id,
SchedulingPriority priority,
scoped_refptr<SyncPointOrderData> order_data);
~Sequence();
SequenceId sequence_id() const { return sequence_id_; }
const scoped_refptr<SyncPointOrderData>& order_data() const {
return order_data_;
}
bool enabled() const { return enabled_; }
bool scheduled() const { return running_state_ == SCHEDULED; }
bool running() const { return running_state_ == RUNNING; }
// The sequence is runnable if its enabled and has tasks which are not blocked
// by wait fences.
bool IsRunnable() const;
// Returns true if this sequence's scheduling state changed and it needs to be
// reinserted into the scheduling queue.
bool NeedsRescheduling() const;
// Returns true if this sequence should yield to another sequence. Uses the
// cached scheduling state for comparison.
bool ShouldYieldTo(const Sequence* other) const;
// Enables or disables the sequence.
void SetEnabled(bool enabled);
// Sets running state to SCHEDULED. Returns scheduling state for this sequence
// used for inserting in the scheduling queue.
SchedulingState SetScheduled();
// Update cached scheduling priority while running.
void UpdateRunningPriority();
// Returns the next order number and closure. Sets running state to RUNNING.
uint32_t BeginTask(base::OnceClosure* closure);
// Called after running the closure returned by BeginTask. Sets running state
// to IDLE.
void FinishTask();
// Enqueues a task in the sequence and returns the generated order number.
uint32_t ScheduleTask(base::OnceClosure closure);
// Continue running the current task with the given closure. Must be called in
// between |BeginTask| and |FinishTask|.
void ContinueTask(base::OnceClosure closure);
// Add a sync token fence that this sequence should wait on.
void AddWaitFence(const SyncToken& sync_token, uint32_t order_num);
// Remove a waiting sync token fence.
void RemoveWaitFence(const SyncToken& sync_token, uint32_t order_num);
// Add a sync token fence that this sequence is expected to release.
void AddReleaseFence(const SyncToken& sync_token, uint32_t order_num);
// Remove a release sync token fence.
void RemoveReleaseFence(const SyncToken& sync_token, uint32_t order_num);
void AddClientWait(CommandBufferId command_buffer_id);
void RemoveClientWait(CommandBufferId command_buffer_id);
private:
enum RunningState { IDLE, SCHEDULED, RUNNING };
struct Fence {
SyncToken sync_token;
uint32_t order_num;
bool operator==(const Fence& other) const {
return std::tie(sync_token, order_num) ==
std::tie(other.sync_token, other.order_num);
}
};
struct Task {
base::OnceClosure closure;
uint32_t order_num;
};
SchedulingPriority GetSchedulingPriority() const;
// If the sequence is enabled. Sequences are disabled/enabled based on when
// the command buffer is descheduled/scheduled.
bool enabled_ = true;
RunningState running_state_ = IDLE;
// Cached scheduling state used for comparison with other sequences while
// running. Updated in |SetScheduled| and |UpdateRunningPriority|.
SchedulingState scheduling_state_;
const SequenceId sequence_id_;
const SchedulingPriority priority_;
scoped_refptr<SyncPointOrderData> order_data_;
// Deque of tasks. Tasks are inserted at the back with increasing order number
// generated from SyncPointOrderData. If a running task needs to be continued,
// it is inserted at the front with the same order number.
base::circular_deque<Task> tasks_;
// List of fences that this sequence is waiting on. Fences are inserted in
// increasing order number but may be removed out of order. Tasks are blocked
// if there's a wait fence with order number less than or equal to the task's
// order number.
std::vector<Fence> wait_fences_;
// List of fences that this sequence is expected to release. If this list is
// non-empty, the priority of the sequence is raised.
std::vector<Fence> release_fences_;
base::flat_set<CommandBufferId> client_waits_;
DISALLOW_COPY_AND_ASSIGN(Sequence);
};
Scheduler::Task::Task(SequenceId sequence_id,
base::OnceClosure closure,
std::vector<SyncToken> sync_token_fences)
......@@ -170,27 +40,85 @@ Scheduler::SchedulingState::AsValue() const {
return std::move(state);
}
Scheduler::Sequence::Sequence(SequenceId sequence_id,
Scheduler::Sequence::Task::Task(base::OnceClosure closure, uint32_t order_num)
: closure(std::move(closure)), order_num(order_num) {}
Scheduler::Sequence::Task::Task(Task&& other) = default;
Scheduler::Sequence::Task::~Task() = default;
Scheduler::Sequence::Task& Scheduler::Sequence::Task::operator=(Task&& other) =
default;
Scheduler::Sequence::Fence::Fence(const SyncToken& sync_token,
uint32_t order_num,
SequenceId release_sequence_id)
: sync_token(sync_token),
order_num(order_num),
release_sequence_id(release_sequence_id) {}
Scheduler::Sequence::Fence::Fence(Fence&& other) = default;
Scheduler::Sequence::Fence::~Fence() = default;
Scheduler::Sequence::Fence& Scheduler::Sequence::Fence::operator=(
Fence&& other) = default;
Scheduler::Sequence::Sequence(Scheduler* scheduler,
SequenceId sequence_id,
SchedulingPriority priority,
scoped_refptr<SyncPointOrderData> order_data)
: sequence_id_(sequence_id),
priority_(priority),
: scheduler_(scheduler),
sequence_id_(sequence_id),
default_priority_(priority),
current_priority_(priority),
order_data_(std::move(order_data)) {}
Scheduler::Sequence::~Sequence() {
for (auto& fence : wait_fences_) {
Sequence* release_sequence =
scheduler_->GetSequence(fence.release_sequence_id);
if (!release_sequence)
continue;
release_sequence->RemoveWaitingPriority(current_priority());
}
order_data_->Destroy();
}
SchedulingPriority Scheduler::Sequence::GetSchedulingPriority() const {
SchedulingPriority priority = priority_;
if (!release_fences_.empty() || !client_waits_.empty())
void Scheduler::Sequence::UpdateSchedulingPriority() {
SchedulingPriority priority = default_priority_;
if (!client_waits_.empty())
priority = std::min(priority, SchedulingPriority::kHigh);
return priority;
for (int release_priority = 0; release_priority < static_cast<int>(priority);
release_priority++) {
if (waiting_priority_counts_[release_priority] != 0) {
priority = static_cast<SchedulingPriority>(release_priority);
break;
}
}
if (current_priority_ != priority) {
TRACE_EVENT2("gpu", "Scheduler::Sequence::UpdateSchedulingPriority",
"sequence_id", sequence_id_.GetUnsafeValue(), "new_priority",
SchedulingPriorityToString(priority));
SchedulingPriority old_priority = current_priority_;
current_priority_ = priority;
// Update priorities on sequences we're waiting on.
for (auto& wait_fence : wait_fences_) {
Sequence* release_sequence =
scheduler_->GetSequence(wait_fence.release_sequence_id);
if (release_sequence) {
release_sequence->ChangeWaitingPriority(old_priority,
current_priority_);
}
}
scheduler_->TryScheduleSequence(this);
}
}
bool Scheduler::Sequence::NeedsRescheduling() const {
return running_state_ != IDLE &&
scheduling_state_.priority != GetSchedulingPriority();
scheduling_state_.priority != current_priority();
}
bool Scheduler::Sequence::IsRunnable() const {
......@@ -213,6 +141,7 @@ void Scheduler::Sequence::SetEnabled(bool enabled) {
if (enabled) {
TRACE_EVENT_ASYNC_BEGIN1("gpu", "SequenceEnabled", this, "sequence_id",
sequence_id_.GetUnsafeValue());
scheduler_->TryScheduleSequence(this);
} else {
TRACE_EVENT_ASYNC_END1("gpu", "SequenceEnabled", this, "sequence_id",
sequence_id_.GetUnsafeValue());
......@@ -226,7 +155,7 @@ Scheduler::SchedulingState Scheduler::Sequence::SetScheduled() {
running_state_ = SCHEDULED;
scheduling_state_.sequence_id = sequence_id_;
scheduling_state_.priority = GetSchedulingPriority();
scheduling_state_.priority = current_priority();
scheduling_state_.order_num = tasks_.front().order_num;
return scheduling_state_;
......@@ -234,7 +163,7 @@ Scheduler::SchedulingState Scheduler::Sequence::SetScheduled() {
void Scheduler::Sequence::UpdateRunningPriority() {
DCHECK_EQ(running_state_, RUNNING);
scheduling_state_.priority = GetSchedulingPriority();
scheduling_state_.priority = current_priority();
}
void Scheduler::Sequence::ContinueTask(base::OnceClosure closure) {
......@@ -270,31 +199,80 @@ void Scheduler::Sequence::FinishTask() {
}
void Scheduler::Sequence::AddWaitFence(const SyncToken& sync_token,
uint32_t order_num) {
wait_fences_.push_back({sync_token, order_num});
uint32_t order_num,
SequenceId release_sequence_id,
Sequence* release_sequence) {
DCHECK(release_sequence);
release_sequence->AddWaitingPriority(current_priority());
wait_fences_.emplace_back(sync_token, order_num, release_sequence_id);
}
void Scheduler::Sequence::RemoveWaitFence(const SyncToken& sync_token,
uint32_t order_num) {
base::Erase(wait_fences_, Fence{sync_token, order_num});
uint32_t order_num,
SequenceId release_sequence_id) {
auto it = std::find(wait_fences_.begin(), wait_fences_.end(),
Fence{sync_token, order_num, release_sequence_id});
DCHECK(it != wait_fences_.end());
if (it != wait_fences_.end()) {
wait_fences_.erase(it);
Sequence* release_sequence = scheduler_->GetSequence(release_sequence_id);
if (release_sequence)
release_sequence->RemoveWaitingPriority(current_priority());
scheduler_->TryScheduleSequence(this);
}
}
void Scheduler::Sequence::AddReleaseFence(const SyncToken& sync_token,
uint32_t order_num) {
release_fences_.push_back({sync_token, order_num});
void Scheduler::Sequence::AddWaitingPriority(SchedulingPriority priority) {
TRACE_EVENT2("gpu", "Scheduler::Sequence::RemoveWaitingPriority",
"sequence_id", sequence_id_.GetUnsafeValue(), "new_priority",
SchedulingPriorityToString(priority));
waiting_priority_counts_[static_cast<int>(priority)]++;
if (priority < current_priority_) {
UpdateSchedulingPriority();
}
}
void Scheduler::Sequence::RemoveReleaseFence(const SyncToken& sync_token,
uint32_t order_num) {
base::Erase(release_fences_, Fence{sync_token, order_num});
void Scheduler::Sequence::RemoveWaitingPriority(SchedulingPriority priority) {
TRACE_EVENT2("gpu", "Scheduler::Sequence::RemoveWaitingPriority",
"sequence_id", sequence_id_.GetUnsafeValue(), "new_priority",
SchedulingPriorityToString(priority));
DCHECK(waiting_priority_counts_[static_cast<int>(priority)] > 0);
waiting_priority_counts_[static_cast<int>(priority)]--;
if (priority == current_priority_ &&
waiting_priority_counts_[static_cast<int>(priority)] == 0)
UpdateSchedulingPriority();
}
void Scheduler::Sequence::ChangeWaitingPriority(
SchedulingPriority old_priority,
SchedulingPriority new_priority) {
DCHECK(waiting_priority_counts_[static_cast<int>(old_priority)] != 0);
waiting_priority_counts_[static_cast<int>(old_priority)]--;
waiting_priority_counts_[static_cast<int>(new_priority)]++;
if (new_priority < current_priority_ ||
(old_priority == current_priority_ &&
waiting_priority_counts_[static_cast<int>(old_priority)] == 0)) {
UpdateSchedulingPriority();
}
}
void Scheduler::Sequence::AddClientWait(CommandBufferId command_buffer_id) {
client_waits_.insert(command_buffer_id);
UpdateSchedulingPriority();
}
void Scheduler::Sequence::RemoveClientWait(CommandBufferId command_buffer_id) {
client_waits_.erase(command_buffer_id);
UpdateSchedulingPriority();
}
Scheduler::Scheduler(scoped_refptr<base::SingleThreadTaskRunner> task_runner,
......@@ -315,8 +293,8 @@ SequenceId Scheduler::CreateSequence(SchedulingPriority priority) {
scoped_refptr<SyncPointOrderData> order_data =
sync_point_manager_->CreateSyncPointOrderData();
SequenceId sequence_id = order_data->sequence_id();
auto sequence =
std::make_unique<Sequence>(sequence_id, priority, std::move(order_data));
auto sequence = std::make_unique<Sequence>(this, sequence_id, priority,
std::move(order_data));
sequences_.emplace(sequence_id, std::move(sequence));
return sequence_id;
}
......@@ -347,7 +325,6 @@ void Scheduler::EnableSequence(SequenceId sequence_id) {
Sequence* sequence = GetSequence(sequence_id);
DCHECK(sequence);
sequence->SetEnabled(true);
TryScheduleSequence(sequence);
}
void Scheduler::DisableSequence(SequenceId sequence_id) {
......@@ -365,7 +342,6 @@ void Scheduler::RaisePriorityForClientWait(SequenceId sequence_id,
Sequence* sequence = GetSequence(sequence_id);
DCHECK(sequence);
sequence->AddClientWait(command_buffer_id);
TryScheduleSequence(sequence);
}
void Scheduler::ResetPriorityForClientWait(SequenceId sequence_id,
......@@ -375,7 +351,6 @@ void Scheduler::ResetPriorityForClientWait(SequenceId sequence_id,
Sequence* sequence = GetSequence(sequence_id);
DCHECK(sequence);
sequence->RemoveClientWait(command_buffer_id);
TryScheduleSequence(sequence);
}
void Scheduler::ScheduleTask(Task task) {
......@@ -398,19 +373,18 @@ void Scheduler::ScheduleTaskHelper(Task task) {
uint32_t order_num = sequence->ScheduleTask(std::move(task.closure));
for (const SyncToken& sync_token : task.sync_token_fences) {
SequenceId release_id =
SequenceId release_sequence_id =
sync_point_manager_->GetSyncTokenReleaseSequenceId(sync_token);
Sequence* release_sequence = GetSequence(release_id);
Sequence* release_sequence = GetSequence(release_sequence_id);
if (!release_sequence)
continue;
if (sync_point_manager_->Wait(
sync_token, sequence_id, order_num,
base::Bind(&Scheduler::SyncTokenFenceReleased,
weak_factory_.GetWeakPtr(), sync_token, order_num,
release_id, sequence_id))) {
sequence->AddWaitFence(sync_token, order_num);
release_sequence->AddReleaseFence(sync_token, order_num);
TryScheduleSequence(release_sequence);
release_sequence_id, sequence_id))) {
sequence->AddWaitFence(sync_token, order_num, release_sequence_id,
release_sequence);
}
}
......@@ -452,15 +426,9 @@ void Scheduler::SyncTokenFenceReleased(const SyncToken& sync_token,
SequenceId waiting_sequence_id) {
base::AutoLock auto_lock(lock_);
Sequence* sequence = GetSequence(waiting_sequence_id);
if (sequence) {
sequence->RemoveWaitFence(sync_token, order_num);
TryScheduleSequence(sequence);
}
Sequence* release_sequence = GetSequence(release_sequence_id);
if (release_sequence) {
release_sequence->RemoveReleaseFence(sync_token, order_num);
TryScheduleSequence(release_sequence);
}
if (sequence)
sequence->RemoveWaitFence(sync_token, order_num, release_sequence_id);
}
void Scheduler::TryScheduleSequence(Sequence* sequence) {
......
gpu/command_buffer/service/scheduler.h
View file @ 651b0c34
......@@ -9,7 +9,10 @@
#include <vector>
#include "base/callback.h"
#include "base/containers/circular_deque.h"
#include "base/containers/flat_map.h"
#include "base/containers/flat_set.h"
#include "base/gtest_prod_util.h"
#include "base/memory/ref_counted.h"
#include "base/memory/weak_ptr.h"
#include "base/synchronization/lock.h"
......@@ -88,7 +91,6 @@ class GPU_EXPORT Scheduler {
bool ShouldYield(SequenceId sequence_id);
private:
class Sequence;
struct SchedulingState {
static bool Comparator(const SchedulingState& lhs,
......@@ -113,6 +115,162 @@ class GPU_EXPORT Scheduler {
uint32_t order_num = 0;
};
class GPU_EXPORT Sequence {
public:
Sequence(Scheduler* scheduler,
SequenceId sequence_id,
SchedulingPriority priority,
scoped_refptr<SyncPointOrderData> order_data);
~Sequence();
SequenceId sequence_id() const { return sequence_id_; }
const scoped_refptr<SyncPointOrderData>& order_data() const {
return order_data_;
}
bool enabled() const { return enabled_; }
bool scheduled() const { return running_state_ == SCHEDULED; }
bool running() const { return running_state_ == RUNNING; }
// The sequence is runnable if its enabled and has tasks which are not
// blocked by wait fences.
bool IsRunnable() const;
// Returns true if this sequence's scheduling state changed and it needs to
// be reinserted into the scheduling queue.
bool NeedsRescheduling() const;
// Returns true if this sequence should yield to another sequence. Uses the
// cached scheduling state for comparison.
bool ShouldYieldTo(const Sequence* other) const;
// Enables or disables the sequence.
void SetEnabled(bool enabled);
// Sets running state to SCHEDULED. Returns scheduling state for this
// sequence used for inserting in the scheduling queue.
SchedulingState SetScheduled();
// Update cached scheduling priority while running.
void UpdateRunningPriority();
// Returns the next order number and closure. Sets running state to RUNNING.
uint32_t BeginTask(base::OnceClosure* closure);
// Called after running the closure returned by BeginTask. Sets running
// state to IDLE.
void FinishTask();
// Enqueues a task in the sequence and returns the generated order number.
uint32_t ScheduleTask(base::OnceClosure closure);
// Continue running the current task with the given closure. Must be called
// in between |BeginTask| and |FinishTask|.
void ContinueTask(base::OnceClosure closure);
// Add a sync token fence that this sequence should wait on.
void AddWaitFence(const SyncToken& sync_token,
uint32_t order_num,
SequenceId release_sequence_id,
Sequence* release_sequence);
// Remove a waiting sync token fence.
void RemoveWaitFence(const SyncToken& sync_token,
uint32_t order_num,
SequenceId release_sequence_id);
void AddClientWait(CommandBufferId command_buffer_id);
void RemoveClientWait(CommandBufferId command_buffer_id);
SchedulingPriority current_priority() const { return current_priority_; }
private:
enum RunningState { IDLE, SCHEDULED, RUNNING };
struct Fence {
Fence(Fence&& other);
Fence(const SyncToken& sync_token,
uint32_t order_num,
SequenceId release_sequence_id);
~Fence();
Fence& operator=(Fence&& other);
SyncToken sync_token;
uint32_t order_num;
SequenceId release_sequence_id;
bool operator==(const Fence& other) const {
return std::tie(sync_token, order_num, release_sequence_id) ==
std::tie(other.sync_token, other.order_num, release_sequence_id);
}
};
struct Task {
Task(Task&& other);
Task(base::OnceClosure closure, uint32_t order_num);
~Task();
Task& operator=(Task&& other);
base::OnceClosure closure;
uint32_t order_num;
};
// Add a waiting priority.
void AddWaitingPriority(SchedulingPriority priority);
// Remove a waiting priority.
void RemoveWaitingPriority(SchedulingPriority priority);
// Change a waiting priority.
void ChangeWaitingPriority(SchedulingPriority old_priority,
SchedulingPriority new_priority);
// Re-compute current priority.
void UpdateSchedulingPriority();
// If the sequence is enabled. Sequences are disabled/enabled based on when
// the command buffer is descheduled/scheduled.
bool enabled_ = true;
RunningState running_state_ = IDLE;
// Cached scheduling state used for comparison with other sequences while
// running. Updated in |SetScheduled| and |UpdateRunningPriority|.
SchedulingState scheduling_state_;
Scheduler* const scheduler_;
const SequenceId sequence_id_;
const SchedulingPriority default_priority_;
SchedulingPriority current_priority_;
scoped_refptr<SyncPointOrderData> order_data_;
// Deque of tasks. Tasks are inserted at the back with increasing order
// number generated from SyncPointOrderData. If a running task needs to be
// continued, it is inserted at the front with the same order number.
base::circular_deque<Task> tasks_;
// List of fences that this sequence is waiting on. Fences are inserted in
// increasing order number but may be removed out of order. Tasks are
// blocked if there's a wait fence with order number less than or equal to
// the task's order number.
std::vector<Fence> wait_fences_;
// Counts of pending releases bucketed by scheduling priority.
int waiting_priority_counts_[static_cast<int>(SchedulingPriority::kLast) +
1] = {};
base::flat_set<CommandBufferId> client_waits_;
DISALLOW_COPY_AND_ASSIGN(Sequence);
};
void SyncTokenFenceReleased(const SyncToken& sync_token,
uint32_t order_num,
SequenceId release_sequence_id,
......@@ -151,6 +309,11 @@ class GPU_EXPORT Scheduler {
base::WeakPtrFactory<Scheduler> weak_factory_;
private:
FRIEND_TEST_ALL_PREFIXES(SchedulerTest, StreamPriorities);
FRIEND_TEST_ALL_PREFIXES(SchedulerTest, StreamDestroyRemovesPriorities);
FRIEND_TEST_ALL_PREFIXES(SchedulerTest, StreamPriorityChangeWhileReleasing);
FRIEND_TEST_ALL_PREFIXES(SchedulerTest, CircularPriorities);
DISALLOW_COPY_AND_ASSIGN(Scheduler);
};
......
gpu/command_buffer/service/scheduler_unittest.cc
View file @ 651b0c34
......@@ -10,10 +10,10 @@
#include "base/memory/ptr_util.h"
#include "base/test/test_simple_task_runner.h"
#include "gpu/command_buffer/service/sync_point_manager.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace gpu {
namespace {
template <typename T>
void RunFunctor(T functor) {
......@@ -97,207 +97,266 @@ TEST_F(SchedulerTest, ContinuedTasksRunFirst) {
EXPECT_TRUE(ran2);
}
TEST_F(SchedulerTest, SequencesRunInPriorityOrder) {
SequenceId sequence_id1 =
scheduler()->CreateSequence(SchedulingPriority::kLow);
bool ran1 = false;
scheduler()->ScheduleTask(Scheduler::Task(sequence_id1,
GetClosure([&] { ran1 = true; }),
std::vector<SyncToken>()));
class SchedulerTaskRunOrderTest : public SchedulerTest {
public:
SchedulerTaskRunOrderTest() {}
~SchedulerTaskRunOrderTest() override {
for (auto info_it : sequence_info_) {
info_it.second.release_state->Destroy();
scheduler()->DestroySequence(info_it.second.sequence_id);
}
}
SequenceId sequence_id2 =
scheduler()->CreateSequence(SchedulingPriority::kNormal);
bool ran2 = false;
scheduler()->ScheduleTask(Scheduler::Task(sequence_id2,
GetClosure([&] { ran2 = true; }),
std::vector<SyncToken>()));
protected:
void CreateSequence(int sequence_key, SchedulingPriority priority) {
SequenceId sequence_id = scheduler()->CreateSequence(priority);
CommandBufferId command_buffer_id =
CommandBufferId::FromUnsafeValue(sequence_key);
scoped_refptr<SyncPointClientState> release_state =
sync_point_manager()->CreateSyncPointClientState(
kNamespaceId, command_buffer_id, sequence_id);
sequence_info_.emplace(std::make_pair(
sequence_key,
SequenceInfo(sequence_id, command_buffer_id, release_state)));
}
SequenceId sequence_id3 =
scheduler()->CreateSequence(SchedulingPriority::kHigh);
bool ran3 = false;
scheduler()->ScheduleTask(Scheduler::Task(sequence_id3,
GetClosure([&] { ran3 = true; }),
std::vector<SyncToken>()));
void DestroySequence(int sequence_key) {
auto info_it = sequence_info_.find(sequence_key);
ASSERT_TRUE(info_it != sequence_info_.end());
task_runner()->RunPendingTasks();
EXPECT_TRUE(ran3);
info_it->second.release_state->Destroy();
scheduler()->DestroySequence(info_it->second.sequence_id);
task_runner()->RunPendingTasks();
EXPECT_TRUE(ran2);
sequence_info_.erase(info_it);
}
task_runner()->RunPendingTasks();
EXPECT_TRUE(ran1);
void CreateSyncToken(int sequence_key, int release_sync) {
auto info_it = sequence_info_.find(sequence_key);
ASSERT_TRUE(info_it != sequence_info_.end());
uint64_t release = release_sync + 1;
sync_tokens_.emplace(std::make_pair(
release_sync, SyncToken(kNamespaceId, 0,
info_it->second.command_buffer_id, release)));
}
void ScheduleTask(int sequence_key, int wait_sync, int release_sync) {
const int task_id = num_tasks_scheduled_++;
std::vector<SyncToken> wait;
if (wait_sync >= 0) {
wait.push_back(sync_tokens_[wait_sync]);
}
uint64_t release = 0;
if (release_sync >= 0) {
CreateSyncToken(sequence_key, release_sync);
release = release_sync + 1;
}
auto info_it = sequence_info_.find(sequence_key);
ASSERT_TRUE(info_it != sequence_info_.end());
scheduler()->ScheduleTask(Scheduler::Task(
info_it->second.sequence_id,
GetClosure([this, task_id, sequence_key, release] {
if (release) {
auto info_it = sequence_info_.find(sequence_key);
ASSERT_TRUE(info_it != sequence_info_.end());
info_it->second.release_state->ReleaseFenceSync(release);
}
this->tasks_executed_.push_back(task_id);
}),
wait));
}
void RunAllPendingTasks() {
while (task_runner()->HasPendingTask())
task_runner()->RunPendingTasks();
}
const std::vector<int>& tasks_executed() { return tasks_executed_; }
private:
const CommandBufferNamespace kNamespaceId = CommandBufferNamespace::GPU_IO;
int num_tasks_scheduled_ = 0;
struct SequenceInfo {
SequenceInfo(SequenceId sequence_id,
CommandBufferId command_buffer_id,
scoped_refptr<SyncPointClientState> release_state)
: sequence_id(sequence_id),
command_buffer_id(command_buffer_id),
release_state(release_state) {}
SequenceId sequence_id;
CommandBufferId command_buffer_id;
scoped_refptr<SyncPointClientState> release_state;
};
std::map<int, const SequenceInfo> sequence_info_;
std::map<int, const SyncToken> sync_tokens_;
std::vector<int> tasks_executed_;
};
TEST_F(SchedulerTaskRunOrderTest, SequencesRunInPriorityOrder) {
CreateSequence(0, SchedulingPriority::kLow);
CreateSequence(1, SchedulingPriority::kNormal);
CreateSequence(2, SchedulingPriority::kHigh);
ScheduleTask(0, -1, -1); // task 0: seq 0, no wait, no release
ScheduleTask(1, -1, -1); // task 1: seq 1, no wait, no release
ScheduleTask(2, -1, -1); // task 2: seq 2, no wait, no release
RunAllPendingTasks();
const int expected_task_order[] = {2, 1, 0};
EXPECT_THAT(tasks_executed(), testing::ElementsAreArray(expected_task_order));
}
TEST_F(SchedulerTest, SequencesOfSamePriorityRunInOrder) {
SequenceId sequence_id1 =
scheduler()->CreateSequence(SchedulingPriority::kNormal);
bool ran1 = false;
scheduler()->ScheduleTask(Scheduler::Task(sequence_id1,
GetClosure([&] { ran1 = true; }),
std::vector<SyncToken>()));
TEST_F(SchedulerTaskRunOrderTest, SequencesOfSamePriorityRunInOrder) {
CreateSequence(0, SchedulingPriority::kNormal);
CreateSequence(1, SchedulingPriority::kNormal);
CreateSequence(2, SchedulingPriority::kNormal);
CreateSequence(3, SchedulingPriority::kNormal);
SequenceId sequence_id2 =
scheduler()->CreateSequence(SchedulingPriority::kNormal);
bool ran2 = false;
scheduler()->ScheduleTask(Scheduler::Task(sequence_id2,
GetClosure([&] { ran2 = true; }),
std::vector<SyncToken>()));
ScheduleTask(0, -1, -1); // task 0: seq 0, no wait, no release
ScheduleTask(1, -1, -1); // task 1: seq 1, no wait, no release
ScheduleTask(2, -1, -1); // task 2: seq 2, no wait, no release
ScheduleTask(3, -1, -1); // task 3: seq 2, no wait, no release
SequenceId sequence_id3 =
scheduler()->CreateSequence(SchedulingPriority::kNormal);
bool ran3 = false;
scheduler()->ScheduleTask(Scheduler::Task(sequence_id3,
GetClosure([&] { ran3 = true; }),
std::vector<SyncToken>()));
RunAllPendingTasks();
SequenceId sequence_id4 =
scheduler()->CreateSequence(SchedulingPriority::kNormal);
bool ran4 = false;
scheduler()->ScheduleTask(Scheduler::Task(sequence_id4,
GetClosure([&] { ran4 = true; }),
std::vector<SyncToken>()));
const int expected_task_order[] = {0, 1, 2, 3};
EXPECT_THAT(tasks_executed(), testing::ElementsAreArray(expected_task_order));
}
task_runner()->RunPendingTasks();
EXPECT_TRUE(ran1);
TEST_F(SchedulerTaskRunOrderTest, SequenceWaitsForFence) {
CreateSequence(0, SchedulingPriority::kHigh);
CreateSequence(1, SchedulingPriority::kNormal);
task_runner()->RunPendingTasks();
EXPECT_TRUE(ran2);
ScheduleTask(1, -1, 0); // task 0: seq 1, no wait, release 0
ScheduleTask(0, 0, -1); // task 1: seq 0, wait 0, no release
task_runner()->RunPendingTasks();
EXPECT_TRUE(ran3);
RunAllPendingTasks();
task_runner()->RunPendingTasks();
EXPECT_TRUE(ran4);
const int expected_task_order[] = {0, 1};
EXPECT_THAT(tasks_executed(), testing::ElementsAreArray(expected_task_order));
}
TEST_F(SchedulerTest, SequenceWaitsForFence) {
SequenceId sequence_id1 =
scheduler()->CreateSequence(SchedulingPriority::kHigh);
SequenceId sequence_id2 =
scheduler()->CreateSequence(SchedulingPriority::kNormal);
TEST_F(SchedulerTaskRunOrderTest, SequenceDoesNotWaitForInvalidFence) {
CreateSequence(0, SchedulingPriority::kNormal);
CreateSequence(1, SchedulingPriority::kNormal);
CommandBufferNamespace namespace_id = CommandBufferNamespace::GPU_IO;
CommandBufferId command_buffer_id = CommandBufferId::FromUnsafeValue(1);
CreateSyncToken(1, 0); // declare sync_token 0 on seq 1
scoped_refptr<SyncPointClientState> release_state =
sync_point_manager()->CreateSyncPointClientState(
namespace_id, command_buffer_id, sequence_id2);
ScheduleTask(0, 0, -1); // task 0: seq 0, wait 0, no release
ScheduleTask(1, -1, 0); // task 1: seq 1, no wait, release 0
uint64_t release = 1;
bool ran2 = false;
scheduler()->ScheduleTask(Scheduler::Task(sequence_id2, GetClosure([&] {
release_state->ReleaseFenceSync(
release);
ran2 = true;
}),
std::vector<SyncToken>()));
RunAllPendingTasks();
SyncToken sync_token(namespace_id, 0, command_buffer_id, release);
// Task 0 does not wait on unrelease sync token 0.
const int expected_task_order[] = {0, 1};
EXPECT_THAT(tasks_executed(), testing::ElementsAreArray(expected_task_order));
}
bool ran1 = false;
scheduler()->ScheduleTask(Scheduler::Task(
sequence_id1, GetClosure([&] { ran1 = true; }), {sync_token}));
TEST_F(SchedulerTaskRunOrderTest, ReleaseSequenceIsPrioritized) {
CreateSequence(0, SchedulingPriority::kNormal);
CreateSequence(1, SchedulingPriority::kLow);
CreateSequence(2, SchedulingPriority::kHigh);
task_runner()->RunPendingTasks();
EXPECT_FALSE(ran1);
EXPECT_TRUE(ran2);
EXPECT_TRUE(sync_point_manager()->IsSyncTokenReleased(sync_token));
ScheduleTask(0, -1, -1); // task 0: seq 0, no wait, no release
ScheduleTask(1, -1, 0); // task 1: seq 1, no wait, release 0
ScheduleTask(2, 0, -1); // task 2: seq 2, wait 0, no release
task_runner()->RunPendingTasks();
EXPECT_TRUE(ran1);
RunAllPendingTasks();
release_state->Destroy();
const int expected_task_order[] = {1, 2, 0};
EXPECT_THAT(tasks_executed(), testing::ElementsAreArray(expected_task_order));
}
TEST_F(SchedulerTest, SequenceDoesNotWaitForInvalidFence) {
SequenceId sequence_id1 =
scheduler()->CreateSequence(SchedulingPriority::kNormal);
TEST_F(SchedulerTaskRunOrderTest, ReleaseSequenceHasPriorityOfWaiter) {
CreateSequence(0, SchedulingPriority::kLow);
CreateSequence(1, SchedulingPriority::kNormal);
CreateSequence(2, SchedulingPriority::kHigh);
SequenceId sequence_id2 =
scheduler()->CreateSequence(SchedulingPriority::kNormal);
CommandBufferNamespace namespace_id = CommandBufferNamespace::GPU_IO;
CommandBufferId command_buffer_id = CommandBufferId::FromUnsafeValue(1);
scoped_refptr<SyncPointClientState> release_state =
sync_point_manager()->CreateSyncPointClientState(
namespace_id, command_buffer_id, sequence_id2);
ScheduleTask(0, -1, 0); // task 0: seq 0, no wait, release 0
ScheduleTask(1, 0, -1); // task 1: seq 1, wait 0, no release
ScheduleTask(2, -1, -1); // task 2: seq 2, no wait, no release
uint64_t release = 1;
SyncToken sync_token(namespace_id, 0, command_buffer_id, release);
RunAllPendingTasks();
bool ran1 = false;
scheduler()->ScheduleTask(Scheduler::Task(
sequence_id1, GetClosure([&] { ran1 = true; }), {sync_token}));
const int expected_task_order[] = {2, 0, 1};
EXPECT_THAT(tasks_executed(), testing::ElementsAreArray(expected_task_order));
}
// Release task is scheduled after wait task so release is treated as non-
// existent.
bool ran2 = false;
scheduler()->ScheduleTask(Scheduler::Task(sequence_id2, GetClosure([&] {
release_state->ReleaseFenceSync(
release);
ran2 = true;
}),
std::vector<SyncToken>()));
TEST_F(SchedulerTaskRunOrderTest, ReleaseSequenceRevertsToDefaultPriority) {
CreateSequence(0, SchedulingPriority::kNormal);
CreateSequence(1, SchedulingPriority::kLow);
CreateSequence(2, SchedulingPriority::kHigh);
task_runner()->RunPendingTasks();
EXPECT_TRUE(ran1);
EXPECT_FALSE(ran2);
EXPECT_FALSE(sync_point_manager()->IsSyncTokenReleased(sync_token));
ScheduleTask(0, -1, -1); // task 0: seq 0, no wait, no release
ScheduleTask(1, -1, 0); // task 1: seq 1, no wait, release 0
ScheduleTask(2, 0, -1); // task 2: seq 2, wait 0, no release
task_runner()->RunPendingTasks();
EXPECT_TRUE(ran2);
EXPECT_TRUE(sync_point_manager()->IsSyncTokenReleased(sync_token));
DestroySequence(2);
release_state->Destroy();
RunAllPendingTasks();
const int expected_task_order[] = {0, 1};
EXPECT_THAT(tasks_executed(), testing::ElementsAreArray(expected_task_order));
}
TEST_F(SchedulerTest, ReleaseSequenceIsPrioritized) {
SequenceId sequence_id1 =
scheduler()->CreateSequence(SchedulingPriority::kNormal);
TEST_F(SchedulerTaskRunOrderTest, ReleaseSequenceCircularRelease) {
CreateSequence(0, SchedulingPriority::kLow);
CreateSequence(1, SchedulingPriority::kNormal);
CreateSequence(2, SchedulingPriority::kHigh);
bool ran1 = false;
scheduler()->ScheduleTask(Scheduler::Task(sequence_id1,
GetClosure([&] { ran1 = true; }),
std::vector<SyncToken>()));
ScheduleTask(0, -1, -1); // task 0: seq 0, no wait, no release
ScheduleTask(1, -1, -1); // task 1: seq 1, no wait, no release
ScheduleTask(2, -1, -1); // task 2: seq 2, no wait, no release
SequenceId sequence_id2 =
scheduler()->CreateSequence(SchedulingPriority::kLow);
CommandBufferNamespace namespace_id = CommandBufferNamespace::GPU_IO;
CommandBufferId command_buffer_id = CommandBufferId::FromUnsafeValue(1);
scoped_refptr<SyncPointClientState> release_state =
sync_point_manager()->CreateSyncPointClientState(
namespace_id, command_buffer_id, sequence_id2);
ScheduleTask(0, -1, 0); // task 3: seq 0, no wait, release 0
ScheduleTask(0, -1, -1); // task 4: seq 0, no wait, no release
uint64_t release = 1;
bool ran2 = false;
scheduler()->ScheduleTask(Scheduler::Task(sequence_id2, GetClosure([&] {
release_state->ReleaseFenceSync(
release);
ran2 = true;
}),
std::vector<SyncToken>()));
ScheduleTask(1, 0, 1); // task 5: seq 1, wait 0, release 1
ScheduleTask(1, -1, -1); // task 6: seq 1, no wait, no release
bool ran3 = false;
SyncToken sync_token(namespace_id, 0, command_buffer_id, release);
SequenceId sequence_id3 =
scheduler()->CreateSequence(SchedulingPriority::kHigh);
scheduler()->ScheduleTask(Scheduler::Task(
sequence_id3, GetClosure([&] { ran3 = true; }), {sync_token}));
ScheduleTask(2, 1, 2); // task 7: seq 2, wait 1, release 2
ScheduleTask(2, -1, -1); // task 8: seq 2, no wait, no release
task_runner()->RunPendingTasks();
EXPECT_FALSE(ran1);
EXPECT_TRUE(ran2);
EXPECT_FALSE(ran3);
EXPECT_TRUE(sync_point_manager()->IsSyncTokenReleased(sync_token));
ScheduleTask(0, 2, 3); // task 9: seq 0, wait 2, releases 3
ScheduleTask(1, 3, 4); // task 10: seq 1, wait 3, releases 4
ScheduleTask(2, 4, -1); // task 11: seq 2, wait 4, no release
task_runner()->RunPendingTasks();
EXPECT_FALSE(ran1);
EXPECT_TRUE(ran3);
ScheduleTask(0, -1, -1); // task 12: seq 0, no wait, no release
ScheduleTask(1, -1, -1); // task 13: seq 1, no wait, no release
ScheduleTask(2, -1, -1); // task 14: seq 2, no wait, no release
task_runner()->RunPendingTasks();
EXPECT_TRUE(ran1);
RunAllPendingTasks();
release_state->Destroy();
const int expected_task_order[] = {0, 1, 2, 3, 4, 5, 6, 7,
8, 9, 10, 11, 14, 13, 12};
EXPECT_THAT(tasks_executed(), testing::ElementsAreArray(expected_task_order));
}
TEST_F(SchedulerTaskRunOrderTest, WaitOnSelfShouldNotBlockSequence) {
CreateSequence(0, SchedulingPriority::kHigh);
CreateSyncToken(0, 0); // declare sync_token 0 on seq 1
// Dummy order number to avoid the wait_order_num <= processed_order_num + 1
// check in SyncPointOrderData::ValidateReleaseOrderNum.
sync_point_manager()->GenerateOrderNumber();
ScheduleTask(0, 0, -1); // task 0: seq 0, wait 0, no release
RunAllPendingTasks();
const int expected_task_order[] = {0};
EXPECT_THAT(tasks_executed(), testing::ElementsAreArray(expected_task_order));
}
TEST_F(SchedulerTest, ReleaseSequenceShouldYield) {
......@@ -392,32 +451,6 @@ TEST_F(SchedulerTest, ReentrantEnableSequenceShouldNotDeadlock) {
release_state2->Destroy();
}
TEST_F(SchedulerTest, WaitOnSelfShouldNotBlockSequence) {
SequenceId sequence_id =
scheduler()->CreateSequence(SchedulingPriority::kHigh);
CommandBufferNamespace namespace_id = CommandBufferNamespace::GPU_IO;
CommandBufferId command_buffer_id = CommandBufferId::FromUnsafeValue(1);
scoped_refptr<SyncPointClientState> release_state =
sync_point_manager()->CreateSyncPointClientState(
namespace_id, command_buffer_id, sequence_id);
// Dummy order number to avoid the wait_order_num <= processed_order_num + 1
// check in SyncPointOrderData::ValidateReleaseOrderNum.
sync_point_manager()->GenerateOrderNumber();
uint64_t release = 1;
SyncToken sync_token(namespace_id, 0, command_buffer_id, release);
bool ran = false;
scheduler()->ScheduleTask(Scheduler::Task(
sequence_id, GetClosure([&]() { ran = true; }), {sync_token}));
task_runner()->RunPendingTasks();
EXPECT_TRUE(ran);
EXPECT_FALSE(sync_point_manager()->IsSyncTokenReleased(sync_token));
release_state->Destroy();
}
TEST_F(SchedulerTest, ClientWaitIsPrioritized) {
SequenceId sequence_id1 =
scheduler()->CreateSequence(SchedulingPriority::kNormal);
......@@ -482,5 +515,241 @@ TEST_F(SchedulerTest, ClientWaitIsPrioritized) {
EXPECT_TRUE(ran2);
}
} // namespace
TEST_F(SchedulerTest, StreamPriorities) {
SequenceId seq_id1 = scheduler()->CreateSequence(SchedulingPriority::kLow);
SequenceId seq_id2 = scheduler()->CreateSequence(SchedulingPriority::kNormal);
SequenceId seq_id3 = scheduler()->CreateSequence(SchedulingPriority::kHigh);
CommandBufferNamespace namespace_id = CommandBufferNamespace::GPU_IO;
CommandBufferId command_buffer_id1 = CommandBufferId::FromUnsafeValue(1);
CommandBufferId command_buffer_id2 = CommandBufferId::FromUnsafeValue(2);
base::AutoLock auto_lock(scheduler()->lock_);
Scheduler::Sequence* seq1 = scheduler()->GetSequence(seq_id1);
Scheduler::Sequence* seq2 = scheduler()->GetSequence(seq_id2);
Scheduler::Sequence* seq3 = scheduler()->GetSequence(seq_id3);
// Initial default priorities.
EXPECT_EQ(SchedulingPriority::kLow, seq1->current_priority());
EXPECT_EQ(SchedulingPriority::kNormal, seq2->current_priority());
EXPECT_EQ(SchedulingPriority::kHigh, seq3->current_priority());
SyncToken sync_token1(namespace_id, 0, command_buffer_id1, 1);
SyncToken sync_token2(namespace_id, 0, command_buffer_id2, 1);
// Wait priorities propagate.
seq2->AddWaitFence(sync_token1, 1, seq_id1, seq1);
EXPECT_EQ(SchedulingPriority::kNormal, seq1->current_priority());
EXPECT_EQ(SchedulingPriority::kNormal, seq2->current_priority());
EXPECT_EQ(SchedulingPriority::kHigh, seq3->current_priority());
seq2->AddWaitFence(sync_token1, 1, seq_id1, seq1);
EXPECT_EQ(SchedulingPriority::kNormal, seq1->current_priority());
EXPECT_EQ(SchedulingPriority::kNormal, seq2->current_priority());
EXPECT_EQ(SchedulingPriority::kHigh, seq3->current_priority());
seq3->AddWaitFence(sync_token2, 2, seq_id2, seq2);
EXPECT_EQ(SchedulingPriority::kHigh, seq1->current_priority());
EXPECT_EQ(SchedulingPriority::kHigh, seq2->current_priority());
EXPECT_EQ(SchedulingPriority::kHigh, seq3->current_priority());
// Release priority propagate.
seq3->RemoveWaitFence(sync_token2, 2, seq_id2);
EXPECT_EQ(SchedulingPriority::kNormal, seq1->current_priority());
EXPECT_EQ(SchedulingPriority::kNormal, seq2->current_priority());
EXPECT_EQ(SchedulingPriority::kHigh, seq3->current_priority());
seq2->RemoveWaitFence(sync_token1, 1, seq_id1);
EXPECT_EQ(SchedulingPriority::kNormal, seq1->current_priority());
EXPECT_EQ(SchedulingPriority::kNormal, seq2->current_priority());
EXPECT_EQ(SchedulingPriority::kHigh, seq3->current_priority());
seq2->RemoveWaitFence(sync_token1, 1, seq_id1);
EXPECT_EQ(SchedulingPriority::kLow, seq1->current_priority());
EXPECT_EQ(SchedulingPriority::kNormal, seq2->current_priority());
EXPECT_EQ(SchedulingPriority::kHigh, seq3->current_priority());
{
base::AutoUnlock auto_unlock(scheduler()->lock_);
scheduler()->DestroySequence(seq_id1);
scheduler()->DestroySequence(seq_id2);
scheduler()->DestroySequence(seq_id3);
}
}
TEST_F(SchedulerTest, StreamDestroyRemovesPriorities) {
SequenceId seq_id1 = scheduler()->CreateSequence(SchedulingPriority::kLow);
SequenceId seq_id2 = scheduler()->CreateSequence(SchedulingPriority::kNormal);
SequenceId seq_id3 = scheduler()->CreateSequence(SchedulingPriority::kHigh);
CommandBufferNamespace namespace_id = CommandBufferNamespace::GPU_IO;
CommandBufferId command_buffer_id1 = CommandBufferId::FromUnsafeValue(1);
CommandBufferId command_buffer_id2 = CommandBufferId::FromUnsafeValue(2);
base::AutoLock auto_lock(scheduler()->lock_);
Scheduler::Sequence* seq1 = scheduler()->GetSequence(seq_id1);
Scheduler::Sequence* seq2 = scheduler()->GetSequence(seq_id2);
Scheduler::Sequence* seq3 = scheduler()->GetSequence(seq_id3);
SyncToken sync_token1(namespace_id, 0, command_buffer_id1, 1);
SyncToken sync_token2(namespace_id, 0, command_buffer_id2, 1);
// Wait priorities propagate.
seq2->AddWaitFence(sync_token1, 1, seq_id1, seq1);
seq2->AddWaitFence(sync_token1, 1, seq_id1, seq1);
seq3->AddWaitFence(sync_token2, 2, seq_id2, seq2);
EXPECT_EQ(SchedulingPriority::kHigh, seq1->current_priority());
EXPECT_EQ(SchedulingPriority::kHigh, seq2->current_priority());
EXPECT_EQ(SchedulingPriority::kHigh, seq3->current_priority());
// Deleting waiting sequences removes priorities.
{
base::AutoUnlock auto_unlock(scheduler()->lock_);
scheduler()->DestroySequence(seq_id3);
}
EXPECT_EQ(SchedulingPriority::kNormal, seq1->current_priority());
EXPECT_EQ(SchedulingPriority::kNormal, seq2->current_priority());
{
base::AutoUnlock auto_unlock(scheduler()->lock_);
scheduler()->DestroySequence(seq_id2);
}
EXPECT_EQ(SchedulingPriority::kLow, seq1->current_priority());
{
base::AutoUnlock auto_unlock(scheduler()->lock_);
scheduler()->DestroySequence(seq_id1);
}
}
// crbug.com/781585#5: Test RemoveWait/AddWait/RemoveWait sequence.
TEST_F(SchedulerTest, StreamPriorityChangeWhileReleasing) {
SequenceId seq_id1 = scheduler()->CreateSequence(SchedulingPriority::kLow);
SequenceId seq_id2 = scheduler()->CreateSequence(SchedulingPriority::kNormal);
SequenceId seq_id3 = scheduler()->CreateSequence(SchedulingPriority::kHigh);
CommandBufferNamespace namespace_id = CommandBufferNamespace::GPU_IO;
CommandBufferId command_buffer_id1 = CommandBufferId::FromUnsafeValue(1);
CommandBufferId command_buffer_id2 = CommandBufferId::FromUnsafeValue(2);
base::AutoLock auto_lock(scheduler()->lock_);
Scheduler::Sequence* seq1 = scheduler()->GetSequence(seq_id1);
Scheduler::Sequence* seq2 = scheduler()->GetSequence(seq_id2);
Scheduler::Sequence* seq3 = scheduler()->GetSequence(seq_id3);
SyncToken sync_token1(namespace_id, 0, command_buffer_id1, 1);
SyncToken sync_token2(namespace_id, 0, command_buffer_id2, 2);
// Wait on same fence multiple times.
seq2->AddWaitFence(sync_token1, 1, seq_id1, seq1);
seq2->AddWaitFence(sync_token1, 1, seq_id1, seq1);
EXPECT_EQ(SchedulingPriority::kNormal, seq1->current_priority());
EXPECT_EQ(SchedulingPriority::kNormal, seq2->current_priority());
EXPECT_EQ(SchedulingPriority::kHigh, seq3->current_priority());
// Begin releasing fences.
seq2->RemoveWaitFence(sync_token1, 1, seq_id1);
EXPECT_EQ(SchedulingPriority::kNormal, seq1->current_priority());
EXPECT_EQ(SchedulingPriority::kNormal, seq2->current_priority());
EXPECT_EQ(SchedulingPriority::kHigh, seq3->current_priority());
// Add wait fence with higher priority. This replicates a possible race.
seq3->AddWaitFence(sync_token2, 1, seq_id2, seq2);
EXPECT_EQ(SchedulingPriority::kHigh, seq1->current_priority());
EXPECT_EQ(SchedulingPriority::kHigh, seq2->current_priority());
EXPECT_EQ(SchedulingPriority::kHigh, seq3->current_priority());
// Finish removing fences.
seq2->RemoveWaitFence(sync_token1, 1, seq_id1);
EXPECT_EQ(SchedulingPriority::kLow, seq1->current_priority());
EXPECT_EQ(SchedulingPriority::kHigh, seq2->current_priority());
EXPECT_EQ(SchedulingPriority::kHigh, seq3->current_priority());
seq3->RemoveWaitFence(sync_token2, 1, seq_id2);
EXPECT_EQ(SchedulingPriority::kLow, seq1->current_priority());
EXPECT_EQ(SchedulingPriority::kNormal, seq2->current_priority());
EXPECT_EQ(SchedulingPriority::kHigh, seq3->current_priority());
{
base::AutoUnlock auto_unlock(scheduler()->lock_);
scheduler()->DestroySequence(seq_id1);
scheduler()->DestroySequence(seq_id2);
scheduler()->DestroySequence(seq_id3);
}
}
TEST_F(SchedulerTest, CircularPriorities) {
SequenceId seq_id1 = scheduler()->CreateSequence(SchedulingPriority::kHigh);
SequenceId seq_id2 = scheduler()->CreateSequence(SchedulingPriority::kLow);
SequenceId seq_id3 = scheduler()->CreateSequence(SchedulingPriority::kNormal);
CommandBufferNamespace namespace_id = CommandBufferNamespace::GPU_IO;
CommandBufferId command_buffer_id2 = CommandBufferId::FromUnsafeValue(2);
CommandBufferId command_buffer_id3 = CommandBufferId::FromUnsafeValue(3);
base::AutoLock auto_lock(scheduler()->lock_);
Scheduler::Sequence* seq1 = scheduler()->GetSequence(seq_id1);
Scheduler::Sequence* seq2 = scheduler()->GetSequence(seq_id2);
Scheduler::Sequence* seq3 = scheduler()->GetSequence(seq_id3);
EXPECT_EQ(SchedulingPriority::kHigh, seq1->current_priority());
EXPECT_EQ(SchedulingPriority::kLow, seq2->current_priority());
EXPECT_EQ(SchedulingPriority::kNormal, seq3->current_priority());
SyncToken sync_token_seq2_1(namespace_id, 0, command_buffer_id2, 1);
SyncToken sync_token_seq2_2(namespace_id, 0, command_buffer_id2, 2);
SyncToken sync_token_seq2_3(namespace_id, 0, command_buffer_id2, 3);
SyncToken sync_token_seq3_1(namespace_id, 0, command_buffer_id3, 1);
seq3->AddWaitFence(sync_token_seq2_1, 1, seq_id2, seq2);
EXPECT_EQ(SchedulingPriority::kHigh, seq1->current_priority());
EXPECT_EQ(SchedulingPriority::kNormal, seq2->current_priority());
EXPECT_EQ(SchedulingPriority::kNormal, seq3->current_priority());
seq1->AddWaitFence(sync_token_seq2_2, 2, seq_id2, seq2);
EXPECT_EQ(SchedulingPriority::kHigh, seq1->current_priority());
EXPECT_EQ(SchedulingPriority::kHigh, seq2->current_priority());
EXPECT_EQ(SchedulingPriority::kNormal, seq3->current_priority());
seq3->AddWaitFence(sync_token_seq2_3, 3, seq_id2, seq2);
EXPECT_EQ(SchedulingPriority::kHigh, seq1->current_priority());
EXPECT_EQ(SchedulingPriority::kHigh, seq2->current_priority());
EXPECT_EQ(SchedulingPriority::kNormal, seq3->current_priority());
seq2->AddWaitFence(sync_token_seq3_1, 4, seq_id3, seq3);
EXPECT_EQ(SchedulingPriority::kHigh, seq1->current_priority());
EXPECT_EQ(SchedulingPriority::kHigh, seq2->current_priority());
EXPECT_EQ(SchedulingPriority::kHigh, seq3->current_priority());
seq3->RemoveWaitFence(sync_token_seq2_1, 1, seq_id2);
EXPECT_EQ(SchedulingPriority::kHigh, seq1->current_priority());
EXPECT_EQ(SchedulingPriority::kHigh, seq2->current_priority());
EXPECT_EQ(SchedulingPriority::kHigh, seq3->current_priority());
seq1->RemoveWaitFence(sync_token_seq2_2, 2, seq_id2);
EXPECT_EQ(SchedulingPriority::kHigh, seq1->current_priority());
EXPECT_EQ(SchedulingPriority::kHigh, seq2->current_priority());
EXPECT_EQ(SchedulingPriority::kHigh, seq3->current_priority());
seq3->RemoveWaitFence(sync_token_seq2_3, 3, seq_id2);
EXPECT_EQ(SchedulingPriority::kHigh, seq1->current_priority());
EXPECT_EQ(SchedulingPriority::kLow, seq2->current_priority());
EXPECT_EQ(SchedulingPriority::kNormal, seq3->current_priority());
{
base::AutoUnlock auto_unlock(scheduler()->lock_);
scheduler()->DestroySequence(seq_id1);
scheduler()->DestroySequence(seq_id2);
scheduler()->DestroySequence(seq_id3);
}
}
} // namespace gpu
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment