chore: savepoint

Author: ckerr

utp_api.cpp

@@ -22,6 +22,7 @@
  * THE SOFTWARE.
  */
 
+#include <assert.h>
 #include <stdio.h>
 #include "utp_internal.h"
 #include "utp_utils.h"
@@ -72,7 +73,6 @@ struct_utp_context::struct_utp_context()
 	memset(&context_stats, 0, sizeof(context_stats));
 	memset(callbacks, 0, sizeof(callbacks));
 	target_delay = CCONTROL_TARGET;
-	utp_sockets = new UTPSocketHT;
 
 	callbacks[UTP_GET_UDP_MTU]      = &utp_default_get_udp_mtu;
 	callbacks[UTP_GET_UDP_OVERHEAD] = &utp_default_get_udp_overhead;
@@ -92,10 +92,6 @@ struct_utp_context::struct_utp_context()
 	last_check = 0;
 }
 
-struct_utp_context::~struct_utp_context() {
-	delete this->utp_sockets;
-}
-
 utp_context* utp_init (int version)
 {
 	assert(version == 2);

utp_hash.cpp

@@ -20,73 +20,20 @@
  * THE SOFTWARE.
  */
 
-#include <assert.h>
-
 #include "utp_hash.h"
 #include "utp_types.h"
 
-#define LIBUTP_HASH_UNUSED ((utp_link_t)-1)
-
 #ifdef STRICT_ALIGN
 inline uint32 Read32(const void *p)
 {
 	uint32 tmp;
 	memcpy(&tmp, p, sizeof tmp);
 	return tmp;
 }
-
 #else
 inline uint32 Read32(const void *p) { return *(uint32*)p; }
 #endif
 
-
-// Get the amount of memory required for the hash parameters and the bucket set
-// Waste a space for an unused bucket in order to ensure the following managed memory have 32-bit aligned addresses
-// TODO:  make this 64-bit clean
-#define BASE_SIZE(bc) (sizeof(utp_hash_t) + sizeof(utp_link_t) * ((bc) + 1 - 1))
-
-// Get a pointer to the base of the structure array managed by the hash table
-#define get_bep(h) ((byte*)(h)) + BASE_SIZE((h)->N)
-
-// Get the address of the information associated with a specific structure in the array,
-// given the address of the base of the structure.
-// This assumes a utp_link_t link member is at the end of the structure.
-// Given compilers filling out the memory to a 32-bit clean value, this may mean that
-// the location named in the structure may not be the location actually used by the hash table,
-// since the compiler may have padded the end of the structure with 2 bytes after the utp_link_t member.
-// TODO: this macro should not require that the variable pointing at the hash table be named 'hash'
-#define ptr_to_link(p) (utp_link_t *) (((byte *) (p)) + hash->E - sizeof(utp_link_t))
-
-// Calculate how much to allocate for a hash table with bucket count, total size, and structure count
-// TODO:  make this 64-bit clean
-#define ALLOCATION_SIZE(bc, ts, sc) (BASE_SIZE((bc)) + (ts) * (sc))
-
-utp_hash_t *utp_hash_create(int N, int key_size, int total_size, int initial, utp_hash_compute_t hashfun, utp_hash_equal_t compfun)
-{
-	// Must have odd number of hash buckets (prime number is best)
-	assert(N % 2);
-	// Ensure structures will be at aligned memory addresses
-	// TODO:  make this 64-bit clean
-	assert(0 == (total_size % 4));
-
-	int size = ALLOCATION_SIZE(N, total_size, initial);
-	utp_hash_t *hash = (utp_hash_t *) malloc( size );
-	memset( hash, 0, size );
-
-	for (int i = 0; i < N + 1; ++i)
-		hash->inits[i] = LIBUTP_HASH_UNUSED;
-	hash->N = N;
-	hash->K = key_size;
-	hash->E = total_size;
-	hash->hash_compute = hashfun;
-	hash->hash_equal = compfun;
-	hash->allocated = initial;
-	hash->count = 0;
-	hash->used = 0;
-	hash->free = LIBUTP_HASH_UNUSED;
-	return hash;
-}
-
 uint utp_hash_mem(const void *keyp, size_t keysize)
 {
 	uint hash = 0;
@@ -105,144 +52,3 @@ uint utp_hash_mem(const void *keyp, size_t keysize)
 	}
 	return hash;
 }
-
-uint utp_hash_mkidx(utp_hash_t *hash, const void *keyp)
-{
-	// Generate a key from the hash
-	return hash->hash_compute(keyp, hash->K) % hash->N;
-}
-
-static inline bool compare(byte *a, byte *b,int n)
-{
-	assert(n >= 4);
-	if (Read32(a) != Read32(b)) return false;
-	return memcmp(a+4, b+4, n-4) == 0;
-}
-
-#define COMPARE(h,k1,k2,ks) (((h)->hash_equal) ? (h)->hash_equal((void*)k1,(void*)k2,ks) : compare(k1,k2,ks))
-
-// Look-up a key in the hash table.
-// Returns NULL if not found
-void *utp_hash_lookup(utp_hash_t *hash, const void *key)
-{
-	utp_link_t idx = utp_hash_mkidx(hash, key);
-
-	// base pointer
-	byte *bep = get_bep(hash);
-
-	utp_link_t cur = hash->inits[idx];
-	while (cur != LIBUTP_HASH_UNUSED) {
-		byte *key2 = bep + (cur * hash->E);
-		if (COMPARE(hash, (byte*)key, key2, hash->K))
-			return key2;
-		cur = *ptr_to_link(key2);
-	}
-
-	return NULL;
-}
-
-// Add a new element to the hash table.
-// Returns a pointer to the new element.
-// This assumes the element is not already present!
-void *utp_hash_add(utp_hash_t **hashp, const void *key)
-{
-	//Allocate a new entry
-	byte *elemp;
-	utp_link_t elem;
-	utp_hash_t *hash = *hashp;
-	utp_link_t idx = utp_hash_mkidx(hash, key);
-
-	if ((elem=hash->free) == LIBUTP_HASH_UNUSED) {
-		utp_link_t all = hash->allocated;
-		if (hash->used == all) {
-			utp_hash_t *nhash;
-			if (all <= (LIBUTP_HASH_UNUSED/2)) {
-				all *= 2;
-			} else if (all != LIBUTP_HASH_UNUSED) {
-				all  = LIBUTP_HASH_UNUSED;
-			} else {
-				// too many items! can't grow!
-				assert(0);
-				return NULL;
-			}
-			// otherwise need to allocate.
-			nhash = (utp_hash_t*)realloc(hash, ALLOCATION_SIZE(hash->N, hash->E, all));
-			if (!nhash) {
-				// out of memory (or too big to allocate)
-				assert(nhash);
-				return NULL;
-			}
-			hash = *hashp = nhash;
-			hash->allocated = all;
-		}
-
-		elem = hash->used++;
-		elemp = get_bep(hash) + elem * hash->E;
-	} else {
-		elemp = get_bep(hash) + elem * hash->E;
-		hash->free = *ptr_to_link(elemp);
-	}
-
-	*ptr_to_link(elemp) = hash->inits[idx];
-	hash->inits[idx] = elem;
-	hash->count++;
-
-	// copy key into it
-	memcpy(elemp, key, hash->K);
-	return elemp;
-}
-
-// Delete an element from the utp_hash_t
-// Returns a pointer to the already deleted element.
-void *utp_hash_del(utp_hash_t *hash, const void *key)
-{
-	utp_link_t idx = utp_hash_mkidx(hash, key);
-
-	// base pointer
-	byte *bep = get_bep(hash);
-
-	utp_link_t *curp = &hash->inits[idx];
-	utp_link_t cur;
-	while ((cur=*curp) != LIBUTP_HASH_UNUSED) {
-		byte *key2 = bep + (cur * hash->E);
-		if (COMPARE(hash,(byte*)key,(byte*)key2, hash->K )) {
-			// found an item that matched. unlink it
-			*curp = *ptr_to_link(key2);
-			// Insert into freelist
-			*ptr_to_link(key2) = hash->free;
-			hash->free = cur;
-			hash->count--;
-			return key2;
-		}
-		curp = ptr_to_link(key2);
-	}
-
-	return NULL;
-}
-
-void *utp_hash_iterate(utp_hash_t *hash, utp_hash_iterator_t *iter)
-{
-	utp_link_t elem;
-
-	if ((elem=iter->elem) == LIBUTP_HASH_UNUSED) {
-		// Find a bucket with an element
-		utp_link_t buck = iter->bucket + 1;
-		for(;;) {
-			if (buck >= hash->N)
-				return NULL;
-			if ((elem = hash->inits[buck]) != LIBUTP_HASH_UNUSED)
-				break;
-			buck++;
-		}
-		iter->bucket = buck;
-	}
-
-	byte *elemp = get_bep(hash) + (elem * hash->E);
-	iter->elem = *ptr_to_link(elemp);
-	return elemp;
-}
-
-void utp_hash_free_mem(utp_hash_t* hash)
-{
-	free(hash);
-}

utp_hash.h

@@ -23,124 +23,8 @@
 #ifndef __UTP_HASH_H__
 #define __UTP_HASH_H__
 
-#include <string.h> // memset
-#include <stdlib.h>	// malloc
-
 #include "utp_types.h"
-#include "utp_templates.h"
-
-// TODO: make utp_link_t a template parameter to HashTable
-typedef uint32 utp_link_t;
-
-#ifdef _MSC_VER
-// Silence the warning about the C99-compliant zero-length array at the end of the structure
-#pragma warning (disable: 4200)
-#endif
-
-typedef uint32 (*utp_hash_compute_t)(const void *keyp, size_t keysize);
-typedef uint (*utp_hash_equal_t)(const void *key_a, const void *key_b, size_t keysize);
-
-// In memory the HashTable is laid out as follows:
-//  ---------------------------- low
-//  | hash table data members  |
-//  ----------------------------  _
-//  |  indices                 |  ^
-//  |  .                       |  |  utp_link_t indices into the key-values.
-//  |  .                       |  .
-//  ----------------------------  -  <----- bep
-//  |  keys and values         |     each key-value pair has size total_size
-//  |  .                       |
-//  |  .                       |
-//  ---------------------------- high
-//
-// The code depends on the ability of the compiler to pad the length
-// of the hash table data members structure to
-// a length divisible by 32-bits with no remainder.
-//
-// Since the number of hash buckets (indices) should be odd, the code
-// asserts this and adds one to the hash bucket count to ensure that the
-// following key-value pairs array starts on a 32-bit boundary.
-//
-// The key-value pairs array should start on a 32-bit boundary, otherwise
-// processors like the ARM will silently mangle 32-bit data in these structures
-// (e.g., turning 0xABCD into 0XCDAB when moving a value from memory to register
-// when the memory address is 16 bits offset from a 32-bit boundary),
-// also, the value will be stored at an address two bytes lower than the address
-// value would ordinarily indicate.
-//
-// The key-value pair is of type T. The first field in T must
-// be the key, i.e., the first K bytes of T contains the key.
-// total_size = sizeof(T) and thus sizeof(T) >= sizeof(K)
-//
-// N is the number of buckets.
-//
-struct utp_hash_t {
-	utp_link_t N;
-	byte K;
-	byte E;
-	size_t count;
-	utp_hash_compute_t hash_compute;
-	utp_hash_equal_t hash_equal;
-	utp_link_t allocated;
-	utp_link_t used;
-	utp_link_t free;
-	utp_link_t inits[1]; // dynamic
-};
-
-#ifdef _MSC_VER
-#pragma warning (default: 4200)
-#endif
-
-struct utp_hash_iterator_t {
-	utp_link_t bucket;
-	utp_link_t elem;
-
-	utp_hash_iterator_t() : bucket(0xffffffff), elem(0xffffffff) {}
-};
 
 uint utp_hash_mem(const void *keyp, size_t keysize);
-uint utp_hash_comp(const void *key_a, const void *key_b, size_t keysize);
-
-utp_hash_t *utp_hash_create(int N, int key_size, int total_size, int initial, utp_hash_compute_t hashfun = utp_hash_mem, utp_hash_equal_t eqfun = NULL);
-void *utp_hash_lookup(utp_hash_t *hash, const void *key);
-void *utp_hash_add(utp_hash_t **hashp, const void *key);
-void *utp_hash_del(utp_hash_t *hash, const void *key);
-
-void *utp_hash_iterate(utp_hash_t *hash, utp_hash_iterator_t *iter);
-void utp_hash_free_mem(utp_hash_t *hash);
-
-/*
-	This HashTable requires that T have at least sizeof(K)+sizeof(utp_link_t) bytes.
-	Usually done like this:
-
-	struct K {
-		int whatever;
-	};
-
-	struct T {
-		K wtf;
-		utp_link_t link; // also wtf
-	};
-*/
-
-template<typename K, typename T> class utpHashTable {
-	utp_hash_t *hash;
-public:
-	static uint compare(const void *k1, const void *k2, size_t /*ks*/) {
-		return *((K*)k1) == *((K*)k2);
-	}
-	static uint32 compute_hash(const void *k, size_t /*ks*/) {
-		return ((K*)k)->compute_hash();
-	}
-	void Init() { hash = NULL; }
-	bool Allocated() { return (hash != NULL); }
-	void Free() { utp_hash_free_mem(hash); hash = NULL; }
-	void Create(int N, int initial) { hash = utp_hash_create(N, sizeof(K), sizeof(T), initial, &compute_hash, &compare); }
-	T *Lookup(const K &key) { return (T*)utp_hash_lookup(hash, &key); }
-	T *Add(const K &key) { return (T*)utp_hash_add(&hash, &key); }
-	T *Delete(const K &key) { return (T*)utp_hash_del(hash, &key); }
-	T *Iterate(utp_hash_iterator_t &iterator) { return (T*)utp_hash_iterate(hash, &iterator); }
-	size_t GetCount() { return hash->count; }
-};
 
 #endif //__UTP_HASH_H__