blob: 89e541508abd407c331401b02b0a988b89a06f91 [file] [log] [blame] [edit]
// Copyright 2021 The SwiftShader Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "VkTimelineSemaphore.hpp"
#include "VkSemaphore.hpp"
#include "marl/blockingcall.h"
#include "marl/conditionvariable.h"
#include <vector>
namespace vk {
TimelineSemaphore::TimelineSemaphore(const VkSemaphoreCreateInfo *pCreateInfo, void *mem, const VkAllocationCallbacks *pAllocator)
: Semaphore(VK_SEMAPHORE_TYPE_TIMELINE)
{
SemaphoreCreateInfo info(pCreateInfo);
ASSERT(info.semaphoreType == VK_SEMAPHORE_TYPE_TIMELINE);
type = info.semaphoreType;
shared = marl::Allocator::Default->make_shared<TimelineSemaphore::Shared>(marl::Allocator::Default, info.initialPayload);
}
TimelineSemaphore::TimelineSemaphore()
: Semaphore(VK_SEMAPHORE_TYPE_TIMELINE)
{
type = VK_SEMAPHORE_TYPE_TIMELINE;
shared = marl::Allocator::Default->make_shared<TimelineSemaphore::Shared>(marl::Allocator::Default, 0);
}
size_t TimelineSemaphore::ComputeRequiredAllocationSize(const VkSemaphoreCreateInfo *pCreateInfo)
{
return 0;
}
void TimelineSemaphore::destroy(const VkAllocationCallbacks *pAllocator)
{
}
void TimelineSemaphore::signal(uint64_t value)
{
return shared->signal(value);
}
void TimelineSemaphore::Shared::signal(uint64_t value)
{
marl::lock lock(mutex);
if(counter < value)
{
counter = value;
cv.notify_all();
for(auto dep : deps)
{
dep->signal(id, counter);
}
}
}
void TimelineSemaphore::wait(uint64_t value)
{
shared->wait(value);
}
void TimelineSemaphore::Shared::wait(uint64_t value)
{
marl::lock lock(mutex);
cv.wait(lock, [&]() { return counter >= value; });
}
uint64_t TimelineSemaphore::getCounterValue()
{
return shared->getCounterValue();
}
uint64_t TimelineSemaphore::Shared::getCounterValue()
{
marl::lock lock(mutex);
return counter;
}
std::atomic<int> TimelineSemaphore::Shared::nextId;
TimelineSemaphore::Shared::Shared(marl::Allocator *allocator, uint64_t initialState)
: cv(allocator)
, counter(initialState)
, id(nextId++)
{
}
void TimelineSemaphore::Shared::signal(int parentId, uint64_t value)
{
marl::lock lock(mutex);
auto it = waitMap.find(parentId);
// Either we aren't waiting for a signal, or parentId is not something we're waiting for
// Reject any signals that we aren't waiting on
if(counter == 0 && it != waitMap.end() && value == it->second)
{
// Stop waiting on all parents once we find a signal
waitMap.clear();
counter = 1;
cv.notify_all();
for(auto dep : deps)
{
dep->signal(id, counter);
}
}
}
void TimelineSemaphore::addDependent(TimelineSemaphore &other, uint64_t waitValue)
{
shared->addDependent(other);
other.addDependency(shared->id, waitValue);
}
void TimelineSemaphore::Shared::addDependent(TimelineSemaphore &other)
{
marl::lock lock(mutex);
deps.push_back(other.shared);
}
void TimelineSemaphore::addDependency(int id, uint64_t waitValue)
{
shared->addDependency(id, waitValue);
}
void TimelineSemaphore::Shared::addDependency(int id, uint64_t waitValue)
{
marl::lock lock(mutex);
auto mapPos = waitMap.find(id);
ASSERT(mapPos == waitMap.end());
waitMap.insert(mapPos, std::make_pair(id, waitValue));
}
} // namespace vk