Update Spicy runtime driver to use new stream features for improved p…

…erformance.

This does two things:

- When adding data to a stream, we now do that without copying
  anything initially. For block input (e.g., UDP) that's always fine
  because the parser will never suspend before it's fully done
  parsing; hence we can safely delete it once the parser returns. For
  stream input (e.g., TCP), we make the stream own its data later
  if (and only if) the parser suspends.

- For block input (e.g., UDP) we now keep reusing the same stream for
  subsequent blocks, instead of creating a new one each time. This
  allows the stream to reuse an allocated chunk that it may have still
  cached internally.

The result of this, plus the new chunk caching introduced earlier, is
that for a UDP flow, we never need to allocate more than one chunk,
and never need to copy any data; and for TCP it's the same as long as
parsing consumes all data before suspending (which should be a common
case), plus, when we allocate new storage we only copy data that didn't
get trimmed immediately anyways.

Closes #1657.

spicy/runtime/src/driver.cc

@@ -256,13 +256,21 @@ driver::ParsingState::State driver::ParsingState::_process(size_t size, const ch
                 assert(_parser->profiler_tags);
                 auto profiler = hilti::rt::profiler::start(_parser->profiler_tags.prepare_block);
 
-                auto input = hilti::rt::reference::make_value<hilti::rt::Stream>(data, size);
-                input->freeze();
+                if ( ! _input ) {
+                    _input =
+                        hilti::rt::reference::make_value<hilti::rt::Stream>(data, size, hilti::rt::stream::NonOwning());
+
+                    if ( ! _parser->parse1 )
+                        throw InvalidUnitType(
+                            fmt("unit type '%s' cannot be used as external entry point because it requires arguments",
+                                _parser->name));
+                }
+                else {
+                    (*_input)->reset();
+                    (*_input)->append(data, size, hilti::rt::stream::NonOwning());
+                }
 
-                if ( ! _parser->parse1 )
-                    throw InvalidUnitType(
-                        fmt("unit type '%s' cannot be used as external entry point because it requires arguments",
-                            _parser->name));
+                (*_input)->freeze();
 
                 if ( _parser->context_new ) {
                     if ( _context )
@@ -273,9 +281,7 @@ driver::ParsingState::State driver::ParsingState::_process(size_t size, const ch
 
                 hilti::rt::profiler::stop(profiler);
 
-                _resumable = _parser->parse1(input, {}, _context);
-
-                if ( ! *_resumable )
+                if ( ! _parser->parse1(*_input, {}, _context) )
                     hilti::rt::internalError("block-based parsing yielded");
 
                 return Done;
@@ -305,7 +311,8 @@ driver::ParsingState::State driver::ParsingState::_process(size_t size, const ch
                             DRIVER_DEBUG("no context provided");
                     }
 
-                    _input = hilti::rt::reference::make_value<hilti::rt::Stream>(data, size);
+                    _input =
+                        hilti::rt::reference::make_value<hilti::rt::Stream>(data, size, hilti::rt::stream::NonOwning());
                     if ( eod )
                         (*_input)->freeze();
 
@@ -323,7 +330,7 @@ driver::ParsingState::State driver::ParsingState::_process(size_t size, const ch
                     assert(_input && _resumable);
 
                     if ( size )
-                        (*_input)->append(data, size);
+                        (*_input)->append(data, size, hilti::rt::stream::NonOwning());
 
                     if ( eod ) {
                         DRIVER_DEBUG("end of data");
@@ -346,6 +353,7 @@ driver::ParsingState::State driver::ParsingState::_process(size_t size, const ch
                     if ( eod )
                         hilti::rt::internalError("parsing yielded for final data chunk");
 
+                    (*_input)->makeOwning();
                     return Continue;
                 }
             }