Merge pull request #6945 from vespa-engine/havardpe/smarter-buffers

Havardpe/smarter buffers

3 files changed, 40 insertions, 36 deletions

diff --git a/fnet/src/vespa/fnet/databuffer.cpp b/fnet/src/vespa/fnet/databuffer.cpp
index 3b2e7759c99..74a8bc4e12c 100644
--- a/fnet/src/vespa/fnet/databuffer.cpp
+++ b/fnet/src/vespa/fnet/databuffer.cpp
@@ -13,7 +13,6 @@ FNET_DataBuffer::FNET_DataBuffer(uint32_t len)
 
     if (len > 0) {
        Alloc::alloc(len).swap(_ownedBuf);
-       memset(_ownedBuf.get(), 0x55, len);
         _bufstart = static_cast<char *>(_ownedBuf.get());
         assert(_bufstart != nullptr);
     } else { // len == 0
@@ -70,7 +69,6 @@ FNET_DataBuffer::Shrink(uint32_t newsize)
     }
     
     Alloc newBuf(Alloc::alloc(newsize));
-    memset(newBuf.get(), 0x55, newsize);
     memcpy(newBuf.get(), _datapt, GetDataLen());
     _ownedBuf.swap(newBuf);
     _bufstart = static_cast<char *>(_ownedBuf.get());
@@ -95,7 +93,6 @@ FNET_DataBuffer::Pack(uint32_t needbytes)
             bufsize *= 2;
 
         Alloc newBuf(Alloc::alloc(bufsize));
-        memset(newBuf.get(), 0x55, bufsize);
         memcpy(newBuf.get(), _datapt, GetDataLen());
         _ownedBuf.swap(newBuf);
         _bufstart = static_cast<char *>(_ownedBuf.get());
diff --git a/vespalib/src/vespa/vespalib/net/crypto_engine.cpp b/vespalib/src/vespa/vespalib/net/crypto_engine.cpp
index 38a91456cba..ec225311b60 100644
--- a/vespalib/src/vespa/vespalib/net/crypto_engine.cpp
+++ b/vespalib/src/vespa/vespalib/net/crypto_engine.cpp
@@ -9,6 +9,7 @@
 #include <vespa/vespalib/net/tls/transport_security_options.h>
 #include <vespa/vespalib/net/tls/transport_security_options_reading.h>
 #include <vespa/vespalib/net/tls/tls_crypto_engine.h>
+#include <vespa/vespalib/data/smart_buffer.h>
 #include <assert.h>
 
 namespace vespalib {
@@ -46,14 +47,14 @@ public:
 class XorCryptoSocket : public CryptoSocket
 {
 private:
-    static constexpr size_t CHUNK_SIZE = 4096;
+    static constexpr size_t CHUNK_SIZE = 16 * 1024;
     enum class OP { READ_KEY, WRITE_KEY };
     std::vector<OP> _op_stack;
-    char              _my_key;
-    char              _peer_key;
-    std::vector<char> _readbuf;
-    std::vector<char> _writebuf;    
-    SocketHandle      _socket;
+    char            _my_key;
+    char            _peer_key;
+    SmartBuffer     _input;
+    SmartBuffer     _output;
+    SocketHandle    _socket;
 
     bool is_blocked(ssize_t res, int error) const {
         return ((res < 0) && ((error == EWOULDBLOCK) || (error == EAGAIN)));
@@ -95,8 +96,8 @@ public:
                     : std::vector<OP>({OP::READ_KEY, OP::WRITE_KEY})),
           _my_key(gen_key()),
           _peer_key(0),
-          _readbuf(),
-          _writebuf(),
+          _input(CHUNK_SIZE * 2),
+          _output(CHUNK_SIZE * 2),
           _socket(std::move(socket)) {}
     int get_fd() const override { return _socket.get(); }
     HandshakeResult handshake() override {
@@ -111,51 +112,57 @@ public:
     }
     size_t min_read_buffer_size() const override { return 1; }
     ssize_t read(char *buf, size_t len) override {
-        if (_readbuf.empty()) {
-            _readbuf.resize(CHUNK_SIZE);
-            ssize_t res = _socket.read(&_readbuf[0], _readbuf.size());
+        if (_input.obtain().size < CHUNK_SIZE) {
+            auto dst = _input.reserve(CHUNK_SIZE);
+            ssize_t res = _socket.read(dst.data, dst.size);
             if (res > 0) {
-                _readbuf.resize(res);
+                _input.commit(res);
             } else {
-                _readbuf.clear();
-                return res;
+                return res; // eof/error
             }
         }
         return drain(buf, len);
     }
     ssize_t drain(char *buf, size_t len) override {
-        size_t frame = std::min(len, _readbuf.size());
+        auto src = _input.obtain();
+        size_t frame = std::min(len, src.size);
         for (size_t i = 0; i < frame; ++i) {
-            buf[i] = (_readbuf[i] ^ _my_key);
+            buf[i] = (src.data[i] ^ _my_key);
         }
-        _readbuf.erase(_readbuf.begin(), _readbuf.begin() + frame);
+        _input.evict(frame);
         return frame;
     }
     ssize_t write(const char *buf, size_t len) override {
-        ssize_t res = flush();
-        while (res > 0) {
-            res = flush();
-        }
-        if (res < 0) {
-            return res;
+        if (_output.obtain().size >= CHUNK_SIZE) {
+            if (flush() < 0) {
+                return -1;
+            }
+            if (_output.obtain().size > 0) {
+                errno = EWOULDBLOCK;
+                return -1;
+            }
         }
         size_t frame = std::min(len, CHUNK_SIZE);
+        auto dst = _output.reserve(frame);
         for (size_t i = 0; i < frame; ++i) {
-            _writebuf.push_back(buf[i] ^ _peer_key);
+            dst.data[i] = (buf[i] ^ _peer_key);
         }
+        _output.commit(frame);
         return frame;
     }
     ssize_t flush() override {
-        if (!_writebuf.empty()) {
-            ssize_t res = _socket.write(&_writebuf[0], _writebuf.size());
+        auto pending = _output.obtain();
+        if (pending.size > 0) {
+            ssize_t res = _socket.write(pending.data, pending.size);
             if (res > 0) {
-                _writebuf.erase(_writebuf.begin(), _writebuf.begin() + res);                
+                _output.evict(res);
+                return 1; // progress
             } else {
                 assert(res < 0);
+                return -1; // error
             }
-            return res;
         }
-        return 0;
+        return 0; // done
     }
 };
 
diff --git a/vespalib/src/vespa/vespalib/net/tls/crypto_codec_adapter.h b/vespalib/src/vespa/vespalib/net/tls/crypto_codec_adapter.h
index 6a624ca44f7..f17693cabff 100644
--- a/vespalib/src/vespa/vespalib/net/tls/crypto_codec_adapter.h
+++ b/vespalib/src/vespa/vespalib/net/tls/crypto_codec_adapter.h
@@ -4,7 +4,7 @@
 
 #include <vespa/vespalib/net/crypto_socket.h>
 #include <vespa/vespalib/net/socket_handle.h>
-#include <vespa/vespalib/data/simple_buffer.h>
+#include <vespa/vespalib/data/smart_buffer.h>
 #include "crypto_codec.h"
 
 namespace vespalib::net::tls {
@@ -19,8 +19,8 @@ namespace vespalib::net::tls {
 class CryptoCodecAdapter : public CryptoSocket
 {
 private:
-    SimpleBuffer                 _input;
-    SimpleBuffer                 _output;
+    SmartBuffer                  _input;
+    SmartBuffer                  _output;
     SocketHandle                 _socket;
     std::unique_ptr<CryptoCodec> _codec;
 
@@ -33,7 +33,7 @@ private:
     ssize_t flush_all();  // -1/0 -> error/ok
 public:
     CryptoCodecAdapter(SocketHandle socket, std::unique_ptr<CryptoCodec> codec)
-        : _socket(std::move(socket)), _codec(std::move(codec)) {}
+        : _input(64 * 1024), _output(64 * 1024), _socket(std::move(socket)), _codec(std::move(codec)) {}
     int get_fd() const override { return _socket.get(); }
     HandshakeResult handshake() override;
     size_t min_read_buffer_size() const override { return _codec->min_decode_buffer_size(); }