Google Git
Sign in
pigweed / pigweed / pigweed / 0c87be526cb2bbc0ef32896f6548e14c047f4733 / . / pw_stream / docs.rst
blob: 951e9d4563309bdff657ad88e5c8747bec039288 [file] [log] [blame]
.. _module-pw_stream:
.. cpp:namespace-push:: pw::stream
=========
pw_stream
=========
``pw_stream`` provides a foundational interface for streaming data from one part
of a system to another. In the simplest use cases, this is basically a memcpy
behind a reusable interface that can be passed around the system. On the other
hand, the flexibility of this interface means a ``pw_stream`` could terminate is
something more complex, like a UART stream or flash memory.
--------
Overview
--------
At the most basic level, ``pw_stream``'s interfaces provide very simple handles
to enabling streaming data from one location in a system to an endpoint.
Example:
.. code-block:: cpp
Status DumpSensorData(pw::stream::Writer& writer) {
static char temp[64];
ImuSample imu_sample;
imu.GetSample(&info);
size_t bytes_written = imu_sample.AsCsv(temp, sizeof(temp));
return writer.Write(temp, bytes_written);
}
In this example, ``DumpSensorData()`` only cares that it has access to a
:cpp:class:`Writer` that it can use to stream data to using ``Writer::Write()``.
The :cpp:class:`Writer` itself can be backed by anything that can act as a data
"sink."
---------------------
pw::stream Interfaces
---------------------
There are three basic capabilities of a stream:
* Reading -- Bytes can be read from the stream.
* Writing -- Bytes can be written to the stream.
* Seeking -- The position in the stream can be changed.
``pw_stream`` provides a family of stream classes with different capabilities.
The most basic class, :cpp:class:`Stream` guarantees no functionality, while the
most capable class, :cpp:class:`SeekableReaderWriter` supports reading, writing,
and seeking.
Usage overview
==============
+-------------------------------------------+-----------------+------------------------------+
| pw::stream Interfaces | Accept in APIs? | Extend to create new stream? |
+===========================================+=================+==============================+
| :cpp:class:`Stream` | ❌ | ❌ |
+-------------------------------------------+-----------------+------------------------------+
| :cpp:class:`Reader` | ✅ | ❌ |
| | | |
| :cpp:class:`Writer` | | |
| | | |
| :cpp:class:`ReaderWriter` | | |
+-------------------------------------------+-----------------+------------------------------+
| :cpp:class:`SeekableReader` | ✅ | ✅ |
| | | |
| :cpp:class:`SeekableWriter` | | |
| | | |
| :cpp:class:`SeekableReaderWriter` | | |
+-------------------------------------------+-----------------+------------------------------+
| :cpp:class:`RelativeSeekableReader` | ✅ (rarely) | ✅ |
| | | |
| :cpp:class:`RelativeSeekableWriter` | | |
| | | |
| :cpp:class:`RelativeSeekableReaderWriter` | | |
+-------------------------------------------+-----------------+------------------------------+
| :cpp:class:`NonSeekableReader` | ❌ | ✅ |
| | | |
| :cpp:class:`NonSeekableWriter` | | |
| | | |
| :cpp:class:`NonSeekableReaderWriter` | | |
+-------------------------------------------+-----------------+------------------------------+
Interface documentation
=======================
Summary documentation for the ``pw_stream`` interfaces is below. See the API
comments in `pw_stream/public/pw_stream/stream.h
<https://cs.opensource.google/pigweed/pigweed/+/main:pw_stream/public/pw_stream/stream.h>`_
for full details.
.. cpp:class:: Stream
A generic stream that may support reading, writing, and seeking, but makes no
guarantees about whether any operations are supported. Stream serves as the
base for the Reader, Writer, and ReaderWriter interfaces.
Stream cannot be extended directly. Instead, work with one of the derived
classes that explicitly supports the required functionality. Stream should
almost never be used in APIs; accept a derived class with the required
capabilities instead.
All Stream methods are blocking. They return when the requested operation
completes.
**Public methods**
.. cpp:function:: bool readable() const
True if :cpp:func:`Read` is supported.
.. cpp:function:: bool writable() const
True if :cpp:func:`Write` is supported.
.. cpp:function:: bool seekable() const
True if :cpp:func:`Seek` is supported.
.. cpp:function:: Result<ByteSpan> Read(ByteSpan buffer)
.. cpp:function:: Result<ByteSpan> Read(void* buffer, size_t size_bytes)
Reads data from the stream into the provided buffer, if supported. As many
bytes as are available up to the buffer size are copied into the buffer.
Remaining bytes may by read in subsequent calls.
Returns:
* OK - Between 1 and dest.size_bytes() were successfully read. Returns
the span of read bytes.
* UNIMPLEMENTED - This stream does not support writing.
* FAILED_PRECONDITION - The Reader is not in state to read data.
* RESOURCE_EXHAUSTED - Unable to read any bytes at this time. No bytes
read. Try again once bytes become available.
* OUT_OF_RANGE - Reader has been exhausted, similar to EOF. No bytes were
read, no more will be read.
.. cpp:function:: Status Write(ConstByteSpan data)
Writes the provided data to the stream, if supported.
Returns:
* OK - Data was successfully accepted by the stream.
* UNIMPLEMENTED - This stream does not support writing.
* FAILED_PRECONDITION - The writer is not in a state to accept data.
* RESOURCE_EXHAUSTED - The writer was unable to write all of requested data
at this time. No data was written.
* OUT_OF_RANGE - The Writer has been exhausted, similar to EOF. No data was
written; no more will be written.
.. cpp:function:: Status Seek(ptrdiff_t offset, Whence origin = kBeginning)
Changes the current read & write position in the stream, if supported.
Returns:
* OK - Successfully updated the position.
* UNIMPLEMENTED - Seeking is not supported for this stream.
* OUT_OF_RANGE - Attempted to seek beyond the bounds of the stream. The
position is unchanged.
.. cpp:function:: size_t Tell() const
Returns the current read & write position in the stream, if supported.
Returns ``Stream::kUnknownPosition`` (``size_t(-1)``) if unsupported.
.. cpp:function:: size_t ConservativeReadLimit() const
Likely minimum bytes available to read. Returns ``kUnlimited``
(``size_t(-1)``) if there is no limit or it is unknown.
.. cpp:function:: size_t ConservativeWriteLimit() const
Likely minimum bytes available to write. Returns ``kUnlimited``
(``size_t(-1)``) if there is no limit or it is unknown.
**Private virtual methods**
Stream's public methods are non-virtual. The public methods call private
virtual methods that are implemented by derived classes.
.. cpp:function:: private virtual StatusWithSize DoRead(ByteSpan destination)
Virtual :cpp:func:`Read` function implemented by derived classes.
.. cpp:function:: private virtual Status DoWrite(ConstByteSpan data)
Virtual :cpp:func:`Write` function implemented by derived classes.
.. cpp:function:: private virtual Status DoSeek(ptrdiff_t offset, Whence origin)
Virtual :cpp:func:`Seek` function implemented by derived classes.
.. cpp:function:: private virtual size_t DoTell() const
Virtual :cpp:func:`Tell` function optionally implemented by derived classes.
The default implementation always returns ``kUnknownPosition``.
.. cpp:function:: private virtual size_t ConservativeLimit(LimitType limit_type)
Virtual function optionally implemented by derived classes that is used for
:cpp:func:`ConservativeReadLimit` and :cpp:func:`ConservativeWriteLimit`.
The default implementation returns ``kUnlimited`` or ``0`` depending on
whether the stream is readable/writable.
Reader interfaces
-----------------
.. cpp:class:: Reader : public Stream
A Stream that supports writing but not reading. The Write() method is hidden.
Use in APIs when:
* Must read from, but not write to, a stream.
* May or may not need seeking. Use a SeekableReader& if seeking is
required.
Inherit from when:
* Reader cannot be extended directly. Instead, extend SeekableReader,
NonSeekableReader, or (rarely) RelativeSeekableReader, as appropriate.
A Reader may or may not support seeking. Check seekable() or try calling
Seek() to determine if the stream is seekable.
.. cpp:class:: SeekableReader : public RelativeSeekableReader
A Reader that fully supports seeking.
Use in APIs when:
* Absolute seeking is required. Use Reader& if seeking is not required or
seek failures can be handled gracefully.
Inherit from when:
* Implementing a reader that supports absolute seeking.
.. cpp:class:: RelativeSeekableReader : public Reader
A Reader that at least partially supports seeking. Seeking within some range
of the current position works, but seeking beyond that or from other origins
may or may not be supported. The extent to which seeking is possible is NOT
exposed by this API.
Use in APIs when:
* Relative seeking is required. Usage in APIs should be rare; generally
Reader should be used instead.
Inherit from when:
* Implementing a Reader that can only support seeking near the current
position.
A buffered Reader that only supports seeking within its buffer is a good
example of a RelativeSeekableReader.
.. cpp:class:: NonSeekableReader : public Reader
A Reader that does not support seeking. The Seek() method is hidden.
Use in APIs when:
* Do NOT use in APIs! If seeking is not required, use Reader& instead.
Inherit from when:
* Implementing a Reader that does not support seeking.
Writer interfaces
-----------------
.. cpp:class:: Writer : public Stream
A Stream that supports writing but not reading. The Read() method is hidden.
Use in APIs when:
* Must write to, but not read from, a stream.
* May or may not need seeking. Use a SeekableWriter& if seeking is
required.
Inherit from when:
* Writer cannot be extended directly. Instead, extend SeekableWriter,
NonSeekableWriter, or (rarely) RelativeSeekableWriter, as appropriate.
A Writer may or may not support seeking. Check seekable() or try calling
Seek() to determine if the stream is seekable.
.. cpp:class:: SeekableWriter : public RelativeSeekableWriter
A Writer that fully supports seeking.
Use in APIs when:
* Absolute seeking is required. Use Writer& if seeking is not required or
seek failures can be handled gracefully.
Inherit from when:
* Implementing a writer that supports absolute seeking.
.. cpp:class:: RelativeSeekableWriter : public Writer
A Writer that at least partially supports seeking. Seeking within some range
of the current position works, but seeking beyond that or from other origins
may or may not be supported. The extent to which seeking is possible is NOT
exposed by this API.
Use in APIs when:
* Relative seeking is required. Usage in APIs should be rare; generally
Writer should be used instead.
Inherit from when:
* Implementing a Writer that can only support seeking near the current
position.
A buffered Writer that only supports seeking within its buffer is a good
example of a RelativeSeekableWriter.
.. cpp:class:: NonSeekableWriter : public Writer
A Writer that does not support seeking. The Seek() method is hidden.
Use in APIs when:
* Do NOT use in APIs! If seeking is not required, use Writer& instead.
Inherit from when:
* Implementing a Writer that does not support seeking.
ReaderWriter interfaces
-----------------------
.. cpp:class:: ReaderWriter : public Stream
A Stream that supports both reading and writing.
Use in APIs when:
* Must both read from and write to a stream.
* May or may not need seeking. Use a SeekableReaderWriter& if seeking is
required.
Inherit from when:
* Cannot extend ReaderWriter directly. Instead, extend
SeekableReaderWriter, NonSeekableReaderWriter, or (rarely)
RelativeSeekableReaderWriter, as appropriate.
A ReaderWriter may or may not support seeking. Check seekable() or try
calling Seek() to determine if the stream is seekable.
.. cpp:class:: SeekableReaderWriter : public RelativeSeekableReaderWriter
A ReaderWriter that fully supports seeking.
Use in APIs when:
* Absolute seeking is required. Use ReaderWriter& if seeking is not
required or seek failures can be handled gracefully.
Inherit from when:
* Implementing a writer that supports absolute seeking.
.. cpp:class:: RelativeSeekableReaderWriter : public ReaderWriter
A ReaderWriter that at least partially supports seeking. Seeking within some
range of the current position works, but seeking beyond that or from other
origins may or may not be supported. The extent to which seeking is possible
is NOT exposed by this API.
Use in APIs when:
* Relative seeking is required. Usage in APIs should be rare; generally
ReaderWriter should be used instead.
Inherit from when:
* Implementing a ReaderWriter that can only support seeking near the
current position.
A buffered ReaderWriter that only supports seeking within its buffer is a
good example of a RelativeSeekableReaderWriter.
.. cpp:class:: NonSeekableReaderWriter : public ReaderWriter
A ReaderWriter that does not support seeking. The Seek() method is hidden.
Use in APIs when:
* Do NOT use in APIs! If seeking is not required, use ReaderWriter&
instead.
Inherit from when:
* Implementing a ReaderWriter that does not support seeking.
---------------
Implementations
---------------
``pw_stream`` includes a few stream implementations for general use.
.. cpp:class:: MemoryWriter : public SeekableWriter
The ``MemoryWriter`` class implements the :cpp:class:`Writer` interface by
backing the data destination with an **externally-provided** memory buffer.
``MemoryWriterBuffer`` extends ``MemoryWriter`` to internally provide a memory
buffer.
The ``MemoryWriter`` can be accessed like a standard C++ container. The
contents grow as data is written.
.. cpp:class:: MemoryReader : public SeekableReader
The ``MemoryReader`` class implements the :cpp:class:`Reader` interface by
backing the data source with an **externally-provided** memory buffer.
.. cpp:class:: NullReaderWriter : public SeekableReaderWriter
``NullReaderWriter`` is a no-op stream implementation, similar to
``/dev/null``. Writes are always dropped. Reads always return
``OUT_OF_RANGE``. Seeks have no effect.
.. cpp:class:: StdFileWriter : public SeekableWriter
``StdFileWriter`` wraps an ``std::ofstream`` with the :cpp:class:`Writer`
interface.
.. cpp:class:: StdFileReader : public SeekableReader
``StdFileReader`` wraps an ``std::ifstream`` with the :cpp:class:`Reader`
interface.
------------------
Why use pw_stream?
------------------
Standard API
============
``pw_stream`` provides a standard way for classes to express that they have the
ability to write data. Writing to one sink versus another sink is a matter of
just passing a reference to the appropriate :cpp:class:`Writer`.
As an example, imagine dumping sensor data. If written against a random HAL
or one-off class, there's porting work required to write to a different sink
(imagine writing over UART vs dumping to flash memory). Building a "dumping"
implementation against the :cpp:class:`Writer` interface prevents a dependency
on a bespoke API that would require porting work.
Similarly, after building a :cpp:class:`Writer` implementation for a Sink that
data could be dumped to, that same :cpp:class:`Writer` can be reused for other
contexts that already write data to the :cpp:class:`pw::stream::Writer`
interface.
Before:
.. code-block:: cpp
// Not reusable, depends on `Uart`.
void DumpSensorData(Uart& uart) {
static char temp[64];
ImuSample imu_sample;
imu.GetSample(&info);
size_t bytes_written = imu_sample.AsCsv(temp, sizeof(temp));
uart.Transmit(temp, bytes_written, /*timeout_ms=*/ 200);
}
After:
.. code-block:: cpp
// Reusable; no more Uart dependency!
Status DumpSensorData(Writer& writer) {
static char temp[64];
ImuSample imu_sample;
imu.GetSample(&info);
size_t bytes_written = imu_sample.AsCsv(temp, sizeof(temp));
return writer.Write(temp, bytes_written);
}
Reduce intermediate buffers
===========================
Often functions that write larger blobs of data request a buffer is passed as
the destination that data should be written to. This *requires* a buffer to be
allocated, even if the data only exists in that buffer for a very short period
of time before it's written somewhere else.
In situations where data read from somewhere will immediately be written
somewhere else, a :cpp:class:`Writer` interface can cut out the middleman
buffer.
Before:
.. code-block:: cpp
// Requires an intermediate buffer to write the data as CSV.
void DumpSensorData(Uart& uart) {
char temp[64];
ImuSample imu_sample;
imu.GetSample(&info);
size_t bytes_written = imu_sample.AsCsv(temp, sizeof(temp));
uart.Transmit(temp, bytes_written, /*timeout_ms=*/ 200);
}
After:
.. code-block:: cpp
// Both DumpSensorData() and RawSample::AsCsv() use a Writer, eliminating the
// need for an intermediate buffer.
Status DumpSensorData(Writer& writer) {
RawSample imu_sample;
imu.GetSample(&info);
return imu_sample.AsCsv(writer);
}
Prevent buffer overflow
=======================
When copying data from one buffer to another, there must be checks to ensure the
copy does not overflow the destination buffer. As this sort of logic is
duplicated throughout a codebase, there's more opportunities for bound-checking
bugs to sneak in. ``Writers`` manage this logic internally rather than pushing
the bounds checking to the code that is moving or writing the data.
Similarly, since only the :cpp:class:`Writer` has access to any underlying
buffers, it's harder for functions that share a :cpp:class:`Writer` to
accidentally clobber data written by others using the same buffer.
Before:
.. code-block:: cpp
Status BuildPacket(Id dest, span<const std::byte> payload,
span<std::byte> dest) {
Header header;
if (dest.size_bytes() + payload.size_bytes() < sizeof(Header)) {
return Status::ResourceExhausted();
}
header.dest = dest;
header.src = DeviceId();
header.payload_size = payload.size_bytes();
memcpy(dest.data(), &header, sizeof(header));
// Forgetting this line would clobber buffer contents. Also, using
// a temporary span instead could leave `dest` to be misused elsewhere in
// the function.
dest = dest.subspan(sizeof(header));
memcpy(dest.data(), payload.data(), payload.size_bytes());
}
After:
.. code-block:: cpp
Status BuildPacket(Id dest, span<const std::byte> payload, Writer& writer) {
Header header;
header.dest = dest;
header.src = DeviceId();
header.payload_size = payload.size_bytes();
writer.Write(header);
return writer.Write(payload);
}
------------
Design notes
------------
Sync & Flush
============
The :cpp:class:`pw::stream::Stream` API does not include ``Sync()`` or
``Flush()`` functions. There no mechanism in the :cpp:class:`Stream` API to
synchronize a :cpp:class:`Reader`'s potentially buffered input with its
underlying data source. This must be handled by the implementation if required.
Similarly, the :cpp:class:`Writer` implementation is responsible for flushing
any buffered data to the sink.
``Flush()`` and ``Sync()`` were excluded from :cpp:class:`Stream` for a few
reasons:
* The semantics of when to call ``Flush()``/``Sync()`` on the stream are
unclear. The presence of these methods complicates using a
:cpp:class:`Reader` or :cpp:class:`Writer`.
* Adding one or two additional virtual calls increases the size of all
:cpp:class:`Stream` vtables.
Class hierarchy
===============
All ``pw_stream`` classes inherit from a single, common base with all possible
functionality: :cpp:class:`pw::stream::Stream`. This structure has
some similarities with Python's `io module
<https://docs.python.org/3/library/io.html>`_ and C#'s `Stream class
<https://docs.microsoft.com/en-us/dotnet/api/system.io.stream>`_.
An alternative approach is to have the reading, writing, and seeking portions of
the interface provided by different entities. This is how Go's `io
<https://pkg.go.dev/io package>`_ and C++'s `input/output library
<https://en.cppreference.com/w/cpp/io>`_ are structured.
We chose to use a single base class for a few reasons:
* The inheritance hierarchy is simple and linear. Despite the linear
hierarchy, combining capabilities is natural with classes like
:cpp:class:`ReaderWriter`.
In C++, separate interfaces for each capability requires either a complex
virtual inheritance hierarchy or entirely separate hierarchies for each
capability. Separate hierarchies can become cumbersome when trying to
combine multiple capabilities. A :cpp:class:`SeekableReaderWriter` would
have to implement three different interfaces, which means three different
vtables and three vtable pointers in each instance.
* Stream capabilities are clearly expressed in the type system, while
naturally supporting optional functionality. A :cpp:class:`Reader` may
or may not support :cpp:func:`Stream::Seek`. Applications that can handle
seek failures gracefully way use seek on any :cpp:class:`Reader`. If seeking
is strictly necessary, an API can accept a :cpp:class:`SeekableReader`
instead.
Expressing optional functionality in the type system is cumbersome when
there are distinct interfaces for each capability. ``Reader``, ``Writer``,
and ``Seeker`` interfaces would not be sufficient. To match the flexibility
of the current structure, there would have to be separate optional versions
of each interface, and classes for various combinations. :cpp:class:`Stream`
would be an "OptionalReaderOptionalWriterOptionalSeeker" in this model.
* Code reuse is maximized. For example, a single
:cpp:func:`Stream::ConservativeLimit` implementation supports many stream
implementations.
Virtual interfaces
==================
``pw_stream`` uses virtual functions. Virtual functions enable runtime
polymorphism. The same code can be used with any stream implementation.
Virtual functions have inherently has more overhead than a regular function
call. However, this is true of any polymorphic API. Using a C-style ``struct``
of function pointers makes different trade-offs but still has more overhead than
a regular function call.
For many use cases, the overhead of virtual calls insignificant. However, in
some extremely performance-sensitive contexts, the flexibility of the virtual
interface may not justify the performance cost.
Asynchronous APIs
=================
At present, ``pw_stream`` is synchronous. All :cpp:class:`Stream` API calls are
expected to block until the operation is complete. This might be undesirable
for slow operations, like writing to NOR flash.
Pigweed has not yet established a pattern for asynchronous C++ APIs. The
:cpp:class:`Stream` class may be extended in the future to add asynchronous
capabilities, or a separate ``AsyncStream`` could be created.
------------
Dependencies
------------
* :ref:`module-pw_assert`
* :ref:`module-pw_preprocessor`
* :ref:`module-pw_status`
* :ref:`module-pw_span`
.. cpp:namespace-pop::
Zephyr
======
To enable ``pw_stream`` for Zephyr add ``CONFIG_PIGWEED_STREAM=y`` to the
project's configuration.