Ladybird/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-06-11 10:18:15 +09:00
Code Activity

Add internal locking to DoubleBuffer.

Browse source
This commit is contained in:
Andreas Kling 2019-01-15 21:43:38 +01:00
parent e42f090ed3
commit 52c004eb53
Notes: sideshowbarker 2024-07-19 16:02:01 +09:00
2 changed files with 16 additions and 2 deletions
Download patch file Download diff file Expand all files Collapse all files

11
Kernel/DoubleBuffer.cpp
View file

@ -1,8 +1,12 @@
#include "DoubleBuffer.h" #include "DoubleBuffer.h"
inline void DoubleBuffer::compute_emptiness()
{
m_empty = m_read_buffer_index >= m_read_buffer->size() && m_write_buffer->is_empty();
}
void DoubleBuffer::flip() void DoubleBuffer::flip()
{ {
InterruptDisabler disabler;
ASSERT(m_read_buffer_index == m_read_buffer->size()); ASSERT(m_read_buffer_index == m_read_buffer->size());
swap(m_read_buffer, m_write_buffer); swap(m_read_buffer, m_write_buffer);
if (m_write_buffer->capacity() < 32) if (m_write_buffer->capacity() < 32)
@ -10,16 +14,20 @@ void DoubleBuffer::flip()
else else
m_write_buffer->clear(); m_write_buffer->clear();
m_read_buffer_index = 0; m_read_buffer_index = 0;
compute_emptiness();
} }
ssize_t DoubleBuffer::write(const byte* data, size_t size) ssize_t DoubleBuffer::write(const byte* data, size_t size)
{ {
LOCKER(m_lock);
m_write_buffer->append(data, size); m_write_buffer->append(data, size);
compute_emptiness();
return size; return size;
} }
ssize_t DoubleBuffer::read(byte* data, size_t size) ssize_t DoubleBuffer::read(byte* data, size_t size)
{ {
LOCKER(m_lock);
if (m_read_buffer_index >= m_read_buffer->size() && !m_write_buffer->is_empty()) if (m_read_buffer_index >= m_read_buffer->size() && !m_write_buffer->is_empty())
flip(); flip();
if (m_read_buffer_index >= m_read_buffer->size()) if (m_read_buffer_index >= m_read_buffer->size())
@ -27,5 +35,6 @@ ssize_t DoubleBuffer::read(byte* data, size_t size)
ssize_t nread = min(m_read_buffer->size() - m_read_buffer_index, size); ssize_t nread = min(m_read_buffer->size() - m_read_buffer_index, size);
memcpy(data, m_read_buffer->data() + m_read_buffer_index, nread); memcpy(data, m_read_buffer->data() + m_read_buffer_index, nread);
m_read_buffer_index += nread; m_read_buffer_index += nread;
compute_emptiness();
return nread; return nread;
} }

7
Kernel/DoubleBuffer.h
View file

@ -2,6 +2,7 @@
#include <AK/Types.h> #include <AK/Types.h>
#include <AK/Vector.h> #include <AK/Vector.h>
#include <AK/Lock.h>
class DoubleBuffer { class DoubleBuffer {
public: public:
@ -14,16 +15,20 @@ public:
ssize_t write(const byte*, size_t); ssize_t write(const byte*, size_t);
ssize_t read(byte*, size_t); ssize_t read(byte*, size_t);
bool is_empty() const { return m_read_buffer_index >= m_read_buffer->size() && m_write_buffer->is_empty(); } bool is_empty() const { return m_empty; }
// FIXME: Isn't this racy? What if we get interrupted between getting the buffer pointer and dereferencing it?
size_t bytes_in_write_buffer() const { return m_write_buffer->size(); } size_t bytes_in_write_buffer() const { return m_write_buffer->size(); }
private: private:
void flip(); void flip();
void compute_emptiness();
Vector<byte>* m_write_buffer { nullptr }; Vector<byte>* m_write_buffer { nullptr };
Vector<byte>* m_read_buffer { nullptr }; Vector<byte>* m_read_buffer { nullptr };
Vector<byte> m_buffer1; Vector<byte> m_buffer1;
Vector<byte> m_buffer2; Vector<byte> m_buffer2;
size_t m_read_buffer_index { 0 }; size_t m_read_buffer_index { 0 };
bool m_empty { true };
SpinLock m_lock;
}; };