peter
/
creole
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

openmp parallelized encoding testing

This commit is contained in:
Peter McGoron 2023-02-07 05:25:30 +00:00
parent e0599bad23
commit df4b2e3b3f
4 changed files with 192 additions and 111 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Makefile
View File

@ -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

1
creole.h
View File

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

120
test_creole.c
View File

@ -37,78 +37,7 @@ SUITE(reader) {
RUN_TEST1(reader_test_basic, &r);
}
/**************************************************************************
* 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();
}
#if 0
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;
s.maxbuf[0] = 0x7F;
RUN_TEST1(encode_byte_seq, &s);
RUN_TEST1(encode_decode_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);
s.maxbuf[0] = 0xC1 | (s.high_bits << 1);
s.minbuf[1] = 0x80;
RUN_TEST1(encode_byte_seq, &s);
RUN_TEST1(encode_decode_byte_seq, &s);
memset(s.minbuf, 0x80, sizeof(s.minbuf));
s.max = 0xFFF;
s.encode_to = 3;
s.minbuf[0] = 0xE0 | s.high_bits;
s.maxbuf[0] = 0xE0 | s.high_bits;
s.minbuf[1] = 0x80;
RUN_TEST1(encode_byte_seq, &s);
RUN_TEST1(encode_decode_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);
s.minbuf[1] = 0x80 | ((s.high_bits & 0x1) << 5);
s.maxbuf[1] = 0x9F | ((s.high_bits & 0x1) << 5);
RUN_TEST1(encode_byte_seq, &s);
RUN_TEST1(encode_decode_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);
s.minbuf[1] = 0x80 | ((s.high_bits & 0x3) << 4);
s.maxbuf[1] = 0x8F | ((s.high_bits & 0x3) << 4);
RUN_TEST1(encode_decode_byte_seq, &s);
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);
s.minbuf[1] = 0x80 | ((s.high_bits & 0x7) << 3);
s.maxbuf[1] = 0x87 | ((s.high_bits & 0x7) << 3);
RUN_TEST1(encode_byte_seq, &s);
RUN_TEST1(encode_decode_byte_seq, &s);
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 | (s.high_bits << 2);
s.maxbuf[1] = 0x83 | (s.high_bits << 2);
RUN_TEST1(encode_byte_seq, &s);
RUN_TEST1(encode_decode_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();
}

180
test_encode_decode.c Normal file
View File

@ -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;
}