Various performance improvements (#24)

* switch from array to linked list for photon queue

* performance optimizations

* fix tests

* various fixes

src/common/common.h

@@ -35,6 +35,11 @@
 
 #define CHECK(COND) CHECKM(COND, "")
 
+#define DCHECK(COND)
+#ifdef RAY_COMMON_DEBUG
+CHECK(COND)
+#endif
+
 /* These are exit codes for common errors that can occur in Ray components. */
 #define EXIT_COULD_NOT_BIND_PORT -2
 

src/common/io.c

@@ -266,16 +266,15 @@ int read_bytes(int fd, uint8_t *cursor, size_t length) {
  *
  * @param fd The file descriptor to read from. It can be non-blocking.
  * @param type The type of the message that is read will be written at this
-          address. If there was an error while reading, this will be
-          DISCONNECT_CLIENT.
+ *        address. If there was an error while reading, this will be
+ *        DISCONNECT_CLIENT.
  * @param length The size in bytes of the message that is read will be written
-          at this address. This size does not include the bytes used to encode
-          the type and length. If there was an error while reading, this will
-          be 0.
+ *        at this address. This size does not include the bytes used to encode
+ *        the type and length. If there was an error while reading, this will
+ *        be 0.
  * @param bytes The address at which to write the pointer to the bytes that are
-          read and allocated by this function. If there was an error while
-          reading, this will be NULL.
-
+ *        read and allocated by this function. If there was an error while
+ *        reading, this will be NULL.
  * @return Void.
  */
 void read_message(int fd, int64_t *type, int64_t *length, uint8_t **bytes) {
@@ -303,6 +302,47 @@ disconnected:
   return;
 }
 
+/**
+ * Read a sequence of bytes written by write_message from a file descriptor.
+ * This does not allocate space for the message if the provided buffer is
+ * large enough and can therefore often avoid allocations.
+ *
+ * @note The caller must create and free the buffer.
+ *
+ * @param fd The file descriptor to read from. It can be non-blocking.
+ * @param type The type of the message that is read will be written at this
+ *        address. If there was an error while reading, this will be
+ *        DISCONNECT_CLIENT.
+ * @param buffer The array the message will be written to. If it is not
+ *        large enough to hold the message, it will be enlarged by read_buffer.
+ * @return Number of bytes of the message that were read. This size does not
+ *         include the bytes used to encode the type and length. If there was
+ *         an error while reading, this will be 0.
+ */
+int64_t read_buffer(int fd, int64_t *type, UT_array *buffer) {
+  int64_t length;
+  int closed = read_bytes(fd, (uint8_t *) type, sizeof(int64_t));
+  if (closed) {
+    goto disconnected;
+  }
+  closed = read_bytes(fd, (uint8_t *) &length, sizeof(int64_t));
+  if (closed) {
+    goto disconnected;
+  }
+  if (length > utarray_len(buffer)) {
+    utarray_resize(buffer, length);
+  }
+  closed = read_bytes(fd, (uint8_t *) utarray_front(buffer), length);
+  if (closed) {
+    goto disconnected;
+  }
+  return length;
+disconnected:
+  /* Handle the case in which the socket is closed. */
+  *type = DISCONNECT_CLIENT;
+  return 0;
+}
+
 /* Write a null-terminated string to a file descriptor. */
 void write_log_message(int fd, char *message) {
   /* Account for the \0 at the end of the string. */

src/common/io.h

@@ -4,6 +4,8 @@
 #include <stdbool.h>
 #include <stdint.h>
 
+#include "utarray.h"
+
 enum common_message_type {
   /** Disconnect a client. */
   DISCONNECT_CLIENT,
@@ -21,10 +23,11 @@ int connect_ipc_sock(const char *socket_pathname);
 
 int accept_client(int socket_fd);
 
-/* Reading and writing data */
+/* Reading and writing data. */
 
 int write_message(int fd, int64_t type, int64_t length, uint8_t *bytes);
 void read_message(int fd, int64_t *type, int64_t *length, uint8_t **bytes);
+int64_t read_buffer(int fd, int64_t *type, UT_array *buffer);
 
 void write_log_message(int fd, char *message);
 void write_formatted_log_message(int fd, const char *format, ...);