Extract xlap timestamping into separate module.

.gitlab-ci.yml

 variables:
   PYPI_USER: SECURE
   PYPI_PASSWORD: SECURE
+  GIT_SUBMODULE_STRATEGY: recursive
 
 stages:
   - build

.gitmodules

+[submodule "prrt/xlap"]
+	path = prrt/xlap
+	url = ../../as/X-Lap.git

prrt/cprrt.pxd

@@ -121,16 +121,16 @@ cdef extern from "proto/socket.h":
     bint PrrtSocket_set_sock_opt(PrrtSocket *sock_ptr, const_char *name, const uint32_t value)
     uint32_t PrrtSocket_get_sock_opt(PrrtSocket *sock_ptr, const_char *name)
 
-cdef extern from "proto/timestamp.h":
-    ctypedef struct PrrtTimestampTable:
+cdef extern from "xlap/xlap.h":
+    ctypedef struct XlapTimestampTable:
         pass
 
-    cdef enum PrrtTimestampPacketKind:
+    cdef enum XlapTimestampPacketKind:
         ts_data_packet = 0,
         ts_any_packet = 0,
         ts_redundancy_packet = 1
 
-    void PrrtTimestampTableInstall(PrrtSocket* sck, PrrtTimestampPacketKind kind, PrrtTimestampTable* tstp);
+    void XlapTimestampTableInstall(PrrtSocket* sck, XlapTimestampPacketKind kind, XlapTimestampTable* tstp);
 
 cdef extern from "util/bptree.h":
     ctypedef struct BPTreeNode:

prrt/proto/CMakeLists.txt

@@ -6,7 +6,7 @@ add_library(PRRT ../defines.h
         packet.c packet.h
         receiver.c receiver.h
         socket.c socket.h
-        timestamp.c timestamp.h
+        ../xlap/xlap.c ../xlap/xlap.h
         applicationConstraints.c applicationConstraints.h
         vdmcode/block_code.c vdmcode/block_code.h
         stores/forwardPacketTable.c stores/forwardPacketTable.h

prrt/proto/processes/dataReceiver.c

@@ -111,9 +111,9 @@ static void handle_data_packet(PrrtSocket *sock_ptr, PrrtPacket *packet, struct
 
 	prrtSequenceNumber_t seqno = packet->sequenceNumber;
 
-	PrrtTimeStampCycle(sock_ptr, ts_data_packet, seqno, SendFeedbackStart);
+	XlapTimeStampCycle(sock_ptr, ts_data_packet, seqno, SendFeedbackStart);
     check(send_feedback(sock_ptr, remote), "Sending feedback failed.");
-	PrrtTimeStampCycle(sock_ptr, ts_data_packet, seqno, SendFeedbackEnd);
+	XlapTimeStampCycle(sock_ptr, ts_data_packet, seqno, SendFeedbackEnd);
 
     prrtTimestamp_t now = PrrtClock_get_prrt_time_us(&sock_ptr->clock);
     if(is_timeout(now, payload->packetTimeout_us)) {
@@ -144,7 +144,7 @@ static void handle_data_packet(PrrtSocket *sock_ptr, PrrtPacket *packet, struct
         // forward to application layer
 		debug(DEBUG_DATARECEIVER, "forward %u", seqno);
 
-		PrrtTimeStampCycle(sock_ptr, ts_data_packet, seqno, PrrtReturnPackage);
+		XlapTimeStampCycle(sock_ptr, ts_data_packet, seqno, PrrtReturnPackage);
         check(pthread_mutex_lock(&sock_ptr->inQueueFilledMutex) == 0, "Lock failed.");
         List_push(sock_ptr->inQueue, packet);
         check(pthread_cond_signal(&sock_ptr->inQueueFilledCv) == 0, "Cond signal failed.");
@@ -198,46 +198,46 @@ void *receive_data_loop(void *ptr)
     PrrtSocket *sock_ptr = ptr;
 
     while(1) {
-		PrrtTimestampPlaceholder tsph1;
-		PrrtTimestampPlaceholder tsph2;
-		PrrtTimestampPlaceholder tsph3;
-		PrrtTimestampPlaceholderInitialize(&tsph1);
-		PrrtTimestampPlaceholderInitialize(&tsph2);
-		PrrtTimestampPlaceholderInitialize(&tsph3);
+		XlapTimestampPlaceholder tsph1;
+		XlapTimestampPlaceholder tsph2;
+		XlapTimestampPlaceholder tsph3;
+		XlapTimestampPlaceholderInitialize(&tsph1);
+		XlapTimestampPlaceholderInitialize(&tsph2);
+		XlapTimestampPlaceholderInitialize(&tsph3);
 
         memset(buffer, 0, MAX_PAYLOAD_LENGTH);
         n = recvfrom(sock_ptr->dataSocketFd, buffer, MAX_PAYLOAD_LENGTH, 0, (struct sockaddr *) &remote, &addrlen);
         sock_ptr->lastReceivedTimestamp = PrrtClock_get_current_time_us();
-		PrrtTimeStampClock(&tsph1, ts_any_packet, 0, LinkReceive);
-		PrrtTimeStampCycle(&tsph1, ts_any_packet, 0, LinkReceive);
+		XlapTimeStampClock(&tsph1, ts_any_packet, 0, LinkReceive);
+		XlapTimeStampCycle(&tsph1, ts_any_packet, 0, LinkReceive);
 
         PrrtPacket *packet = (PrrtPacket *) calloc(1, sizeof(PrrtPacket));
         check_mem(packet);
 
-		PrrtTimeStampCycle(&tsph2, ts_any_packet, 0, DecodeStart);
+		XlapTimeStampCycle(&tsph2, ts_any_packet, 0, DecodeStart);
         check(PrrtPacket_decode(buffer, (uint16_t) n, packet), "Decode failed.");
-		PrrtTimeStampCycle(&tsph3, ts_any_packet, 0, DecodeEnd);
+		XlapTimeStampCycle(&tsph3, ts_any_packet, 0, DecodeEnd);
 
 		prrtSequenceNumber_t seqno = packet->sequenceNumber;
 
         prrtPacketType_t packetType = PrrtPacket_type(packet);
 		debug(DEBUG_DATARECEIVER, "received packet %d:%u", (int) packetType, seqno);
         if(packetType == PACKET_TYPE_DATA) {
-			PrrtTimestampPlaceholderUse(sock_ptr, ts_data_packet, seqno, &tsph1);
-			PrrtTimestampPlaceholderUse(sock_ptr, ts_data_packet, seqno, &tsph2);
-			PrrtTimestampPlaceholderUse(sock_ptr, ts_data_packet, seqno, &tsph3);
+			XlapTimestampPlaceholderUse(sock_ptr, ts_data_packet, seqno, &tsph1);
+			XlapTimestampPlaceholderUse(sock_ptr, ts_data_packet, seqno, &tsph2);
+			XlapTimestampPlaceholderUse(sock_ptr, ts_data_packet, seqno, &tsph3);
 
-			PrrtTimeStampCycle(sock_ptr, ts_data_packet, seqno, HandlePacketStart);
+			XlapTimeStampCycle(sock_ptr, ts_data_packet, seqno, HandlePacketStart);
             handle_data_packet(sock_ptr, packet, remote);
-			PrrtTimeStampCycle(sock_ptr, ts_data_packet, seqno, HandlePacketEnd);
+			XlapTimeStampCycle(sock_ptr, ts_data_packet, seqno, HandlePacketEnd);
         } else if(packetType == PACKET_TYPE_REDUNDANCY) {
-			PrrtTimestampPlaceholderUse(sock_ptr, ts_redundancy_packet, seqno, &tsph1);
-			PrrtTimestampPlaceholderUse(sock_ptr, ts_redundancy_packet, seqno, &tsph2);
-			PrrtTimestampPlaceholderUse(sock_ptr, ts_redundancy_packet, seqno, &tsph3);
+			XlapTimestampPlaceholderUse(sock_ptr, ts_redundancy_packet, seqno, &tsph1);
+			XlapTimestampPlaceholderUse(sock_ptr, ts_redundancy_packet, seqno, &tsph2);
+			XlapTimestampPlaceholderUse(sock_ptr, ts_redundancy_packet, seqno, &tsph3);
 
-			PrrtTimeStampCycle(sock_ptr, ts_redundancy_packet, seqno, HandlePacketStart);
+			XlapTimeStampCycle(sock_ptr, ts_redundancy_packet, seqno, HandlePacketStart);
             handle_redundancy_packet(sock_ptr, packet);
-			PrrtTimeStampCycle(sock_ptr, ts_redundancy_packet, seqno, HandlePacketEnd);
+			XlapTimeStampCycle(sock_ptr, ts_redundancy_packet, seqno, HandlePacketEnd);
         } else {
             PrrtPacket_print(packet);
             PrrtPacket_destroy(packet);

prrt/proto/processes/dataTransmitter.c

@@ -21,10 +21,10 @@ static bool send_packet(PrrtSocket *sock_ptr, PrrtPacket *packet)
 
 	switch (PrrtPacket_type(packet)) {
 	case PACKET_TYPE_DATA:
-	    PrrtTimeStampCycle(sock_ptr, ts_data_packet, packet->sequenceNumber, LinkTransmitStart);
+	    XlapTimeStampCycle(sock_ptr, ts_data_packet, packet->sequenceNumber, LinkTransmitStart);
 		break;
 	case PACKET_TYPE_REDUNDANCY:
-		PrrtTimeStampCycle(sock_ptr, ts_redundancy_packet, packet->sequenceNumber, LinkTransmitStart);
+		XlapTimeStampCycle(sock_ptr, ts_redundancy_packet, packet->sequenceNumber, LinkTransmitStart);
 		break;
 	case PACKET_TYPE_REPETITION:
 	case PACKET_TYPE_FEEDBACK:
@@ -43,12 +43,12 @@ static bool send_packet(PrrtSocket *sock_ptr, PrrtPacket *packet)
     }
     switch (PrrtPacket_type(packet)) {
 	case PACKET_TYPE_DATA:
-       PrrtTimeStampClock(sock_ptr, ts_data_packet, packet->sequenceNumber, LinkTransmitEnd);
-       PrrtTimeStampCycle(sock_ptr, ts_data_packet, packet->sequenceNumber, LinkTransmitEnd);
+       XlapTimeStampClock(sock_ptr, ts_data_packet, packet->sequenceNumber, LinkTransmitEnd);
+       XlapTimeStampCycle(sock_ptr, ts_data_packet, packet->sequenceNumber, LinkTransmitEnd);
 	   break;
     case PACKET_TYPE_REDUNDANCY:
-       PrrtTimeStampClock(sock_ptr, ts_redundancy_packet, packet->sequenceNumber, LinkTransmitEnd);
-       PrrtTimeStampCycle(sock_ptr, ts_redundancy_packet, packet->sequenceNumber, LinkTransmitEnd);
+       XlapTimeStampClock(sock_ptr, ts_redundancy_packet, packet->sequenceNumber, LinkTransmitEnd);
+       XlapTimeStampCycle(sock_ptr, ts_redundancy_packet, packet->sequenceNumber, LinkTransmitEnd);
 	   break;
 	case PACKET_TYPE_REPETITION:
 	case PACKET_TYPE_FEEDBACK:
@@ -86,7 +86,7 @@ void *send_data_loop(void *ptr)
         }
 
         PrrtPacket *packet = List_shift(sock_ptr->outQueue);
-		PrrtTimeStampCycle(sock_ptr, ts_data_packet, packet->sequenceNumber, PrrtTransmitStart);
+		XlapTimeStampCycle(sock_ptr, ts_data_packet, packet->sequenceNumber, PrrtTransmitStart);
         if(block == NULL) {
             block = PrrtBlock_create(sock_ptr->codingParameters, packet->sequenceNumber);
         }
@@ -98,7 +98,7 @@ void *send_data_loop(void *ptr)
 
         PrrtPacket *packetToSend = PrrtPacket_copy(packet);
         send_packet(sock_ptr, packetToSend);
-		PrrtTimeStampCycle(sock_ptr, ts_data_packet, packet->sequenceNumber, PrrtTransmitEnd);
+		XlapTimeStampCycle(sock_ptr, ts_data_packet, packet->sequenceNumber, PrrtTransmitEnd);
 
         PrrtBlock_insert_data_packet(block, packet);
 
@@ -106,9 +106,9 @@ void *send_data_loop(void *ptr)
         if(PrrtBlock_encode_ready(block)) {
             uint32_t j = 0;
 			unsigned int redundancy_seqno = sock_ptr->sequenceNumberRedundancy;
-			PrrtTimeStampCycle(sock_ptr, ts_redundancy_packet, redundancy_seqno, PrrtEncodeStart);
+			XlapTimeStampCycle(sock_ptr, ts_redundancy_packet, redundancy_seqno, PrrtEncodeStart);
             PrrtBlock_encode(block, &sock_ptr->sequenceNumberRedundancy);
-			PrrtTimeStampCycle(sock_ptr, ts_redundancy_packet, redundancy_seqno, PrrtEncodeEnd);
+			XlapTimeStampCycle(sock_ptr, ts_redundancy_packet, redundancy_seqno, PrrtEncodeEnd);
 
             uint32_t redundancyPackets = List_count(block->redundancyPackets);
             for(j = 0; j < redundancyPackets; j++) {

prrt/proto/socket.c

@@ -152,24 +152,24 @@ int PrrtSocket_connect(PrrtSocket *sock_ptr, const char *host, const uint16_t po
 int PrrtSocket_send(PrrtSocket *sock_ptr, const uint8_t *data, const size_t data_len)
 {
     check(sock_ptr->isSender, "Cannot send on receiver socket.")
-    PrrtTimestampPlaceholder tsph;
-    PrrtTimestampPlaceholderInitialize(&tsph);
-    PrrtTimeStampClock(&tsph, ts_any_packet, 0, PrrtSendStart);
-    PrrtTimeStampCycle(&tsph, ts_any_packet, 0, PrrtSendStart);
+    XlapTimestampPlaceholder tsph;
+    XlapTimestampPlaceholderInitialize(&tsph);
+    XlapTimeStampClock(&tsph, ts_any_packet, 0, PrrtSendStart);
+    XlapTimeStampCycle(&tsph, ts_any_packet, 0, PrrtSendStart);
     prrtSequenceNumber_t sequenceNumber = sock_ptr->sequenceNumberSource++;
     PrrtPacket *packet = PrrtPacket_create_data_packet(5, data, (prrtPacketLength_t) data_len, sequenceNumber,
                                                        PrrtApplicationConstraints_get_target_delay(
                                                                sock_ptr->applicationConstraints));
-    PrrtTimestampPlaceholderUse(sock_ptr, ts_data_packet, packet->sequenceNumber, &tsph);
+    XlapTimestampPlaceholderUse(sock_ptr, ts_data_packet, packet->sequenceNumber, &tsph);
 
-    PrrtTimeStampCycle(sock_ptr, ts_data_packet, packet->sequenceNumber, PrrtSubmitPackage);
+    XlapTimeStampCycle(sock_ptr, ts_data_packet, packet->sequenceNumber, PrrtSubmitPackage);
     check(pthread_mutex_lock(&sock_ptr->outQueueFilledMutex) == 0, "Lock failed.");
     List_push(sock_ptr->outQueue, packet);
     check(pthread_cond_signal(&sock_ptr->outQueueFilledCv) == 0, "Signal failed.");
     check(pthread_mutex_unlock(&sock_ptr->outQueueFilledMutex) == 0, "Unlock failed");
 
-    PrrtTimeStampClock(sock_ptr, ts_data_packet, packet->sequenceNumber, PrrtSendEnd);
-    PrrtTimeStampCycle(sock_ptr, ts_data_packet, packet->sequenceNumber, PrrtSendEnd);
+    XlapTimeStampClock(sock_ptr, ts_data_packet, packet->sequenceNumber, PrrtSendEnd);
+    XlapTimeStampCycle(sock_ptr, ts_data_packet, packet->sequenceNumber, PrrtSendEnd);
     return 0;
     error:
     PERROR("There was a failure while sending from socket.%s", "");
@@ -190,19 +190,19 @@ int32_t PrrtSocket_recv(PrrtSocket *sock_ptr, void *buf_ptr)
             check(pthread_cond_wait(&sock_ptr->inQueueFilledCv, &sock_ptr->inQueueFilledMutex) == 0, "Wait failed.");
         }
         PrrtPacket *packet = List_shift(sock_ptr->inQueue);
-        PrrtTimeStampClock(sock_ptr, ts_data_packet, packet->sequenceNumber, PrrtReceivePackage);
-        PrrtTimeStampCycle(sock_ptr, ts_data_packet, packet->sequenceNumber, PrrtReceivePackage);
+        XlapTimeStampClock(sock_ptr, ts_data_packet, packet->sequenceNumber, PrrtReceivePackage);
+        XlapTimeStampCycle(sock_ptr, ts_data_packet, packet->sequenceNumber, PrrtReceivePackage);
 
         prrtPacketLength_t len = (prrtPacketLength_t) (packet->payloadLength - PRRT_PACKET_DATA_HEADER_SIZE);
-        PrrtTimeStampCycle(sock_ptr, ts_data_packet, packet->sequenceNumber, CopyOutputStart);
+        XlapTimeStampCycle(sock_ptr, ts_data_packet, packet->sequenceNumber, CopyOutputStart);
         PrrtPacket_copy_payload_to_buffer(buf_ptr, packet, PRRT_PACKET_DATA_HEADER_SIZE);
-        PrrtTimeStampCycle(sock_ptr, ts_data_packet, packet->sequenceNumber, CopyOutputEnd);
+        XlapTimeStampCycle(sock_ptr, ts_data_packet, packet->sequenceNumber, CopyOutputEnd);
 
         debug(DEBUG_SOCKET, "len: %d", (int) len);
 
         check(pthread_mutex_unlock(&sock_ptr->inQueueFilledMutex) == 0, "Unlock failed.");
-        PrrtTimeStampClock(sock_ptr, ts_data_packet, packet->sequenceNumber, PrrtDeliver);
-        PrrtTimeStampCycle(sock_ptr, ts_data_packet, packet->sequenceNumber, PrrtDeliver);
+        XlapTimeStampClock(sock_ptr, ts_data_packet, packet->sequenceNumber, PrrtDeliver);
+        XlapTimeStampCycle(sock_ptr, ts_data_packet, packet->sequenceNumber, PrrtDeliver);
         PrrtPacket_destroy(packet);
         return len;
     }
@@ -237,19 +237,19 @@ int32_t PrrtSocket_timedrecv(PrrtSocket *sock_ptr, void *buf_ptr, const uint32_t
             }
         }
         PrrtPacket *packet = List_shift(sock_ptr->inQueue);
-        PrrtTimeStampClock(sock_ptr, ts_data_packet, packet->sequenceNumber, PrrtReceivePackage);
-        PrrtTimeStampCycle(sock_ptr, ts_data_packet, packet->sequenceNumber, PrrtReceivePackage);
+        XlapTimeStampClock(sock_ptr, ts_data_packet, packet->sequenceNumber, PrrtReceivePackage);
+        XlapTimeStampCycle(sock_ptr, ts_data_packet, packet->sequenceNumber, PrrtReceivePackage);
 
         prrtPacketLength_t len = (prrtPacketLength_t) (packet->payloadLength - PRRT_PACKET_DATA_HEADER_SIZE);
-        PrrtTimeStampCycle(sock_ptr, ts_data_packet, packet->sequenceNumber, CopyOutputStart);
+        XlapTimeStampCycle(sock_ptr, ts_data_packet, packet->sequenceNumber, CopyOutputStart);
         PrrtPacket_copy_payload_to_buffer(buf_ptr, packet, PRRT_PACKET_DATA_HEADER_SIZE);
-        PrrtTimeStampCycle(sock_ptr, ts_data_packet, packet->sequenceNumber, CopyOutputEnd);
+        XlapTimeStampCycle(sock_ptr, ts_data_packet, packet->sequenceNumber, CopyOutputEnd);
 
         debug(DEBUG_SOCKET, "len: %d", (int) len);
 
         check(pthread_mutex_unlock(&sock_ptr->inQueueFilledMutex) == 0, "Unlock failed.");
-        PrrtTimeStampClock(sock_ptr, ts_data_packet, packet->sequenceNumber, PrrtDeliver);
-        PrrtTimeStampCycle(sock_ptr, ts_data_packet, packet->sequenceNumber, PrrtDeliver);
+        XlapTimeStampClock(sock_ptr, ts_data_packet, packet->sequenceNumber, PrrtDeliver);
+        XlapTimeStampCycle(sock_ptr, ts_data_packet, packet->sequenceNumber, PrrtDeliver);
         PrrtPacket_destroy(packet);
         return len;
     }

prrt/proto/socket.h

@@ -14,7 +14,7 @@
 #include "stores/packetTimeoutTable.h"
 #include "stores/repairBlockStore.h"
 #include "clock.h"
-#include "timestamp.h"
+#include "../xlap/xlap.h"
 
 
 typedef struct prrtSocket {
@@ -63,7 +63,7 @@ typedef struct prrtSocket {
 
     PrrtCodingParams *codingParameters;
 
-	_Atomic(PrrtTimestampTable *) tstable[2];
+	_Atomic(XlapTimestampTable *) tstable[2];
 
 	pthread_attr_t* receiveFeedbackThreadAttr;
 	pthread_attr_t* sendDataThreadAttr;

prrt/proto/timestamp.c

-#include "timestamp.h"
-
-#include <stdatomic.h>
-
-void PrrtTimestampTableDumpHeader(FILE *out)
-{
-	fprintf(out, "SeqNo,Kind" );
-#	define OUT(id) fprintf(out, ",%s_T,%s_C", #id, #id);
-	PP_foreach(PP_join_space, OUT, TIMESTAMP_ID_LIST)
-#	undef OUT
-	fprintf(out, "\n");
-}
-
-static inline unsigned long long timestampByTime(struct timespec *ts)
-{
-	// convert timespec to microseconds
-	unsigned long long x = ts->tv_sec;
-	x *= 1000000ULL;
-	x += ts->tv_nsec / 1000;
-	return x;
-}
-
-void PrrtTimestampTableDump(FILE *out, PrrtTimestampPacketKind kind, PrrtTimestampTable *table)
-{
-#	define OUT(id) fprintf(out, ",%llu,%llu", timestampByTime(&table->rows[row].time[ts_##id].actual.t), (unsigned long long) table->rows[row].time[ts_##id].actual.c);
-	for (unsigned int row = 0; row < TS_ROWS; row++) {
-		fprintf(out, "%u,%u", row, (unsigned) kind);
-		PP_foreach(PP_join_space, OUT, TIMESTAMP_ID_LIST)
-		fprintf(out, "\n");
-	}
-#	undef OUT
-}

prrt/proto/timestamp.h

-#ifndef PRRT_TIMESTAMP_H
-#define PRRT_TIMESTAMP_H
-
-#include <stdio.h>
-#include <stdint.h>
-#include <time.h>
-
-/*
- * Each timestamp contains both a cycle value and a time value, but some values
- * might remain zero
- */
-typedef union PrrtTimestamp {
-	struct PrrtActualTimestamp {
-		uint64_t c;
-		struct timespec t;
-	} actual;
-	char _cacheline[64];
-} PrrtTimestamp;
-
-#include "../util/pp.h"
-
-/*
- * Comma-separated list of timestamp IDs
- */
-#define TIMESTAMP_ID_LIST \
-	PrrtSendStart, \
-	PrrtSendEnd, \
-	PrrtSubmitPackage, \
-	PrrtEncodeStart, \
-	PrrtEncodeEnd, \
-	PrrtTransmitStart, \
-	PrrtTransmitEnd, \
-	LinkTransmitStart, \
-	LinkTransmitEnd, \
-	LinkReceive, \
-	DecodeStart, \
-	DecodeEnd, \
-	HandlePacketStart, \
-	HandlePacketEnd, \
-	CopyOutputStart, \
-	CopyOutputEnd, \
-	SendFeedbackStart, \
-	SendFeedbackEnd, \
-	PrrtReturnPackage, \
-	PrrtReceivePackage, \
-	PrrtDeliver \
-
-#define TIMESSTAMP_ID_TO_NAME(id) ts_##id
-
-/*
- * enum containing all timestamp IDs
- */
-typedef enum PrrtTimestampId {
-	PP_foreach(PP_join_comma, TIMESSTAMP_ID_TO_NAME, TIMESTAMP_ID_LIST),
-	ts_count
-} PrrtTimestampId;
-
-/*
- * enum to distinguish between data and redundancy packet timstamps
- */
-typedef enum PrrtTimestampPacketKind {
-	ts_data_packet = 0,
-	ts_any_packet = 0,
-	ts_redundancy_packet = 1,
-} PrrtTimestampPacketKind;
-
-/*
- * Table that stores timestamps for each timestamp ID
- */
-typedef struct PrrtTimestampTableRow {
-	PrrtTimestamp time[ts_count];
-} PrrtTimestampTableRow;
-
-/*
- * by default, store timestamps for 128 packages
- */
-#ifndef TS_ROWS
-#define TS_ROWS (1u<<12)
-#endif
-
-/*
- * Table that stores timestamp table rows
- */
-typedef struct PrrtTimestampTable {
-	PrrtTimestampTableRow rows[TS_ROWS];
-} PrrtTimestampTable;
-
-/*
- * Dummy data structure to store a single timestamp table row.
- */
-typedef struct PrrtTimestampPlaceholder {
-	_Atomic(PrrtTimestampTable *) tstable[1];
-	PrrtTimestampTableRow rows[1];
-} PrrtTimestampPlaceholder;
-
-/*
- * update the clock value of a timestamp
- *
- * This macro will cause a SIGSEGV if the application does not install a
- * timestamp table to the prrt socket.
- */
-#define PrrtTimeStampClock(sck, kind, seqno, id) do { \
-		clock_gettime(CLOCK_MONOTONIC, &atomic_load_explicit(&(sck)->tstable[kind], memory_order_acquire)->rows[(seqno) % TS_ROWS].time[ts_##id].actual.t); \
-	} while (0);
-
-/*
- * update the cycle value of a timestamp
- *
- * This macro will cause a SIGSEGV if the application does not install a
- * timestamp table to the prrt socket.
- */
-#define PrrtTimeStampCycle(sck, kind, seqno, id) do { \
-		atomic_load_explicit(&(sck)->tstable[kind], memory_order_acquire)->rows[(seqno) % TS_ROWS].time[ts_##id].actual.c = __builtin_ia32_rdtsc(); \
-	} while (0);
-
-/*
- * install a time stamp table to a socket
- */
-#define PrrtTimestampTableInstall(sck, kind, tstp) do { \
-		PrrtTimestampTable *__tstp = (tstp); \
-		memset(__tstp, 0, sizeof(PrrtTimestampTable)); \
-		atomic_store_explicit(&(sck)->tstable[kind], __tstp, memory_order_release); \
-	} while (0)
-
-/*
- * print a timestamp dump header
- */
-extern void PrrtTimestampTableDumpHeader(FILE *);
-
-/*
- * dump a timestamp table
- */
-extern void PrrtTimestampTableDump(FILE *, PrrtTimestampPacketKind, PrrtTimestampTable *);
-
-/*
- * use a specific timestamp table
- */
-extern void PrrtTimestampTableUse(PrrtTimestampTable *);
-
-/*
- * intialize a timestamp table placeholder
- */
-#define PrrtTimestampPlaceholderInitialize(ph) do { \
-		PrrtTimestampPlaceholder *__ph = (ph); \
-		atomic_store_explicit(&__ph->tstable[0], (PrrtTimestampTable *) &__ph->rows, memory_order_release); \
-		memset(&__ph->rows, 0x0, sizeof(PrrtTimestampTableRow)); \
-	} while (0);
-
-/*
- * copy a timestamp table placeholder into an actual timestamp table
- *
- * Since every timestamp is taken at most once, either the timestamptable or
- * the placeholder value must be zero (for each timestamp).
- */
-#define PrrtTimestampPlaceholderUse(sck, kind, seqno, ph) do { \
-		PrrtTimestampPlaceholder *__ph = (ph); \
-		PrrtTimestampTable       *__ts = atomic_load_explicit(&(sck)->tstable[kind], memory_order_acquire); \
-		for (unsigned int __t = 0; __t < ts_count; __t++) { \
-			__ts->rows[seqno % TS_ROWS].time[__t].actual.t.tv_sec  += __ph->rows[0].time[__t].actual.t.tv_sec; \
-			__ts->rows[seqno % TS_ROWS].time[__t].actual.t.tv_nsec += __ph->rows[0].time[__t].actual.t.tv_nsec; \
-			__ts->rows[seqno % TS_ROWS].time[__t].actual.c         += __ph->rows[0].time[__t].actual.c; \
-		} \
-	} while (0)
-
-#endif // PRRT_TIMESTAMP_H

prrt/prrt.pyx

@@ -6,7 +6,7 @@ cimport cprrt
 cdef extern from "proto/applicationConstraints.c":
     pass
 
-cdef extern from "proto/timestamp.c":
+cdef extern from "xlap/xlap.c":
     pass
 
 cdef extern from "proto/stores/dataPacketStore.c":
@@ -69,18 +69,18 @@ cdef extern from "util/list.c":
 cdef class PrrtSocket:
     cdef cprrt.PrrtSocket* _c_socket
     cdef bint isSender
-    cdef cprrt.PrrtTimestampTable* tstable_data
-    cdef cprrt.PrrtTimestampTable* tstable_redundancy
+    cdef cprrt.XlapTimestampTable* tstable_data
+    cdef cprrt.XlapTimestampTable* tstable_redundancy
 
     def __cinit__(self, port, isSender):
         self._c_socket = cprrt.PrrtSocket_create(isSender)
         cprrt.PrrtSocket_bind(self._c_socket, "0.0.0.0", port)
 
-        self.tstable_data       = <cprrt.PrrtTimestampTable*> malloc(sizeof(cprrt.PrrtTimestampTable))
-        self.tstable_redundancy = <cprrt.PrrtTimestampTable*> malloc(sizeof(cprrt.PrrtTimestampTable))
+        self.tstable_data       = <cprrt.XlapTimestampTable*> malloc(sizeof(cprrt.XlapTimestampTable))
+        self.tstable_redundancy = <cprrt.XlapTimestampTable*> malloc(sizeof(cprrt.XlapTimestampTable))
 
-        cprrt.PrrtTimestampTableInstall(self._c_socket, cprrt.ts_data_packet,       self.tstable_data)
-        cprrt.PrrtTimestampTableInstall(self._c_socket, cprrt.ts_redundancy_packet, self.tstable_redundancy)
+        cprrt.XlapTimestampTableInstall(self._c_socket, cprrt.ts_data_packet,       self.tstable_data)
+        cprrt.XlapTimestampTableInstall(self._c_socket, cprrt.ts_redundancy_packet, self.tstable_redundancy)
 
         self.isSender = isSender
 

prrt/receiver.c

@@ -36,12 +36,12 @@ int main(int argc, char* const argv[]) {
     check(PrrtSocket_bind(sock, "0.0.0.0", port), "bind failed");
     check(sock != NULL, "Could not create socket.");
 
-	PrrtTimestampTable *tstable_data       = malloc(sizeof(PrrtTimestampTable));
-	PrrtTimestampTable *tstable_redundancy = malloc(sizeof(PrrtTimestampTable));
+	XlapTimestampTable *tstable_data       = malloc(sizeof(XlapTimestampTable));
+	XlapTimestampTable *tstable_redundancy = malloc(sizeof(XlapTimestampTable));
 	check(tstable_data       != NULL, "malloc failed");
 	check(tstable_redundancy != NULL, "malloc failed");
-	PrrtTimestampTableInstall(sock, ts_data_packet,       tstable_data);
-	PrrtTimestampTableInstall(sock, ts_redundancy_packet, tstable_redundancy);
+	XlapTimestampTableInstall(sock, ts_data_packet,       tstable_data);
+	XlapTimestampTableInstall(sock, ts_redundancy_packet, tstable_redundancy);
 
     uint32_t i = 0;
     while(i < rounds && keepRunning) {
@@ -59,9 +59,9 @@ int main(int argc, char* const argv[]) {
         usleep(1);
     }
 
-	PrrtTimestampTableDumpHeader(out_desc);
-	PrrtTimestampTableDump(out_desc, ts_data_packet,       tstable_data);
-	PrrtTimestampTableDump(out_desc, ts_redundancy_packet, tstable_redundancy);
+    XlapTimestampTableDumpHeader(out_desc);
+    XlapTimestampTableDump(out_desc, ts_data_packet, tstable_data);
+    XlapTimestampTableDump(out_desc, ts_redundancy_packet, tstable_redundancy);
 
     if(file_output) {
         fclose(out_desc);

prrt/sender.c

@@ -36,12 +36,12 @@ int main(int argc, char *const argv[]) {
     uint16_t remote_port = port;
     PrrtSocket_connect(socket, remote_host, remote_port);
 
-    PrrtTimestampTable *tstable_data       = malloc(sizeof(PrrtTimestampTable));
-	PrrtTimestampTable *tstable_redundancy = malloc(sizeof(PrrtTimestampTable));
+    XlapTimestampTable *tstable_data       = malloc(sizeof(XlapTimestampTable));
+	XlapTimestampTable *tstable_redundancy = malloc(sizeof(XlapTimestampTable));
 	check(tstable_data       != NULL, "malloc failed");
 	check(tstable_redundancy != NULL, "malloc failed");
-	PrrtTimestampTableInstall(socket, ts_data_packet,       tstable_data);
-	PrrtTimestampTableInstall(socket, ts_redundancy_packet, tstable_redundancy);
+	XlapTimestampTableInstall(socket, ts_data_packet,       tstable_data);
+	XlapTimestampTableInstall(socket, ts_redundancy_packet, tstable_redundancy);
 
     uint32_t j = 0;
     while(j < rounds) {
@@ -56,9 +56,9 @@ int main(int argc, char *const argv[]) {
         usleep(1000);
     }
 
-	PrrtTimestampTableDumpHeader(out_desc);
-	PrrtTimestampTableDump(out_desc, ts_data_packet,       tstable_data);
-	PrrtTimestampTableDump(out_desc, ts_redundancy_packet, tstable_redundancy);
+    XlapTimestampTableDumpHeader(out_desc);
+    XlapTimestampTableDump(out_desc, ts_data_packet, tstable_data);
+    XlapTimestampTableDump(out_desc, ts_redundancy_packet, tstable_redundancy);
 
     if(file_output) {
         fclose(out_desc);

xlap @ 53cce0dd

+Subproject commit 53cce0dd62db218131b3d8fd3e81a5855b2d9be4