feat(snapshot): add container hash map

store a container hash map in side the snapshot to map offsets in an migartion attemp

BREAKING CHANGE:  issue #112

Author: Julian

inkcpp/include/snapshot.h

@@ -26,7 +26,7 @@ namespace ink::runtime
 class snapshot
 {
 public:
-	virtual ~snapshot(){};
+	virtual ~snapshot() {};
 
 	/** Construct snapshot from blob.
 	 * Memory must be kept valid until the snapshot is deconstructed.
@@ -39,13 +39,13 @@ class snapshot
 	static snapshot* from_binary(const unsigned char* data, size_t length, bool freeOnDestroy = true);
 
 	/** access blob inside snapshot */
-	virtual const unsigned char* get_data() const     = 0;
+	virtual const unsigned char* get_data() const       = 0;
 	/** size of blob inside snapshot */
-	virtual size_t               get_data_len() const = 0;
+	virtual size_t               get_data_len() const   = 0;
 	/** number of runners which are stored inside this snapshot */
-	virtual size_t               num_runners() const  = 0;
+	virtual size_t               num_runners() const    = 0;
 	/** hash of story to check for story changes on load. */
-	virtual hash_t get_story_hash() const = 0;
+	virtual hash_t               get_story_hash() const = 0;
 
 #ifdef INK_ENABLE_STL
 	/** deserialize snapshot from file.

inkcpp/snapshot_impl.cpp

@@ -54,9 +54,11 @@ void snapshot::write_to_file(const char* filename) const
 
 namespace ink::runtime::internal
 {
-size_t snapshot_impl::file_size(size_t serialization_length, size_t runner_cnt)
+size_t
+    snapshot_impl::file_size(size_t serialization_length, size_t runner_cnt, size_t num_container)
 {
-	return serialization_length + sizeof(header) + (runner_cnt + 1) * sizeof(size_t);
+	return serialization_length + sizeof(header) + (runner_cnt + 1 + 1) * sizeof(uint32_t)
+	     + num_container * sizeof(uint32_t) * 3;
 }
 
 const unsigned char* snapshot_impl::get_data() const { return _file; }
@@ -67,7 +69,8 @@ snapshot_impl::snapshot_impl(const globals_impl& globals)
     : _managed{true}
 {
 	snapshot_interface::snapper snapper{globals.strings(), globals._owner->string(0)};
-	_length           = globals.snap(nullptr, snapper);
+	_length = 0;
+	_length += globals.snap(nullptr, snapper);
 	size_t runner_cnt = 0;
 	for (auto node = globals._runners_start; node; node = node->next) {
 		_length += node->object->snap(nullptr, snapper);
@@ -77,19 +80,24 @@ snapshot_impl::snapshot_impl(const globals_impl& globals)
 	    runner_cnt > 0,
 	    "No runner assoziated with global you want to snap. This will just store the initial state."
 	);
-	_length             = file_size(_length, runner_cnt);
-	_header.story_hash  = globals._runners_start->object->_story->get_hash();
-	_header.length      = _length;
-	_header.num_runners = runner_cnt;
-	unsigned char* data = new unsigned char[_length];
-	_file               = data;
-	unsigned char* ptr  = data;
+	const story_impl* story = globals._runners_start->object->_story;
+	_header.num_container   = (story->_container_hash_end - story->_container_hash_start) / 2;
+	_length                 = file_size(_length, runner_cnt, _header.num_container);
+	_header.story_hash      = story->get_hash();
+	_header.length          = _length;
+	_header.num_runners     = runner_cnt;
+	unsigned char* data     = new unsigned char[_length];
+	_file                   = data;
+	unsigned char* ptr      = data;
 	// write header
 	memcpy(ptr, &_header, sizeof(_header));
 	// write lookup table
 	ptr += sizeof(header);
 	{
-		size_t offset = (ptr - data) + (_header.num_runners + 1) * sizeof(size_t);
+		uint32_t offset = (ptr - data) + (_header.num_runners + 1 + 1) * sizeof(uint32_t);
+		memcpy(ptr, &offset, sizeof(offset));
+		ptr += sizeof(offset);
+		offset += _header.num_container * sizeof(uint32_t) * 3;
 		memcpy(ptr, &offset, sizeof(offset));
 		ptr += sizeof(offset);
 		offset += globals.snap(nullptr, snapper);
@@ -100,6 +108,21 @@ snapshot_impl::snapshot_impl(const globals_impl& globals)
 		}
 	}
 
+	uint32_t container_value;
+	for (size_t i = 0; i < _header.num_container; ++i) {
+		container_value = story->_container_hash_start[i * 2];
+		memcpy(ptr, &container_value, sizeof(container_value));
+		ptr += sizeof(container_value);
+		container_value = story->_container_hash_start[i * 2 + 1];
+		memcpy(ptr, &container_value, sizeof(container_value));
+		ptr += sizeof(container_value);
+		if (!story->get_container_id(story->_container_hash_start[i * 2 + 1] + story->instructions(), container_value)) {
+			container_value = ~0;
+		}
+		memcpy(ptr, &container_value, sizeof(container_value));
+		ptr += sizeof(container_value);
+	}
+
 	ptr += globals.snap(ptr, snapper);
 	for (auto node = globals._runners_start; node; node = node->next) {
 		ptr += node->object->snap(ptr, snapper);

inkcpp/snapshot_impl.h

@@ -104,20 +104,22 @@ class snapshot_impl : public snapshot
 	const unsigned char*                        _file;
 	size_t                                      _length;
 	bool                                        _managed;
-	static size_t                               file_size(size_t, size_t);
+	static size_t                               file_size(size_t, size_t, size_t);
 
 	struct header {
 		const char* magic_sequence = "INKCPP_SNAP";
 		const char  version[3]     = {config::version[0], config::version[1], config::version[2]};
 		hash_t      story_hash;
-		size_t      num_runners;
-		size_t      length;
+		uint32_t      num_runners;
+		uint32_t      num_container;
+		uint32_t      length;
 	} _header;
 
 	size_t get_offset(size_t idx) const
 	{
+		// 0 - container hashes, 1 - globals, 2 + runner
 		inkAssert(idx <= _header.num_runners, "Out of Bound access for runner in snapshot.");
-		return reinterpret_cast<const size_t*>(_file + sizeof(header))[idx];
+		return reinterpret_cast<const uint32_t*>(_file + sizeof(header))[idx + 1];
 	}
 };
 } // namespace ink::runtime::internal

inkcpp/story_impl.h

@@ -19,6 +19,7 @@ namespace ink::runtime::internal
 // Ink story. Constant once constructed. Can be shared safely between multiple runner instances
 class story_impl : public story
 {
+	friend snapshot_impl;
 public:
 #ifdef INK_ENABLE_STL
 	story_impl(const char* filename);
@@ -83,7 +84,7 @@ class story_impl : public story
 	uint32_t  _container_list_size;
 	uint32_t  _num_containers;
 
-	// container hashes
+	// container hashes (hash,offset)
 	hash_t* _container_hash_start;
 	hash_t* _container_hash_end;
 

inkcpp_compiler/binary_emitter.cpp

@@ -12,11 +12,6 @@
 
 #include <vector>
 #include <map>
-#include <fstream>
-
-#ifndef WIN32
-#	include <cstring>
-#endif
 
 namespace ink::compiler::internal
 {