Implement RX buffer for WiFi client to speed up small reads

Author: me-no-dev

libraries/WiFi/src/WiFiClient.cpp

@@ -31,6 +31,118 @@
 #undef write
 #undef read
 
+class WiFiClientRxBuffer {
+private:
+        size_t _size;
+        uint8_t *_buffer;
+        size_t _pos;
+        size_t _fill;
+        int _fd;
+        bool _failed;
+
+        size_t r_available()
+        {
+            if(_fd < 0){
+                return 0;
+            }
+            int count;
+            int res = lwip_ioctl_r(_fd, FIONREAD, &count);
+            if(res < 0) {
+                _failed = true;
+                return 0;
+            }
+            return count;
+        }
+
+        size_t fillBuffer()
+        {
+            if(!_buffer){
+                _buffer = (uint8_t *)malloc(_size);
+            }
+            if(_fill && _pos == _fill){
+                _fill = 0;
+                _pos = 0;
+            }
+            if(!_buffer || _size <= _fill || !r_available()) {
+                return 0;
+            }
+            int res = recv(_fd, _buffer + _fill, _size - _fill, MSG_DONTWAIT);
+            if(res < 0 && errno != EWOULDBLOCK) {
+                _failed = true;
+                return 0;
+            }
+            _fill += res;
+            return res;
+        }
+
+public:
+    WiFiClientRxBuffer(int fd, size_t size=1436)
+        :_size(size)
+        ,_buffer(NULL)
+        ,_pos(0)
+        ,_fill(0)
+        ,_fd(fd)
+        ,_failed(false)
+    {
+        //_buffer = (uint8_t *)malloc(_size);
+    }
+
+    ~WiFiClientRxBuffer()
+    {
+        free(_buffer);
+    }
+
+    bool failed(){
+        return _failed;
+    }
+
+    int read(uint8_t * dst, size_t len){
+        if(!dst || !len || (_pos == _fill && !fillBuffer())){
+            return -1;
+        }
+        size_t a = _fill - _pos;
+        if(len <= a || ((len - a) <= (_size - _fill) && fillBuffer() >= (len - a))){
+            if(len == 1){
+                *dst = _buffer[_pos];
+            } else {
+                memcpy(dst, _buffer + _pos, len);
+            }
+            _pos += len;
+            return len;
+        }
+        size_t left = len;
+        size_t toRead = a;
+        uint8_t * buf = dst;
+        memcpy(buf, _buffer + _pos, toRead);
+        _pos += toRead;
+        left -= toRead;
+        buf += toRead;
+        while(left){
+            if(!fillBuffer()){
+                return len - left;
+            }
+            a = _fill - _pos;
+            toRead = (a > left)?left:a;
+            memcpy(buf, _buffer + _pos, toRead);
+            _pos += toRead;
+            left -= toRead;
+            buf += toRead;
+        }
+        return len;
+    }
+
+    int peek(){
+        if(_pos == _fill && !fillBuffer()){
+            return -1;
+        }
+        return _buffer[_pos];
+    }
+
+    size_t available(){
+        return _fill - _pos + r_available();
+    }
+};
+
 class WiFiClientSocketHandle {
 private:
     int sockfd;
@@ -58,6 +170,7 @@ WiFiClient::WiFiClient():_connected(false),next(NULL)
 WiFiClient::WiFiClient(int fd):_connected(true),next(NULL)
 {
     clientSocketHandle.reset(new WiFiClientSocketHandle(fd));
+    _rxBuffer.reset(new WiFiClientRxBuffer(fd));
 }
 
 WiFiClient::~WiFiClient()
@@ -69,13 +182,15 @@ WiFiClient & WiFiClient::operator=(const WiFiClient &other)
 {
     stop();
     clientSocketHandle = other.clientSocketHandle;
+    _rxBuffer = other._rxBuffer;
     _connected = other._connected;
     return *this;
 }
 
 void WiFiClient::stop()
 {
     clientSocketHandle = NULL;
+    _rxBuffer = NULL;
     _connected = false;
 }
 
@@ -100,6 +215,7 @@ int WiFiClient::connect(IPAddress ip, uint16_t port)
         return 0;
     }
     clientSocketHandle.reset(new WiFiClientSocketHandle(sockfd));
+    _rxBuffer.reset(new WiFiClientRxBuffer(sockfd));
     _connected = true;
     return 1;
 }
@@ -260,11 +376,9 @@ size_t WiFiClient::write(Stream &stream)
 
 int WiFiClient::read(uint8_t *buf, size_t size)
 {
-    if(!available()) {
-        return -1;
-    }
-    int res = recv(fd(), buf, size, MSG_DONTWAIT);
-    if(res < 0 && errno != EWOULDBLOCK) {
+    int res = -1;
+    res = _rxBuffer->read(buf, size);
+    if(_rxBuffer->failed()) {
         log_e("%d", errno);
         stop();
     }
@@ -273,31 +387,25 @@ int WiFiClient::read(uint8_t *buf, size_t size)
 
 int WiFiClient::peek()
 {
-    if(!available()) {
-        return -1;
-    }
-    uint8_t data = 0;
-    int res = recv(fd(), &data, 1, MSG_PEEK);
-    if(res < 0 && errno != EWOULDBLOCK) {
+    int res = _rxBuffer->peek();
+    if(_rxBuffer->failed()) {
         log_e("%d", errno);
         stop();
     }
-    return data;
+    return res;
 }
 
 int WiFiClient::available()
 {
     if(!_connected) {
         return 0;
     }
-    int count;
-    int res = lwip_ioctl_r(fd(), FIONREAD, &count);
-    if(res < 0) {
+    int res = _rxBuffer->available();
+    if(_rxBuffer->failed()) {
         log_e("%d", errno);
         stop();
-        return 0;
     }
-    return count;
+    return res;
 }
 
 // Though flushing means to send all pending data,

libraries/WiFi/src/WiFiClient.h

@@ -28,11 +28,13 @@
 #include <memory>
 
 class WiFiClientSocketHandle;
+class WiFiClientRxBuffer;
 
 class WiFiClient : public Client
 {
 protected:
     std::shared_ptr<WiFiClientSocketHandle> clientSocketHandle;
+    std::shared_ptr<WiFiClientRxBuffer> _rxBuffer;
     bool _connected;
 
 public: