openmp parallelized encoding testing

Makefile

@@ -1,2 +1,4 @@
+test_encode_decode: test_encode_decode.c creole.c creole.h
+	$(CC) test_encode_decode.c -Wall -pedantic -std=c89 -O2 -fopenmp -o test_encode_decode
 test_creole: test_creole.c creole.c creole.h greatest.h
 	$(CC) -g test_creole.c -Wall -pedantic -std=c89 -o test_creole

creole.h

@@ -2,6 +2,7 @@
 #define CREOLE_H
 
 #include <limits.h>
+#include <stddef.h>
 
 #ifndef CREOLE_WORD
 # define CREOLE_WORD unsigned int

test_creole.c

@@ -37,78 +37,7 @@ SUITE(reader) {
 	RUN_TEST1(reader_test_basic, &r);
 }
 
-/**************************************************************************
+#if 0
- * Pseudo UTF-8 sequences
- *************************************************************************/
-
-TEST no_values(void) {
-	struct creole_reader r;
-	struct word w;
-	r.p = NULL;
-	r.left = 0;
-	ASSERT_EQ(decode_seq(&r, &w), 0);
-
-	PASS();
-}
-
-struct seq {
-	creole_word max;
-	unsigned encode_to;
-	unsigned high_bits;
-
-	unsigned char minbuf[7];
-	unsigned char maxbuf[7];
-};
-
-void bprint(unsigned char c) {
-	int i;
-
-	for (i = 0; i < 8; i++) {
-		printf("%u", (c >> (7 - i)) & 1);
-	}
-}
-
-void bprintb(unsigned char *b, int len) {
-	while (len-- > 0) {
-		bprint(*b++);
-		printf(" ");
-	}
-}
-
-TEST encode_byte_seq(struct seq *s) {
-	creole_word i = 0;
-	int j;
-	unsigned char buf[7];
-
-	for (;;) {
-		printf("0x%X ", i);
-		bprintb(s->minbuf, s->encode_to);
-		printf("\n");
-
-		ASSERT_EQ(creole_encode(i, s->encode_to, s->high_bits,
-		                        buf), 1);
-		ASSERT_MEM_EQ(s->minbuf, buf, s->encode_to);
-
-		if (i == s->max)
-			break;
-		i++;
-
-		for (j = s->encode_to - 1; j > 0; j--) {
-			if (s->minbuf[j] == 0xBF) {
-				s->minbuf[j] = 0x80;
-			} else {
-				s->minbuf[j]++;
-				break;
-			}
-		}
-
-		if (j == 0)
-			s->minbuf[0]++;
-	}
-	ASSERT_MEM_EQ(s->maxbuf, s->minbuf, s->encode_to);
-	PASS();
-}
-
 TEST encode_decode_byte_seq(struct seq *s) {
 	unsigned char buf[7];
 	struct creole_reader r = {0};
@@ -132,75 +61,44 @@ TEST encode_decode_byte_seq(struct seq *s) {
 
 	PASS();
 }
-
 SUITE(pseudo_utf8_encode_all) {
 	struct seq s;
 
-	RUN_TEST(no_values);
-
 	s.max = 0x7F;
 	s.encode_to = 1;
 	s.high_bits = 0;
-	s.minbuf[0] = 0x00;
+	RUN_TEST1(encode_decode_byte_seq, &s);
-	s.maxbuf[0] = 0x7F;
-
-	RUN_TEST1(encode_byte_seq, &s);
 
 	for (s.high_bits = 0; s.high_bits < 16; s.high_bits++) {
-		memset(s.maxbuf, 0xBF, sizeof(s.maxbuf));
-
-		memset(s.minbuf, 0x80, sizeof(s.minbuf));
 		s.max = 0x7F;
 		s.encode_to = 2;
-		s.maxbuf[0] = s.minbuf[0] = 0xC0 | (s.high_bits << 1);
+		RUN_TEST1(encode_decode_byte_seq, &s);
-		s.maxbuf[0] = 0xC1 | (s.high_bits << 1);
-		s.minbuf[1] = 0x80;
-		RUN_TEST1(encode_byte_seq, &s);
 
-		memset(s.minbuf, 0x80, sizeof(s.minbuf));
 		s.max = 0xFFF;
 		s.encode_to = 3;
-		s.minbuf[0] = 0xE0 | s.high_bits;
+		RUN_TEST1(encode_decode_byte_seq, &s);
-		s.maxbuf[0] = 0xE0 | s.high_bits;
-		s.minbuf[1] = 0x80;
-		RUN_TEST1(encode_byte_seq, &s);
 
-		memset(s.minbuf, 0x80, sizeof(s.minbuf));
 		s.max = 0x1FFFF;
 		s.encode_to = 4;
-		s.maxbuf[0] = s.minbuf[0] = 0xF0 | (s.high_bits >> 1);
+		RUN_TEST1(encode_decode_byte_seq, &s);
-		s.minbuf[1] = 0x80 | ((s.high_bits & 0x1) << 5);
-		s.maxbuf[1] = 0x9F | ((s.high_bits & 0x1) << 5);
-		RUN_TEST1(encode_byte_seq, &s);
 
-		memset(s.minbuf, 0x80, sizeof(s.minbuf));
 		s.max = 0x3FFFFF;
 		s.encode_to = 5;
-		s.maxbuf[0] = s.minbuf[0] = 0xF8 | (s.high_bits >> 2);
+		RUN_TEST1(encode_decode_byte_seq, &s);
-		s.minbuf[1] = 0x80 | ((s.high_bits & 0x3) << 4);
-		s.maxbuf[1] = 0x8F | ((s.high_bits & 0x3) << 4);
 
-		memset(s.minbuf, 0x80, sizeof(s.minbuf));
 		s.max = 0x7FFFFFF;
 		s.encode_to = 6;
-		s.maxbuf[0] = s.minbuf[0] = 0xFC | (s.high_bits >> 3);
+		RUN_TEST1(encode_decode_byte_seq, &s);
-		s.minbuf[1] = 0x80 | ((s.high_bits & 0x7) << 3);
-		s.maxbuf[1] = 0x87 | ((s.high_bits & 0x7) << 3);
-		RUN_TEST1(encode_byte_seq, &s);
 
-		memset(s.minbuf, 0x80, sizeof(s.minbuf));
 		s.max = 0xFFFFFFFF;
 		s.encode_to = 7;
-		s.maxbuf[0] = s.minbuf[0] = 0xFE;
+		RUN_TEST1(encode_decode_byte_seq, &s);
-		s.minbuf[1] = 0x80 | (s.high_bits << 2);
-		s.maxbuf[1] = 0x83 | (s.high_bits << 2);
-		RUN_TEST1(encode_byte_seq, &s);
 	}
 }
+#endif
 
 int main(int argc, char *argv[]) {
 	GREATEST_MAIN_BEGIN();
 	RUN_SUITE(reader);
-	RUN_SUITE(pseudo_utf8_encode_all);
 	GREATEST_MAIN_END();
 }

test_encode_decode.c

@@ -0,0 +1,180 @@
+#include "creole.c"
+#include <string.h>
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+struct seq {
+	creole_word max;
+	unsigned encode_to;
+	unsigned high_bits;
+
+	unsigned char minbuf[7];
+	unsigned char maxbuf[7];
+};
+
+void bprint(unsigned char c) {
+	int i;
+
+	for (i = 0; i < 8; i++) {
+		printf("%u", (c >> (7 - i)) & 1);
+	}
+}
+
+void bprintb(unsigned char *b, int len) {
+	while (len-- > 0) {
+		bprint(*b++);
+		printf(" ");
+	}
+}
+
+static void encode_byte_seq(struct seq *s) {
+	creole_word i = 0;
+	int j;
+	unsigned char buf[7];
+
+	for (;;) {
+
+		assert(creole_encode(i, s->encode_to, s->high_bits,
+		                        buf) == 1);
+		if (memcmp(s->minbuf, buf, s->encode_to) != 0) {
+			printf("0x%X ", i);
+			bprintb(s->minbuf, s->encode_to);
+			printf("|");
+			bprintb(buf, s->encode_to);
+			printf("\n");
+			abort();
+		}
+
+		if (i == s->max)
+			break;
+		i++;
+
+		for (j = s->encode_to - 1; j > 0; j--) {
+			if (s->minbuf[j] == 0xBF) {
+				s->minbuf[j] = 0x80;
+			} else {
+				s->minbuf[j]++;
+				break;
+			}
+		}
+
+		if (j == 0)
+			s->minbuf[0]++;
+	}
+	assert(memcmp(s->maxbuf, s->minbuf, s->encode_to) == 0);
+}
+
+static void encode_1(void) {
+	struct seq s;
+
+	s.max = 0x7F;
+	s.encode_to = 1;
+	s.high_bits = 0;
+	s.minbuf[0] = 0x00;
+	s.maxbuf[0] = 0x7F;
+
+	encode_byte_seq(&s);
+}
+
+static void encode_2(unsigned high_bits) {
+	struct seq s;
+	s.high_bits = high_bits;
+
+	memset(s.maxbuf, 0xBF, sizeof(s.maxbuf));
+	memset(s.minbuf, 0x80, sizeof(s.minbuf));
+	s.max = 0x7F;
+	s.encode_to = 2;
+	s.maxbuf[0] = s.minbuf[0] = 0xC0 | (high_bits << 1);
+	s.maxbuf[0] = 0xC1 | (high_bits << 1);
+	s.minbuf[1] = 0x80;
+	encode_byte_seq(&s);
+}
+
+static void encode_3(unsigned high_bits) {
+	struct seq s;
+	s.high_bits = high_bits;
+
+	memset(s.maxbuf, 0xBF, sizeof(s.maxbuf));
+	memset(s.minbuf, 0x80, sizeof(s.minbuf));
+	s.max = 0xFFF;
+	s.encode_to = 3;
+	s.minbuf[0] = 0xE0 | high_bits;
+	s.maxbuf[0] = 0xE0 | high_bits;
+	s.minbuf[1] = 0x80;
+	encode_byte_seq(&s);
+}
+
+static void encode_4(unsigned high_bits) {
+	struct seq s;
+	s.high_bits = high_bits;
+
+	memset(s.maxbuf, 0xBF, sizeof(s.maxbuf));
+	memset(s.minbuf, 0x80, sizeof(s.minbuf));
+	s.max = 0x1FFFF;
+	s.encode_to = 4;
+	s.maxbuf[0] = s.minbuf[0] = 0xF0 | (high_bits >> 1);
+	s.minbuf[1] = 0x80 | ((high_bits & 0x1) << 5);
+	s.maxbuf[1] = 0x9F | ((high_bits & 0x1) << 5);
+	encode_byte_seq(&s);
+}
+
+static void encode_5(unsigned high_bits) {
+	struct seq s;
+	s.high_bits = high_bits;
+
+	memset(s.maxbuf, 0xBF, sizeof(s.maxbuf));
+	memset(s.minbuf, 0x80, sizeof(s.minbuf));
+	s.max = 0x3FFFFF;
+	s.encode_to = 5;
+	s.maxbuf[0] = s.minbuf[0] = 0xF8 | (high_bits >> 2);
+	s.minbuf[1] = 0x80 | ((high_bits & 0x3) << 4);
+	s.maxbuf[1] = 0x8F | ((high_bits & 0x3) << 4);
+	encode_byte_seq(&s);
+}
+
+static void encode_6(unsigned high_bits) {
+	struct seq s;
+	s.high_bits = high_bits;
+
+	memset(s.maxbuf, 0xBF, sizeof(s.maxbuf));
+	memset(s.minbuf, 0x80, sizeof(s.minbuf));
+	s.max = 0x7FFFFFF;
+	s.encode_to = 6;
+	s.maxbuf[0] = s.minbuf[0] = 0xFC | (high_bits >> 3);
+	s.minbuf[1] = 0x80 | ((high_bits & 0x7) << 3);
+	s.maxbuf[1] = 0x87 | ((high_bits & 0x7) << 3);
+	encode_byte_seq(&s);
+}
+
+static void encode_7(unsigned high_bits) {
+	struct seq s;
+	s.high_bits = high_bits;
+
+	memset(s.maxbuf, 0xBF, sizeof(s.maxbuf));
+	memset(s.minbuf, 0x80, sizeof(s.minbuf));
+	s.max = 0xFFFFFFFF;
+	s.encode_to = 7;
+	s.maxbuf[0] = s.minbuf[0] = 0xFE;
+	s.minbuf[1] = 0x80 | (high_bits << 2);
+	s.maxbuf[1] = 0x83 | (high_bits << 2);
+	encode_byte_seq(&s);
+}
+
+static void test_encode(void) {
+	void (*tests[6])(unsigned) = {encode_2, encode_3, encode_4, encode_5, encode_6, encode_7};
+	unsigned high_bits;
+	unsigned test;
+	encode_1();
+
+# pragma omp parallel for collapse(2) num_threads(8)
+	for (high_bits = 0; high_bits < 16; high_bits++) {
+		for (test = 0; test < 6; test++)
+			tests[test](high_bits);
+	}
+}
+
+int main(void) {
+	test_encode();
+	return 0;
+}