RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-05-31 07:18:11 +00:00
Code Issues Activity Actions

Kernel: Make DoubleBuffer use a KBuffer instead of kmalloc()ing

Browse source 
Background: DoubleBuffer is a handy buffer class in the kernel that
allows you to keep writing to it from the "outside" while the "inside"
reads from it. It's used for things like LocalSocket and TTY's.
Internally, it has a read buffer and a write buffer, but the two will
swap places when the read buffer is exhausted (by reading from it.)

Before this patch, it was internally implemented as two Vector<u8>
that we would swap between when the reader side had exhausted the data
in the read buffer. Now instead we preallocate a large KBuffer (64KB*2)
on DoubleBuffer construction and use that throughout its lifetime.

This removes all the kmalloc heap traffic caused by DoubleBuffers :^)
This commit is contained in:
Andreas Kling 2020-01-20 16:08:49 +01:00
parent 0a282e0a02
commit f4f958f99f
6 changed files with 54 additions and 37 deletions
Download patch file Download diff file Expand all files Collapse all files

45
Kernel/DoubleBuffer.cpp
View file

@ -26,21 +26,33 @@
#include <Kernel/DoubleBuffer.h>
inline void DoubleBuffer::compute_emptiness()
inline void DoubleBuffer::compute_lockfree_metadata()
{
m_empty = m_read_buffer_index >= m_read_buffer->size() && m_write_buffer->is_empty();
InterruptDisabler disabler;
m_empty = m_read_buffer_index >= m_read_buffer->size && m_write_buffer->size == 0;
m_space_for_writing = m_capacity - m_write_buffer->size;
}
DoubleBuffer::DoubleBuffer(size_t capacity)
: m_write_buffer(&m_buffer1)
, m_read_buffer(&m_buffer2)
, m_storage(KBuffer::create_with_size(capacity * 2, Region::Access::Read | Region::Access::Write, "DoubleBuffer"))
, m_capacity(capacity)
{
m_buffer1.data = m_storage.data();
m_buffer1.size = 0;
m_buffer2.data = m_storage.data() + capacity;
m_buffer2.size = 0;
m_space_for_writing = capacity;
}
void DoubleBuffer::flip()
{
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);
if (m_write_buffer->capacity() < 32)
m_write_buffer->clear_with_capacity();
else
m_write_buffer->clear();
m_write_buffer->size = 0;
m_read_buffer_index = 0;
compute_emptiness();
compute_lockfree_metadata();
}
ssize_t DoubleBuffer::write(const u8* data, ssize_t size)
@ -48,8 +60,11 @@ ssize_t DoubleBuffer::write(const u8* data, ssize_t size)
if (!size)
return 0;
LOCKER(m_lock);
m_write_buffer->append(data, size);
compute_emptiness();
ASSERT(size <= (ssize_t)space_for_writing());
u8* write_ptr = m_write_buffer->data + m_write_buffer->size;
m_write_buffer->size += size;
compute_lockfree_metadata();
memcpy(write_ptr, data, size);
return size;
}
@ -58,13 +73,13 @@ ssize_t DoubleBuffer::read(u8* data, ssize_t size)
if (!size)
return 0;
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->size != 0)
flip();
if (m_read_buffer_index >= m_read_buffer->size())
if (m_read_buffer_index >= m_read_buffer->size)
return 0;
ssize_t nread = min((ssize_t)m_read_buffer->size() - m_read_buffer_index, size);
memcpy(data, m_read_buffer->data() + m_read_buffer_index, nread);
ssize_t nread = min((ssize_t)m_read_buffer->size - (ssize_t)m_read_buffer_index, size);
memcpy(data, m_read_buffer->data + m_read_buffer_index, nread);
m_read_buffer_index += nread;
compute_emptiness();
compute_lockfree_metadata();
return nread;
}