Skip to content

Commit

Permalink
Optimize serializer
Browse files Browse the repository at this point in the history
  • Loading branch information
@katajakasa
katajakasa committed Oct 29, 2017
1 parent ac8d635 commit 5c79e3e
Show file tree
Hide file tree
Showing 5 changed files with 71 additions and 56 deletions.
2 changes: 1 addition & 1 deletion include/controller/controller.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -65,7 +65,7 @@ struct controller_t {

void controller_init(controller* ctrl);
void controller_cmd(controller* ctrl, int action, ctrl_event **ev);
void controller_sync(controller *ctrl, serial *ser, ctrl_event **ev);
void controller_sync(controller *ctrl, const serial *ser, ctrl_event **ev);
void controller_close(controller* ctrl, ctrl_event **ev);
int controller_poll(controller *ctrl, ctrl_event **ev);
int controller_tick(controller *ctrl, int ticks, ctrl_event **ev);
Expand Down
10 changes: 6 additions & 4 deletions include/game/utils/serial.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -7,25 +7,27 @@
typedef struct serial_t {
size_t len;
size_t rpos;
size_t wpos;
char *data;
} serial;

void serial_create(serial *s);
void serial_write(serial *s, const char *buf, int len);
void serial_create_from(serial *s, const char *buf, size_t len);
void serial_write(serial *s, const char *buf, size_t len);
void serial_write_int8(serial *s, int8_t v);
void serial_write_int16(serial *s, int16_t v);
void serial_write_int32(serial *s, int32_t v);
//void serial_write_int64(serial *s, int64_t v);
void serial_write_float(serial *s, float v);
size_t serial_len(serial *s);
void serial_read(serial *s, char *buf, int len);
void serial_read(serial *s, char *buf, size_t len);
void serial_free(serial *s);
void serial_read_reset(serial *s);
int8_t serial_read_int8(serial *s);
int16_t serial_read_int16(serial *s);
int32_t serial_read_int32(serial *s);
//int64_t serial_read_int64(serial *s);
long serial_read_long(serial *s);
float serial_read_float(serial *s);
void serial_copy(serial *dst, const serial *src);
serial* serial_malloc_copy(const serial *src);

#endif // _SERIAL_H
5 changes: 3 additions & 2 deletions src/controller/controller.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -76,15 +76,16 @@ void controller_cmd(controller* ctrl, int action, ctrl_event **ev) {
}
}

void controller_sync(controller *ctrl, serial *ser, ctrl_event **ev) {
void controller_sync(controller *ctrl, const serial *ser, ctrl_event **ev) {
if (*ev != NULL) {
// a sync event obsoletes all previous events
controller_free_chain(*ev);
}
*ev = malloc(sizeof(ctrl_event));
(*ev)->type = EVENT_TYPE_SYNC;
(*ev)->event_data.ser = ser;
(*ev)->event_data.ser = serial_malloc_copy(ser);
(*ev)->next = NULL;

}

void controller_close(controller *ctrl, ctrl_event **ev) {
Expand Down
39 changes: 15 additions & 24 deletions src/controller/net_controller.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -3,6 +3,7 @@

#include "controller/net_controller.h"
#include "utils/log.h"
#include "game/utils/serial.h"

typedef struct wtf_t {
ENetHost *host;
Expand Down Expand Up @@ -95,34 +96,29 @@ int net_controller_tick(controller *ctrl, int ticks, ctrl_event **ev) {
wtf *data = ctrl->data;
ENetHost *host = data->host;
ENetPeer *peer = data->peer;
serial *ser;
/*int handled = 0;*/
serial ser;
while (enet_host_service(host, &event, 0) > 0) {
switch (event.type) {
case ENET_EVENT_TYPE_RECEIVE:
ser = malloc(sizeof(serial));
serial_create(ser);
ser->data = malloc(event.packet->dataLength);
ser->len = event.packet->dataLength;
memcpy(ser->data, event.packet->data, event.packet->dataLength);
switch(serial_read_int8(ser)) {
serial_create_from(
&ser,
(const char*)event.packet->data,
event.packet->dataLength);
switch(serial_read_int8(&ser)) {
case EVENT_TYPE_ACTION:
{
// dispatch keypress to scene
int action = serial_read_int16(ser);
int action = serial_read_int16(&ser);
controller_cmd(ctrl, action, ev);
/*handled = 1;*/
serial_free(ser);
free(ser);
}
break;
case EVENT_TYPE_HB:
{
// got a tick
int id = serial_read_int8(ser);
int id = serial_read_int8(&ser);
if (id == data->id) {
int start = serial_read_int32(ser);
int peerticks = serial_read_int32(ser);
int start = serial_read_int32(&ser);
int peerticks = serial_read_int32(&ser);
int newrtt = abs(start - ticks);
data->rttbuf[data->rttpos++] = newrtt;
if (data->rttpos >= 100) {
Expand All @@ -136,29 +132,24 @@ int net_controller_tick(controller *ctrl, int ticks, ctrl_event **ev) {
}
data->outstanding_hb = 0;
data->last_hb = ticks;
serial_free(ser);
} else {
// a heartbeat from the peer, bounce it back
ENetPacket *packet;
// write our own ticks into it
serial_write_int32(ser, ticks);
packet = enet_packet_create(ser->data, ser->len, ENET_PACKET_FLAG_UNSEQUENCED);
serial_write_int32(&ser, ticks);
packet = enet_packet_create(ser.data, ser.len, ENET_PACKET_FLAG_UNSEQUENCED);
if (peer) {
enet_peer_send(peer, 0, packet);
enet_host_flush (host);
}
}
free(ser);
}
break;
case EVENT_TYPE_SYNC:
controller_sync(ctrl, ser, ev);
/*handled = 1;*/
controller_sync(ctrl, &ser, ev);
break;
default:
serial_free(ser);
free(ser);
}
serial_free(&ser);
enet_packet_destroy(event.packet);
break;
case ENET_EVENT_TYPE_DISCONNECT:
Expand Down
71 changes: 46 additions & 25 deletions src/game/utils/serial.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -9,6 +9,7 @@
#include "utils/log.h"
#include <stdio.h>

#define SERIAL_BUF_RESIZE_INC 64

// taken from http://stackoverflow.com/questions/10620601/portable-serialisation-of-ieee754-floating-point-values
float htonf(float val) {
Expand All @@ -27,23 +28,44 @@ float ntohf(float val) {
return val;
}

// TODO we should probably have some reasonable initial size, so we don't realloc like crazy
void serial_create(serial *s) {
s->len = 0;
s->len = SERIAL_BUF_RESIZE_INC;
s->wpos = 0;
s->rpos = 0;
s->data = NULL;
s->data = malloc(s->len);
}

void serial_create_from(serial *s, const char *buf, size_t len) {
s->len = len + SERIAL_BUF_RESIZE_INC;
s->wpos = len;
s->rpos = 0;
s->data = malloc(s->len);
memcpy(s->data, buf, len);
}

void serial_copy(serial *dst, const serial *src) {
dst->len = src->len;
dst->wpos = src->wpos;
dst->rpos = src->rpos;
dst->data = malloc(dst->len);
memcpy(dst->data, src->data, dst->len);
}

// TODO: Optimize writing
void serial_write(serial *s, const char *buf, int len) {
if(s->data == NULL) {
s->data = malloc(len);
memcpy(s->data, buf, len);
} else {
s->data = realloc(s->data, s->len + len);
memcpy(s->data + s->len, buf, len);
serial* serial_malloc_copy(const serial *src) {
serial* dst = malloc(sizeof(serial));
serial_copy(dst, src);
return dst;
}

void serial_write(serial *s, const char *buf, size_t len) {
if(s->len < (s->wpos + len)) {
size_t new_len = s->len + len + SERIAL_BUF_RESIZE_INC;
s->data = realloc(s->data, new_len);
s->len = new_len;
}
s->len += len;

memcpy(s->data + s->wpos, buf, len);
s->wpos += len;
}

void serial_write_int8(serial *s, int8_t v) {
Expand All @@ -66,30 +88,29 @@ void serial_write_float(serial *s, float v) {
}

void serial_free(serial *s) {
if(s->data != NULL) {
free(s->data);
s->data = NULL;
s->len = 0;
s->rpos = 0;
}
free(s->data);
s->data = NULL;
s->len = 0;
s->rpos = 0;
s->wpos = 0;
}

size_t serial_len(serial *s) {
return s->len;
return s->wpos;
}

void serial_read_reset(serial *s) {
s->rpos = 0;
}

void serial_read(serial *s, char *buf, int len) {
if(len + s->rpos > s->len) {
len = s->len - s->rpos;
void serial_read(serial *s, char *buf, size_t len) {
if(len + s->rpos > s->wpos) {
len = s->wpos - s->rpos;
}
memcpy(buf, s->data+s->rpos, len);
memcpy(buf, s->data + s->rpos, len);
s->rpos += len;
if (s->rpos > s->len) {
s->rpos = s->len;
if(s->rpos > s->wpos) {
s->rpos = s->wpos;
}
}

Expand Down

0 comments on commit 5c79e3e

Please sign in to comment.