Merge pull request #642 from arrbee/mem-pools

Memory pools and khash hashtables

4 files changed, 199 insertions, 11 deletions

diff --git a/tests-clar/attr/file.c b/tests-clar/attr/file.c
index 7fede5025..4e1010230 100644
--- a/tests-clar/attr/file.c
+++ b/tests-clar/attr/file.c
@@ -11,7 +11,7 @@ void test_attr_file__simple_read(void)
 	git_attr_assignment *assign;
 	git_attr_rule *rule;
 
-	cl_git_pass(git_attr_file__new(&file));
+	cl_git_pass(git_attr_file__new(&file, NULL));
 	cl_git_pass(git_attr_file__from_file(NULL, cl_fixture("attr/attr0"), file));
 	cl_assert_equal_s(cl_fixture("attr/attr0"), file->path);
 	cl_assert(file->rules.length == 1);
@@ -27,7 +27,6 @@ void test_attr_file__simple_read(void)
 	cl_assert(assign != NULL);
 	cl_assert_equal_s("binary", assign->name);
 	cl_assert(GIT_ATTR_TRUE(assign->value));
-	cl_assert(!assign->is_allocated);
 
 	git_attr_file__free(file);
 }
@@ -38,7 +37,7 @@ void test_attr_file__match_variants(void)
 	git_attr_rule *rule;
 	git_attr_assignment *assign;
 
-	cl_git_pass(git_attr_file__new(&file));
+	cl_git_pass(git_attr_file__new(&file, NULL));
 	cl_git_pass(git_attr_file__from_file(NULL, cl_fixture("attr/attr1"), file));
 	cl_assert_equal_s(cl_fixture("attr/attr1"), file->path);
 	cl_assert(file->rules.length == 10);
@@ -56,7 +55,6 @@ void test_attr_file__match_variants(void)
 	cl_assert_equal_s("attr0", assign->name);
 	cl_assert(assign->name_hash == git_attr_file__name_hash(assign->name));
 	cl_assert(GIT_ATTR_TRUE(assign->value));
-	cl_assert(!assign->is_allocated);
 
 	rule = get_rule(1);
 	cl_assert_equal_s("pat1", rule->match.pattern);
@@ -125,7 +123,7 @@ void test_attr_file__assign_variants(void)
 	git_attr_rule *rule;
 	git_attr_assignment *assign;
 
-	cl_git_pass(git_attr_file__new(&file));
+	cl_git_pass(git_attr_file__new(&file, NULL));
 	cl_git_pass(git_attr_file__from_file(NULL, cl_fixture("attr/attr2"), file));
 	cl_assert_equal_s(cl_fixture("attr/attr2"), file->path);
 	cl_assert(file->rules.length == 11);
@@ -191,7 +189,7 @@ void test_attr_file__check_attr_examples(void)
 	git_attr_rule *rule;
 	git_attr_assignment *assign;
 
-	cl_git_pass(git_attr_file__new(&file));
+	cl_git_pass(git_attr_file__new(&file, NULL));
 	cl_git_pass(git_attr_file__from_file(NULL, cl_fixture("attr/attr3"), file));
 	cl_assert_equal_s(cl_fixture("attr/attr3"), file->path);
 	cl_assert(file->rules.length == 3);
diff --git a/tests-clar/attr/lookup.c b/tests-clar/attr/lookup.c
index 4ce80e947..accd617e6 100644
--- a/tests-clar/attr/lookup.c
+++ b/tests-clar/attr/lookup.c
@@ -9,7 +9,7 @@ void test_attr_lookup__simple(void)
 	git_attr_path path;
 	const char *value = NULL;
 
-	cl_git_pass(git_attr_file__new(&file));
+	cl_git_pass(git_attr_file__new(&file, NULL));
 	cl_git_pass(git_attr_file__from_file(NULL, cl_fixture("attr/attr0"), file));
 	cl_assert_equal_s(cl_fixture("attr/attr0"), file->path);
 	cl_assert(file->rules.length == 1);
@@ -127,7 +127,7 @@ void test_attr_lookup__match_variants(void)
 		{ NULL, NULL, 0, NULL }
 	};
 
-	cl_git_pass(git_attr_file__new(&file));
+	cl_git_pass(git_attr_file__new(&file, NULL));
 	cl_git_pass(git_attr_file__from_file(NULL, cl_fixture("attr/attr1"), file));
 	cl_assert_equal_s(cl_fixture("attr/attr1"), file->path);
 	cl_assert(file->rules.length == 10);
@@ -144,6 +144,7 @@ void test_attr_lookup__match_variants(void)
 void test_attr_lookup__assign_variants(void)
 {
 	git_attr_file *file;
+
 	struct attr_expected cases[] = {
 		/* pat0 -> simple assign */
 		{ "pat0", "simple", EXPECT_TRUE, NULL },
@@ -187,7 +188,7 @@ void test_attr_lookup__assign_variants(void)
 		{ NULL, NULL, 0, NULL }
 	};
 
-	cl_git_pass(git_attr_file__new(&file));
+	cl_git_pass(git_attr_file__new(&file, NULL));
 	cl_git_pass(git_attr_file__from_file(NULL, cl_fixture("attr/attr2"), file));
 	cl_assert(file->rules.length == 11);
 
@@ -199,6 +200,7 @@ void test_attr_lookup__assign_variants(void)
 void test_attr_lookup__check_attr_examples(void)
 {
 	git_attr_file *file;
+
 	struct attr_expected cases[] = {
 		{ "foo.java", "diff", EXPECT_STRING, "java" },
 		{ "foo.java", "crlf", EXPECT_FALSE, NULL },
@@ -222,7 +224,7 @@ void test_attr_lookup__check_attr_examples(void)
 		{ NULL, NULL, 0, NULL }
 	};
 
-	cl_git_pass(git_attr_file__new(&file));
+	cl_git_pass(git_attr_file__new(&file, NULL));
 	cl_git_pass(git_attr_file__from_file(NULL, cl_fixture("attr/attr3"), file));
 	cl_assert(file->rules.length == 3);
 
@@ -234,6 +236,7 @@ void test_attr_lookup__check_attr_examples(void)
 void test_attr_lookup__from_buffer(void)
 {
 	git_attr_file *file;
+
 	struct attr_expected cases[] = {
 		{ "abc", "foo", EXPECT_TRUE, NULL },
 		{ "abc", "bar", EXPECT_TRUE, NULL },
@@ -247,7 +250,7 @@ void test_attr_lookup__from_buffer(void)
 		{ NULL, NULL, 0, NULL }
 	};
 
-	cl_git_pass(git_attr_file__new(&file));
+	cl_git_pass(git_attr_file__new(&file, NULL));
 	cl_git_pass(git_attr_file__from_buffer(NULL, "a* foo\nabc bar\n* baz", file));
 	cl_assert(file->rules.length == 3);
 
diff --git a/tests-clar/core/pool.c b/tests-clar/core/pool.c
new file mode 100644
index 000000000..5ed97366f
--- /dev/null
+++ b/tests-clar/core/pool.c
@@ -0,0 +1,85 @@
+#include "clar_libgit2.h"
+#include "pool.h"
+#include "git2/oid.h"
+
+void test_core_pool__0(void)
+{
+	int i;
+	git_pool p;
+	void *ptr;
+
+	cl_git_pass(git_pool_init(&p, 1, 4000));
+
+	for (i = 1; i < 10000; i *= 2) {
+		ptr = git_pool_malloc(&p, i);
+		cl_assert(ptr != NULL);
+		cl_assert(git_pool__ptr_in_pool(&p, ptr));
+		cl_assert(!git_pool__ptr_in_pool(&p, &i));
+	}
+
+	/* 1+2+4+8+16+32+64+128+256+512+1024 -> original block */
+	/* 2048 -> 1 block */
+	/* 4096 -> 1 block */
+	/* 8192 -> 1 block */
+
+	cl_assert(git_pool__open_pages(&p) + git_pool__full_pages(&p) == 4);
+
+	git_pool_clear(&p);
+}
+
+void test_core_pool__1(void)
+{
+	int i;
+	git_pool p;
+
+	cl_git_pass(git_pool_init(&p, 1, 4000));
+
+	for (i = 2010; i > 0; i--)
+		cl_assert(git_pool_malloc(&p, i) != NULL);
+
+	/* with fixed page size, allocation must end up with these values */
+	cl_assert(git_pool__open_pages(&p) == 1);
+	cl_assert(git_pool__full_pages(&p) == 505);
+
+	git_pool_clear(&p);
+
+	cl_git_pass(git_pool_init(&p, 1, 4100));
+
+	for (i = 2010; i > 0; i--)
+		cl_assert(git_pool_malloc(&p, i) != NULL);
+
+	/* with fixed page size, allocation must end up with these values */
+	cl_assert(git_pool__open_pages(&p) == 1);
+	cl_assert(git_pool__full_pages(&p) == 492);
+
+	git_pool_clear(&p);
+}
+
+static char to_hex[] = "0123456789abcdef";
+
+void test_core_pool__2(void)
+{
+	git_pool p;
+	char oid_hex[GIT_OID_HEXSZ];
+	git_oid *oid;
+	int i, j;
+
+	memset(oid_hex, '0', sizeof(oid_hex));
+
+	cl_git_pass(git_pool_init(&p, sizeof(git_oid), 100));
+
+	for (i = 1000; i < 10000; i++) {
+		oid = git_pool_malloc(&p, 1);
+		cl_assert(oid != NULL);
+
+		for (j = 0; j < 8; j++)
+			oid_hex[j] = to_hex[(i >> (4 * j)) & 0x0f];
+		cl_git_pass(git_oid_fromstr(oid, oid_hex));
+	}
+
+	/* with fixed page size, allocation must end up with these values */
+	cl_assert(git_pool__open_pages(&p) == 0);
+	cl_assert(git_pool__full_pages(&p) == 90);
+
+	git_pool_clear(&p);
+}
diff --git a/tests-clar/core/strmap.c b/tests-clar/core/strmap.c
new file mode 100644
index 000000000..f34a4f89f
--- /dev/null
+++ b/tests-clar/core/strmap.c
@@ -0,0 +1,102 @@
+#include "clar_libgit2.h"
+#include "strmap.h"
+
+GIT__USE_STRMAP;
+
+void test_core_strmap__0(void)
+{
+	git_strmap *table = git_strmap_alloc();
+	cl_assert(table != NULL);
+	cl_assert(git_strmap_num_entries(table) == 0);
+	git_strmap_free(table);
+}
+
+static void insert_strings(git_strmap *table, int count)
+{
+	int i, j, over, err;
+	char *str;
+
+	for (i = 0; i < count; ++i) {
+		str = malloc(10);
+		for (j = 0; j < 10; ++j)
+			str[j] = 'a' + (i % 26);
+		str[9] = '\0';
+
+		/* if > 26, then encode larger value in first letters */
+		for (j = 0, over = i / 26; over > 0; j++, over = over / 26)
+			str[j] = 'A' + (over % 26);
+
+		git_strmap_insert(table, str, str, err);
+		cl_assert(err >= 0);
+	}
+
+	cl_assert((int)git_strmap_num_entries(table) == count);
+}
+
+void test_core_strmap__1(void)
+{
+	int i;
+	char *str;
+	git_strmap *table = git_strmap_alloc();
+	cl_assert(table != NULL);
+
+	insert_strings(table, 20);
+
+	cl_assert(git_strmap_exists(table, "aaaaaaaaa"));
+	cl_assert(git_strmap_exists(table, "ggggggggg"));
+	cl_assert(!git_strmap_exists(table, "aaaaaaaab"));
+	cl_assert(!git_strmap_exists(table, "abcdefghi"));
+
+	i = 0;
+	git_strmap_foreach_value(table, str, { i++; free(str); });
+	cl_assert(i == 20);
+
+	git_strmap_free(table);
+}
+
+void test_core_strmap__2(void)
+{
+	khiter_t pos;
+	int i;
+	char *str;
+	git_strmap *table = git_strmap_alloc();
+	cl_assert(table != NULL);
+
+	insert_strings(table, 20);
+
+	cl_assert(git_strmap_exists(table, "aaaaaaaaa"));
+	cl_assert(git_strmap_exists(table, "ggggggggg"));
+	cl_assert(!git_strmap_exists(table, "aaaaaaaab"));
+	cl_assert(!git_strmap_exists(table, "abcdefghi"));
+
+	cl_assert(git_strmap_exists(table, "bbbbbbbbb"));
+	pos = git_strmap_lookup_index(table, "bbbbbbbbb");
+	cl_assert(git_strmap_valid_index(table, pos));
+	cl_assert_equal_s(git_strmap_value_at(table, pos), "bbbbbbbbb");
+	free(git_strmap_value_at(table, pos));
+	git_strmap_delete_at(table, pos);
+
+	cl_assert(!git_strmap_exists(table, "bbbbbbbbb"));
+
+	i = 0;
+	git_strmap_foreach_value(table, str, { i++; free(str); });
+	cl_assert(i == 19);
+
+	git_strmap_free(table);
+}
+
+void test_core_strmap__3(void)
+{
+	int i;
+	char *str;
+	git_strmap *table = git_strmap_alloc();
+	cl_assert(table != NULL);
+
+	insert_strings(table, 10000);
+
+	i = 0;
+	git_strmap_foreach_value(table, str, { i++; free(str); });
+	cl_assert(i == 10000);
+
+	git_strmap_free(table);
+}