Create packet_slab to ecapsulate simulated annealing system, create memory-optimized undo stack

Author: blackle

src/packet_slab.c

@@ -0,0 +1,51 @@
+#include "packet_slab.h"
+#include "memory_mapper.h"
+#include <stdlib.h>
+
+struct PacketSlab_struct {
+	size_t data_size;
+	LZMAPacket* packets;
+};
+
+size_t packet_slab_memory_usage(size_t data_size)
+{
+	return sizeof(LZMAPacket) * data_size + sizeof(PacketSlab);
+}
+
+PacketSlab* packet_slab_new(size_t data_size)
+{
+	PacketSlab* slab = malloc(sizeof(PacketSlab));
+	if (slab == NULL) {
+		return NULL;
+	}
+	slab->data_size = data_size;
+
+	uint8_t* packets;
+	if (map_anonymous(sizeof(LZMAPacket) * data_size, &packets)) {
+		free(slab);
+		return NULL;
+	}
+	slab->packets = (LZMAPacket*)packets;
+
+	for (size_t i = 0; i < data_size; i++) {
+		slab->packets[i] = literal_packet();
+	}
+
+	return slab;
+}
+
+void packet_slab_free(PacketSlab* slab)
+{
+	unmap((uint8_t*) slab->packets, sizeof(LZMAPacket) * slab->data_size);
+	free(slab);
+}
+
+size_t packet_slab_size(const PacketSlab* slab)
+{
+	return slab->data_size;
+}
+
+LZMAPacket* packet_slab_packets(PacketSlab* slab)
+{
+	return slab->packets;
+}

src/packet_slab.h

@@ -0,0 +1,13 @@
+#pragma once
+#include "lzma_packet.h"
+#include <stddef.h>
+
+typedef struct PacketSlab_struct PacketSlab;
+
+size_t packet_slab_memory_usage(size_t data_size);
+
+PacketSlab* packet_slab_new(size_t data_size);
+void packet_slab_free(PacketSlab* slab);
+
+size_t packet_slab_size(const PacketSlab* slab);
+LZMAPacket* packet_slab_packets(PacketSlab* slab);

src/packet_slab_undo_stack.c

@@ -0,0 +1,95 @@
+#include "packet_slab_undo_stack.h"
+#include <stdlib.h>
+#include <assert.h>
+
+struct PacketSlabUndoHeap_struct {
+	size_t size;
+	size_t count;
+	PacketSlabUndo* heap;
+	PacketSlabUndoHeap* prev;
+};
+
+static PacketSlabUndoHeap* packet_slab_undo_heap_new(size_t size, PacketSlabUndoHeap* prev)
+{
+	PacketSlabUndoHeap* undo_heap = malloc(sizeof(PacketSlabUndoHeap));
+	if (undo_heap == NULL) {
+		return NULL;
+	}
+	undo_heap->size = size;
+	undo_heap->count = 0;
+	undo_heap->prev = prev;
+	undo_heap->heap = malloc(sizeof(PacketSlabUndo) * size);
+	if (undo_heap->heap == NULL) {
+		free(undo_heap);
+		return NULL;
+	}
+	return undo_heap;
+}
+
+static void packet_slab_undo_heap_free(PacketSlabUndoHeap* undo_heap)
+{
+	free(undo_heap->heap);
+	free(undo_heap);
+}
+
+static void packet_slab_undo_heap_apply(PacketSlabUndoHeap* undo_heap, PacketSlab* slab)
+{
+	LZMAPacket* packets = packet_slab_packets(slab);
+	while (undo_heap->count > 0) {
+		PacketSlabUndo undo = undo_heap->heap[--undo_heap->count];
+		packets[undo.position] = undo.old_packet;
+	}
+}
+
+void packet_slab_undo_stack_new(PacketSlabUndoStack* undo_stack)
+{
+	undo_stack->count = 0;
+	undo_stack->last = NULL;
+}
+
+void packet_slab_undo_stack_free(PacketSlabUndoStack* undo_stack)
+{
+	while (undo_stack->last != NULL) {
+		PacketSlabUndoHeap* undo_heap = undo_stack->last;
+		undo_stack->last = undo_heap->prev;
+		packet_slab_undo_heap_free(undo_heap);
+	}
+}
+
+void packet_slab_undo_stack_insert(PacketSlabUndoStack* undo_stack, PacketSlabUndo undo)
+{
+	if (undo_stack->count < UNDO_STACK_SIZE) {
+		undo_stack->stack[undo_stack->count++] = undo;
+		return;
+	}
+
+	if (undo_stack->last == NULL || undo_stack->last->size == undo_stack->last->count) {
+		size_t next_size = UNDO_STACK_SIZE*2;
+		if (undo_stack->last != NULL) {
+			next_size = undo_stack->last->size*2;
+		}
+		PacketSlabUndoHeap* prev = undo_stack->last;
+		undo_stack->last = packet_slab_undo_heap_new(next_size, prev);
+	}
+
+	assert(undo_stack->last != NULL);
+
+	undo_stack->last->heap[undo_stack->last->count++] = undo;
+}
+
+void packet_slab_undo_stack_apply(PacketSlabUndoStack* undo_stack, PacketSlab* slab)
+{
+	while (undo_stack->last != NULL) {
+		PacketSlabUndoHeap* undo_heap = undo_stack->last;
+		undo_stack->last = undo_heap->prev;
+
+		packet_slab_undo_heap_apply(undo_heap, slab);
+		packet_slab_undo_heap_free(undo_heap);
+	}
+
+	LZMAPacket* packets = packet_slab_packets(slab);
+	while (undo_stack->count > 0) {
+		PacketSlabUndo undo = undo_stack->stack[--undo_stack->count];
+		packets[undo.position] = undo.old_packet;
+	}
+}

src/packet_slab_undo_stack.h

@@ -0,0 +1,26 @@
+#pragma once
+#include "lzma_state.h"
+#include "packet_slab.h"
+#include <stddef.h>
+
+//todo: this explination sucks
+//this structure stores a list of undo states. this is generated by the slab neighbour generator and can be used to return to the last slab if it is not suitable
+
+typedef struct {
+	size_t position;
+	LZMAPacket old_packet;
+} PacketSlabUndo;
+
+typedef struct PacketSlabUndoHeap_struct PacketSlabUndoHeap;
+
+#define UNDO_STACK_SIZE 32
+typedef struct {
+	size_t count;
+	PacketSlabUndo stack[UNDO_STACK_SIZE];
+	PacketSlabUndoHeap* last;
+} PacketSlabUndoStack;
+
+void packet_slab_undo_stack_new(PacketSlabUndoStack* undo_stack);
+void packet_slab_undo_stack_free(PacketSlabUndoStack* undo_stack);
+void packet_slab_undo_stack_insert(PacketSlabUndoStack* undo_stack, PacketSlabUndo undo);
+void packet_slab_undo_stack_apply(PacketSlabUndoStack* undo_stack, PacketSlab* slab);

src/substring_enumerator.c

@@ -23,7 +23,7 @@ size_t substring_enumerator_memory_usage(size_t data_size)
 	return sizeof(size_t) * data_size + sizeof(SubstringEnumerator);
 }
 
-void memoize_bigram_positions(SubstringEnumerator* em)
+static void memoize_bigram_positions(SubstringEnumerator* em)
 {
 	const uint8_t* data = em->data;
 	size_t data_size = em->data_size;

tests/main.c

@@ -1,12 +1,14 @@
 #include "max_heap_test.h"
 #include "substring_enumerator_test.h"
+#include "packet_slab_undo_stack_test.h"
 
 int main(int argc, char** argv)
 {
 	(void) argc; (void) argv;
 
 	substring_enumerator_test();
 	max_heap_test();
+	packet_slab_undo_stack_test();
 
 	return 0;
 }

tests/packet_slab_undo_stack_test.c

@@ -0,0 +1,74 @@
+#include "packet_slab_undo_stack_test.h"
+#include "test_util.h"
+#include "../src/lzma_packet.h"
+#include "../src/packet_slab.h"
+#include "../src/packet_slab_undo_stack.h"
+
+#define SLAB_SIZE 1024
+
+static void packet_slab_undo_stack_test_apply()
+{
+	PRETTY_PRINT_SUB_TEST_NAME();
+
+	fprintf(stderr, "allocating PacketSlab of size %ld\n", (size_t)SLAB_SIZE);
+	PacketSlab* slab = packet_slab_new(SLAB_SIZE);
+
+	TEST_ASSERT(slab != NULL, "Could not allocate slab!");
+
+	PacketSlabUndoStack undo_stack;
+	packet_slab_undo_stack_new(&undo_stack);
+
+	fprintf(stderr, "changing all packets to shortreps...\n");
+	LZMAPacket* packets = packet_slab_packets(slab);
+	for (size_t i = 0; i < SLAB_SIZE; i++) {
+		PacketSlabUndo undo = { .position = i, .old_packet = packets[i] };
+		packets[i] = short_rep_packet();
+		packet_slab_undo_stack_insert(&undo_stack, undo);
+	}
+	fprintf(stderr, "undoing shortreps...\n");
+	packet_slab_undo_stack_apply(&undo_stack, slab);
+	for (size_t i = 0; i < SLAB_SIZE; i++) {
+		TEST_ASSERT_EQ(packets[i].type, LITERAL, "Packet edit was not undone! expected: %d, got %d");
+	}
+
+	fprintf(stderr, "freeing memory...\n");
+	packet_slab_undo_stack_free(&undo_stack);
+	packet_slab_free(slab);
+}
+
+static void packet_slab_undo_stack_test_free()
+{
+	PRETTY_PRINT_SUB_TEST_NAME();
+
+	fprintf(stderr, "allocating PacketSlab of size %ld\n", (size_t)SLAB_SIZE);
+	PacketSlab* slab = packet_slab_new(SLAB_SIZE);
+
+	TEST_ASSERT(slab != NULL, "Could not allocate slab!");
+
+	PacketSlabUndoStack undo_stack;
+	packet_slab_undo_stack_new(&undo_stack);
+
+	fprintf(stderr, "changing all packets to shortreps...\n");
+	LZMAPacket* packets = packet_slab_packets(slab);
+	for (size_t i = 0; i < SLAB_SIZE; i++) {
+		PacketSlabUndo undo = { .position = i, .old_packet = packets[i] };
+		packets[i] = short_rep_packet();
+		packet_slab_undo_stack_insert(&undo_stack, undo);
+	}
+	fprintf(stderr, "not undoing shortreps...\n");
+	for (size_t i = 0; i < SLAB_SIZE; i++) {
+		TEST_ASSERT_EQ(packets[i].type, SHORT_REP, "Packet edit was not applied! expected: %d, got %d");
+	}
+
+	fprintf(stderr, "freeing memory...\n");
+	packet_slab_undo_stack_free(&undo_stack);
+	packet_slab_free(slab);
+}
+
+void packet_slab_undo_stack_test()
+{
+	PRETTY_PRINT_TEST_NAME();
+
+	packet_slab_undo_stack_test_apply();
+	packet_slab_undo_stack_test_free();
+}

tests/packet_slab_undo_stack_test.h

@@ -0,0 +1,3 @@
+#pragma once
+
+void packet_slab_undo_stack_test();

tests/test_util.h

@@ -1,5 +1,6 @@
 #include <stdio.h>
 #include <stdlib.h>
+#include <assert.h>
 
 #define PRETTY_PRINT_TEST_NAME() \
 { \
@@ -17,7 +18,7 @@
 		fprintf(stderr, "ERROR: "); \
 		fprintf(stderr, msg); \
 		fprintf(stderr, "\n"); \
-		exit(-1); \
+		assert(0); \
 	} \
 }
 
@@ -29,6 +30,6 @@
 		fprintf(stderr, "ERROR: "); \
 		fprintf(stderr, msg, __EXPECT_STOR, __GOT_STOR); \
 		fprintf(stderr, "\n"); \
-		exit(-1); \
+		assert(0); \
 	} \
 }