Kernel: Actually wake up the requested number of threads in Semaphore::Release.

Also properly keep track of data in guest memory, this fixes managing the semaphore from userland.

It was found that Semaphores are actually Condition Variables, with Release(1) and Release(-1) being equivalent to notify_one and notify_all. We should change the name of the class to reflect this.
This commit is contained in:
Subv 2018-01-08 14:14:30 -05:00 committed by bunnei
parent 1bbe9309da
commit db3a525166
4 changed files with 18 additions and 21 deletions

View file

@ -273,9 +273,8 @@ std::vector<std::unique_ptr<WaitTreeItem>> WaitTreeSemaphore::GetChildren() cons
std::vector<std::unique_ptr<WaitTreeItem>> list(WaitTreeWaitObject::GetChildren());
const auto& semaphore = static_cast<const Kernel::Semaphore&>(object);
list.push_back(
std::make_unique<WaitTreeText>(tr("available count = %1").arg(semaphore.available_count)));
list.push_back(std::make_unique<WaitTreeText>(tr("max count = %1").arg(semaphore.max_count)));
list.push_back(std::make_unique<WaitTreeText>(
tr("available count = %1").arg(semaphore.GetAvailableCount())));
return list;
}

View file

@ -18,9 +18,6 @@ ResultVal<SharedPtr<Semaphore>> Semaphore::Create(VAddr guest_addr, VAddr mutex_
std::string name) {
SharedPtr<Semaphore> semaphore(new Semaphore);
// When the semaphore is created, some slots are reserved for other threads,
// and the rest is reserved for the caller thread;
semaphore->available_count = Memory::Read32(guest_addr);
semaphore->name = std::move(name);
semaphore->guest_addr = guest_addr;
semaphore->mutex_addr = mutex_addr;
@ -32,34 +29,36 @@ ResultVal<SharedPtr<Semaphore>> Semaphore::Create(VAddr guest_addr, VAddr mutex_
}
bool Semaphore::ShouldWait(Thread* thread) const {
return available_count <= 0;
return GetAvailableCount() <= 0;
}
void Semaphore::Acquire(Thread* thread) {
if (available_count <= 0)
if (GetAvailableCount() <= 0)
return;
--available_count;
UpdateGuestState();
SetAvailableCount(GetAvailableCount() - 1);
}
ResultCode Semaphore::Release(s32 target) {
++available_count;
UpdateGuestState();
if (target == -1) {
// When -1, wake up all waiting threads
SetAvailableCount(GetWaitingThreads().size());
WakeupAllWaitingThreads();
} else {
// Otherwise, wake up just a single thread
SetAvailableCount(target);
WakeupWaitingThread(GetHighestPriorityReadyThread());
}
return RESULT_SUCCESS;
}
void Semaphore::UpdateGuestState() {
Memory::Write32(guest_addr, available_count);
s32 Semaphore::GetAvailableCount() const {
return Memory::Read32(guest_addr);
}
void Semaphore::SetAvailableCount(s32 value) const {
Memory::Write32(guest_addr, value);
}
} // namespace Kernel

View file

@ -13,6 +13,7 @@
namespace Kernel {
// TODO(Subv): This is actually a Condition Variable.
class Semaphore final : public WaitObject {
public:
/**
@ -39,8 +40,9 @@ public:
return HANDLE_TYPE;
}
s32 max_count; ///< Maximum number of simultaneous holders the semaphore can have
s32 available_count; ///< Number of free slots left in the semaphore
s32 GetAvailableCount() const;
void SetAvailableCount(s32 value) const;
std::string name; ///< Name of semaphore (optional)
VAddr guest_addr; ///< Address of the guest semaphore value
VAddr mutex_addr; ///< (optional) Address of guest mutex value associated with this semaphore,
@ -59,9 +61,6 @@ public:
private:
Semaphore();
~Semaphore() override;
/// Updates the state of the object tracking this semaphore in guest memory
void UpdateGuestState();
};
} // namespace Kernel

View file

@ -501,7 +501,7 @@ static ResultCode WaitProcessWideKeyAtomic(VAddr mutex_addr, VAddr semaphore_add
semaphore->name = Common::StringFromFormat("semaphore-%llx", semaphore_addr);
}
ASSERT(semaphore->available_count == 0);
ASSERT(semaphore->GetAvailableCount() == 0);
ASSERT(semaphore->mutex_addr == mutex_addr);
auto wakeup_callback = [mutex, nano_seconds](ThreadWakeupReason reason,