Buffer API refactor, C++ compat

 - Add common_close() to tests.

Signed-off-by: Andrew Opalach <andrew@akon.city>

8 files changed, 58 insertions, 55 deletions

diff --git a/src/common.c b/src/common.c
index 1d4e3be..797090d 100644
--- a/src/common.c
+++ b/src/common.c
@@ -105,9 +105,10 @@ void nn_common_close(void)
     size_t current;
     size_t peak;
     size_t total;
-    al_malloc_stats(&current, &peak, &total);
-    al_printf("malloc stats, current: %.2fKB, peak: %.2fKB, total: %.2fKB.\n",
-        current / 1024.f, peak / 1024.f, total / 1024.f);
+    size_t ops;
+    al_malloc_stats(&current, &peak, &total, &ops);
+    al_printf("malloc stats, current: %.2fKB, peak: %.2fKB, total: %.2fKB, ops: %zu.\n",
+        current / 1024.f, peak / 1024.f, total / 1024.f, ops);
     nn_mutex_destroy(&malloc_mutex);
 #endif
 }
diff --git a/src/curl/http.c b/src/curl/http.c
index cfb8a18..364b32e 100644
--- a/src/curl/http.c
+++ b/src/curl/http.c
@@ -132,7 +132,7 @@ static void request_callback(void *userdata, u8 op, u8 *buf, void *opaque)
     switch (op) {
     case NNWT_HTTP_READ: {
         size_t n = *(size_t *)opaque;
-        size_t size = nn_buffer_get_size(&request->payload);
+        size_t size = request->payload.size;
         if (request->pointer + n > size) {
             n = size - request->pointer;
         }
@@ -217,7 +217,7 @@ bool nn_http_request(struct nn_http_request *request, u8 method, struct nn_event
     curl->loop = loop;
     request->http.callback = request_callback;
     request->http.userdata = request;
-    long payload = (long)nn_buffer_get_size(&request->payload);
+    long payload = (long)request->payload.size;
     if (payload > 0) {
         curl_easy_setopt(curl->handle, CURLOPT_POSTFIELDSIZE, payload);
     }
diff --git a/src/packet_stream.c b/src/packet_stream.c
index 271898a..cca1b0f 100644
--- a/src/packet_stream.c
+++ b/src/packet_stream.c
@@ -115,7 +115,7 @@ static void stream_read_callback(struct ev_loop *loop, ev_io *w, s32 revents)
     if (!stream->in.have_header && stream->in.index >= NNWT_PACKET_HEADER_LENGTH) {
         stream->in.have_header = true;
         size = nn_packet_get_size(stream->in.packet);
-        nn_buffer_set_size(buffer, size);
+        buffer->size = size;
         nn_buffer_ensure_space(buffer, size);
     }
 
diff --git a/src/util/buffer.c b/src/util/buffer.c
index 071d8bf..4c8b3c2 100644
--- a/src/util/buffer.c
+++ b/src/util/buffer.c
@@ -5,59 +5,54 @@
 #define NNWT_BUFFER_SIZE KB(1)
 #define NNWT_BUFFER_GROW ((size_t)al_grow_step)
 
-void nn_buffer_ensure_space(struct nn_buffer *buf, size_t size)
+void nn_buffer_init(struct nn_buffer *buffer)
 {
-    if (size > buf->alloc) {
-        buf->alloc = (size < NNWT_BUFFER_SIZE) ? NNWT_BUFFER_SIZE :
-            (size + NNWT_BUFFER_GROW) & ~NNWT_BUFFER_GROW;
-        buf->data = (u8 *)(buf->data ? al_realloc(buf->data, buf->alloc) : al_malloc(buf->alloc));
-    }
-}
-
-void nn_buffer_init(struct nn_buffer *buf)
-{
-    buf->size = 0;
-    buf->alloc = 0;
-    buf->data = NULL;
+    buffer->size = 0;
+    buffer->alloc = 0;
+    buffer->data = NULL;
 }
 
-size_t nn_buffer_get_size(struct nn_buffer *buf)
+void nn_buffer_ensure_space(struct nn_buffer *buffer, size_t size)
 {
-    return buf->size;
+    al_assert(size > 0);
+    if (size > buffer->alloc) {
+        buffer->alloc = (size <= NNWT_BUFFER_SIZE) ? NNWT_BUFFER_SIZE :
+            (size + NNWT_BUFFER_GROW) & ~NNWT_BUFFER_GROW;
+        buffer->data = (u8 *)al_realloc(buffer->data, buffer->alloc);
+    }
 }
 
-void nn_buffer_set_size(struct nn_buffer *buf, size_t size)
+void nn_buffer_shrink_to_size(struct nn_buffer *buffer)
 {
-    buf->size = size;
+    buffer->alloc = 0;
+    nn_buffer_ensure_space(buffer, buffer->size);
 }
 
-void nn_buffer_write(struct nn_buffer *buf, void *data, size_t index, size_t size)
+void nn_buffer_write(struct nn_buffer *buffer, void *data, size_t index, size_t size)
 {
     size_t reach = index + size;
-    nn_buffer_ensure_space(buf, reach);
-    if (reach > buf->size) {
-        buf->size = reach;
-    }
-    al_memcpy(&buf->data[index], data, size);
+    nn_buffer_ensure_space(buffer, reach);
+    if (reach > buffer->size) buffer->size = reach;
+    al_memcpy(&buffer->data[index], data, size);
 }
 
-void nn_buffer_append(struct nn_buffer *buf, void *data, size_t size)
+void nn_buffer_append(struct nn_buffer *buffer, void *data, size_t size)
 {
-    nn_buffer_write(buf, data, buf->size, size);
+    nn_buffer_write(buffer, data, buffer->size, size);
 }
 
-u8 *nn_buffer_get_ptr(struct nn_buffer *buf, size_t index)
+u8 *nn_buffer_get_ptr(struct nn_buffer *buffer, size_t index)
 {
-    return buf->data + index;
+    return buffer->data + index;
 }
 
-void nn_buffer_read(struct nn_buffer *buf, void *ptr, size_t index, size_t size)
+void nn_buffer_read(struct nn_buffer *buffer, void *ptr, size_t index, size_t size)
 {
-    al_assert(index + size <= buf->size);
-    al_memcpy(ptr, &buf->data[index], size);
+    al_assert(index + size <= buffer->size);
+    al_memcpy(ptr, &buffer->data[index], size);
 }
 
-void nn_buffer_free(struct nn_buffer *buf)
+void nn_buffer_free(struct nn_buffer *buffer)
 {
-    if (buf->data && buf->alloc > 0) al_free(buf->data);
+    if (buffer->alloc) al_free(buffer->data);
 }
diff --git a/src/util/buffer.h b/src/util/buffer.h
index 9b254d4..19bc400 100644
--- a/src/util/buffer.h
+++ b/src/util/buffer.h
@@ -10,15 +10,14 @@ struct nn_buffer {
 };
 
 // A pun+dereference breaks on 32bit Android but isn't warned about by -Wstrict-aliasing=3.
-#define NNWT_BUFFER_READ_TYPE(buf, index, type, r) \
-    al_memcpy((void *)&(r), (void *)nn_buffer_get_ptr(buf, index), sizeof(type))
+#define NNWT_BUFFER_READ_TYPE(buffer, index, type, r) \
+    al_memcpy((void *)&(r), (void *)nn_buffer_get_ptr(buffer, index), sizeof(type))
 
-void nn_buffer_init(struct nn_buffer *buf);
-void nn_buffer_ensure_space(struct nn_buffer *buf, size_t size);
-size_t nn_buffer_get_size(struct nn_buffer *buf);
-void nn_buffer_set_size(struct nn_buffer *buf, size_t size);
-void nn_buffer_write(struct nn_buffer *buf, void *data, size_t index, size_t size);
-void nn_buffer_append(struct nn_buffer *buf, void *data, size_t size);
-u8 *nn_buffer_get_ptr(struct nn_buffer *buf, size_t index);
-void nn_buffer_read(struct nn_buffer *buf, void *ptr, size_t index, size_t size);
-void nn_buffer_free(struct nn_buffer *buf);
+void nn_buffer_init(struct nn_buffer *buffer);
+void nn_buffer_ensure_space(struct nn_buffer *buffer, size_t size);
+void nn_buffer_shrink_to_size(struct nn_buffer *buffer);
+void nn_buffer_write(struct nn_buffer *buffer, void *data, size_t index, size_t size);
+void nn_buffer_append(struct nn_buffer *buffer, void *data, size_t size);
+u8 *nn_buffer_get_ptr(struct nn_buffer *buffer, size_t index);
+void nn_buffer_read(struct nn_buffer *buffer, void *ptr, size_t index, size_t size);
+void nn_buffer_free(struct nn_buffer *buffer);
diff --git a/src/util/file/util.c b/src/util/file/util.c
index cf2d31c..a2201a7 100644
--- a/src/util/file/util.c
+++ b/src/util/file/util.c
@@ -15,7 +15,7 @@ s32 nn_file_read_as_str(struct nn_file *file, str *out)
 s32 nn_file_read_as_c_str(struct nn_file *file, char **out)
 {
     size_t size = file->size;
-    *out = al_malloc(size + 1);
+    *out = (char *)al_malloc(size + 1);
     if (!nn_file_read(file, (void *)*out, size)) {
         al_free(*out);
         return -1;
diff --git a/src/util/packet.c b/src/util/packet.c
index fe20b58..d7df1da 100644
--- a/src/util/packet.c
+++ b/src/util/packet.c
@@ -2,7 +2,7 @@
 
 struct nn_packet *nn_packet_create(void)
 {
-    struct nn_packet *packet = (struct nn_packet *)al_malloc(sizeof(struct nn_packet));
+    struct nn_packet *packet = al_alloc_object(struct nn_packet);
     nn_buffer_init(&packet->buffer);
     nn_packet_reset(packet);
     return packet;
@@ -10,9 +10,11 @@ struct nn_packet *nn_packet_create(void)
 
 struct nn_packet *nn_packet_clone(struct nn_packet *packet)
 {
+    al_assert(packet->buffer.alloc >= NNWT_PACKET_HEADER_LENGTH);
     struct nn_packet *c = nn_packet_create();
-    nn_buffer_ensure_space(&c->buffer, packet->buffer.size);
-    al_memcpy(nn_buffer_get_ptr(&c->buffer, 0), nn_buffer_get_ptr(&packet->buffer, 0), packet->buffer.size);
+    u32 size = nn_packet_get_size(packet);
+    nn_buffer_ensure_space(&c->buffer, size);
+    al_memcpy(nn_buffer_get_ptr(&c->buffer, 0), nn_buffer_get_ptr(&packet->buffer, 0), size);
     c->windex = packet->windex;
     c->rindex = packet->rindex;
     c->opaque = packet->opaque;
@@ -36,7 +38,13 @@ u32 nn_packet_get_u32(struct nn_packet *packet, u32 index)
 
 void nn_packet_write_size(struct nn_packet *packet)
 {
-    nn_buffer_write(&packet->buffer, &packet->windex, 0, sizeof(u32));
+    struct nn_buffer *buffer = &packet->buffer;
+    al_assert(buffer->alloc >= packet->windex);
+    buffer->size = packet->windex;
+    if (buffer->size < buffer->alloc / 2) {
+        nn_buffer_shrink_to_size(buffer);
+    }
+    nn_buffer_write(buffer, &packet->windex, 0, sizeof(u32));
 }
 
 u32 nn_packet_get_size(struct nn_packet *packet)
diff --git a/src/util/packet.h b/src/util/packet.h
index 7183837..a2837f1 100644
--- a/src/util/packet.h
+++ b/src/util/packet.h
@@ -29,7 +29,7 @@ struct nn_packet {
     (p)->rindex += (u32)sizeof(type)
 
 #define NNWT_PACKET_READ_DATA(p, length, r) \
-    r = (void *)nn_buffer_get_ptr(&(p)->buffer, (p)->rindex); \
+    r = (__typeof__(r))nn_buffer_get_ptr(&(p)->buffer, (p)->rindex); \
     (p)->rindex += (u32)length
 
 struct nn_packet *nn_packet_create(void);