Debian Codegraph @

LspCpp/third_party/rapidjson/test/unittest/simdtest.cpp

raw
1 // Tencent is pleased to support the open source community by making RapidJSON available.
2 //
3 // Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
4 //
5 // Licensed under the MIT License (the "License"); you may not use this file except
6 // in compliance with the License. You may obtain a copy of the License at
7 //
8 // http://opensource.org/licenses/MIT
9 //
10 // Unless required by applicable law or agreed to in writing, software distributed
11 // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
12 // CONDITIONS OF ANY KIND, either express or implied. See the License for the
13 // specific language governing permissions and limitations under the License.
14
15 // Since Travis CI installs old Valgrind 3.7.0, which fails with some SSE4.2
16 // The unit tests prefix with SIMD should be skipped by Valgrind test
17
18 // __SSE2__ and __SSE4_2__ are recognized by gcc, clang, and the Intel compiler.
19 // We use -march=native with gmake to enable -msse2 and -msse4.2, if supported.
20 #if defined(__SSE4_2__)
21 # define RAPIDJSON_SSE42
22 #elif defined(__SSE2__)
23 # define RAPIDJSON_SSE2
24 #elif defined(__ARM_NEON)
25 # define RAPIDJSON_NEON
26 #endif
27
28 #define RAPIDJSON_NAMESPACE rapidjson_simd
29
30 #include "unittest.h"
31
32 #include "rapidjson/reader.h"
33 #include "rapidjson/writer.h"
34
35 #ifdef __GNUC__
36 RAPIDJSON_DIAG_PUSH
37 RAPIDJSON_DIAG_OFF(effc++)
38 #endif
39
40 using namespace rapidjson_simd;
41
42 #ifdef RAPIDJSON_SSE2
43 #define SIMD_SUFFIX(name) name##_SSE2
44 #elif defined(RAPIDJSON_SSE42)
45 #define SIMD_SUFFIX(name) name##_SSE42
46 #elif defined(RAPIDJSON_NEON)
47 #define SIMD_SUFFIX(name) name##_NEON
48 #else
49 #define SIMD_SUFFIX(name) name
50 #endif
51
52 #define SIMD_SIZE_ALIGN(n) ((size_t(n) + 15) & ~size_t(15))
53
54 template <typename StreamType>
55 void TestSkipWhitespace() {
56 for (size_t step = 1; step < 32; step++) {
57 char buffer[SIMD_SIZE_ALIGN(1025)];
58 for (size_t i = 0; i < 1024; i++)
59 buffer[i] = " \t\r\n"[i % 4];
60 for (size_t i = 0; i < 1024; i += step)
61 buffer[i] = 'X';
62 buffer[1024] = '\0';
63
64 StreamType s(buffer);
65 size_t i = 0;
66 for (;;) {
67 SkipWhitespace(s);
68 if (s.Peek() == '\0')
69 break;
70 EXPECT_EQ(i, s.Tell());
71 EXPECT_EQ('X', s.Take());
72 i += step;
73 }
74 }
75 }
76
77 TEST(SIMD, SIMD_SUFFIX(SkipWhitespace)) {
78 TestSkipWhitespace<StringStream>();
79 TestSkipWhitespace<InsituStringStream>();
80 }
81
82 TEST(SIMD, SIMD_SUFFIX(SkipWhitespace_EncodedMemoryStream)) {
83 for (size_t step = 1; step < 32; step++) {
84 char buffer[SIMD_SIZE_ALIGN(1024)];
85 for (size_t i = 0; i < 1024; i++)
86 buffer[i] = " \t\r\n"[i % 4];
87 for (size_t i = 0; i < 1024; i += step)
88 buffer[i] = 'X';
89
90 MemoryStream ms(buffer, 1024);
91 EncodedInputStream<UTF8<>, MemoryStream> s(ms);
92 for (;;) {
93 SkipWhitespace(s);
94 if (s.Peek() == '\0')
95 break;
96 //EXPECT_EQ(i, s.Tell());
97 EXPECT_EQ('X', s.Take());
98 }
99 }
100 }
101
102 struct ScanCopyUnescapedStringHandler : BaseReaderHandler<UTF8<>, ScanCopyUnescapedStringHandler> {
103 bool String(const char* str, size_t length, bool) {
104 memcpy(buffer, str, length + 1);
105 return true;
106 }
107 char buffer[1024 + 5 + 32];
108 };
109
110 template <unsigned parseFlags, typename StreamType>
111 void TestScanCopyUnescapedString() {
112 char buffer[SIMD_SIZE_ALIGN(1024u + 5 + 32)];
113 char backup[SIMD_SIZE_ALIGN(1024u + 5 + 32)];
114
115 // Test "ABCDABCD...\\"
116 for (size_t offset = 0; offset < 32; offset++) {
117 for (size_t step = 0; step < 1024; step++) {
118 char* json = buffer + offset;
119 char *p = json;
120 *p++ = '\"';
121 for (size_t i = 0; i < step; i++)
122 *p++ = "ABCD"[i % 4];
123 *p++ = '\\';
124 *p++ = '\\';
125 *p++ = '\"';
126 *p++ = '\0';
127 strcpy(backup, json); // insitu parsing will overwrite buffer, so need to backup first
128
129 StreamType s(json);
130 Reader reader;
131 ScanCopyUnescapedStringHandler h;
132 reader.Parse<parseFlags>(s, h);
133 EXPECT_TRUE(memcmp(h.buffer, backup + 1, step) == 0);
134 EXPECT_EQ('\\', h.buffer[step]); // escaped
135 EXPECT_EQ('\0', h.buffer[step + 1]);
136 }
137 }
138
139 // Test "\\ABCDABCD..."
140 for (size_t offset = 0; offset < 32; offset++) {
141 for (size_t step = 0; step < 1024; step++) {
142 char* json = buffer + offset;
143 char *p = json;
144 *p++ = '\"';
145 *p++ = '\\';
146 *p++ = '\\';
147 for (size_t i = 0; i < step; i++)
148 *p++ = "ABCD"[i % 4];
149 *p++ = '\"';
150 *p++ = '\0';
151 strcpy(backup, json); // insitu parsing will overwrite buffer, so need to backup first
152
153 StreamType s(json);
154 Reader reader;
155 ScanCopyUnescapedStringHandler h;
156 reader.Parse<parseFlags>(s, h);
157 EXPECT_TRUE(memcmp(h.buffer + 1, backup + 3, step) == 0);
158 EXPECT_EQ('\\', h.buffer[0]); // escaped
159 EXPECT_EQ('\0', h.buffer[step + 1]);
160 }
161 }
162 }
163
164 TEST(SIMD, SIMD_SUFFIX(ScanCopyUnescapedString)) {
165 TestScanCopyUnescapedString<kParseDefaultFlags, StringStream>();
166 TestScanCopyUnescapedString<kParseInsituFlag, InsituStringStream>();
167 }
168
169 TEST(SIMD, SIMD_SUFFIX(ScanWriteUnescapedString)) {
170 char buffer[SIMD_SIZE_ALIGN(2048 + 1 + 32)];
171 for (size_t offset = 0; offset < 32; offset++) {
172 for (size_t step = 0; step < 1024; step++) {
173 char* s = buffer + offset;
174 char* p = s;
175 for (size_t i = 0; i < step; i++)
176 *p++ = "ABCD"[i % 4];
177 char escape = "\0\n\\\""[step % 4];
178 *p++ = escape;
179 for (size_t i = 0; i < step; i++)
180 *p++ = "ABCD"[i % 4];
181
182 StringBuffer sb;
183 Writer<StringBuffer> writer(sb);
184 writer.String(s, SizeType(step * 2 + 1));
185 const char* q = sb.GetString();
186 EXPECT_EQ('\"', *q++);
187 for (size_t i = 0; i < step; i++)
188 EXPECT_EQ("ABCD"[i % 4], *q++);
189 if (escape == '\0') {
190 EXPECT_EQ('\\', *q++);
191 EXPECT_EQ('u', *q++);
192 EXPECT_EQ('0', *q++);
193 EXPECT_EQ('0', *q++);
194 EXPECT_EQ('0', *q++);
195 EXPECT_EQ('0', *q++);
196 }
197 else if (escape == '\n') {
198 EXPECT_EQ('\\', *q++);
199 EXPECT_EQ('n', *q++);
200 }
201 else if (escape == '\\') {
202 EXPECT_EQ('\\', *q++);
203 EXPECT_EQ('\\', *q++);
204 }
205 else if (escape == '\"') {
206 EXPECT_EQ('\\', *q++);
207 EXPECT_EQ('\"', *q++);
208 }
209 for (size_t i = 0; i < step; i++)
210 EXPECT_EQ("ABCD"[i % 4], *q++);
211 EXPECT_EQ('\"', *q++);
212 EXPECT_EQ('\0', *q++);
213 }
214 }
215 }
216
217 #ifdef __GNUC__
218 RAPIDJSON_DIAG_POP
219 #endif