mirror of
https://github.com/simdjson/simdjson
synced 2026-06-08 17:27:07 +00:00
Daniel Lemire
100 lines
2.7 KiB
C++
100 lines
2.7 KiB
C++
#ifdef __FILC__
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
int main() {
|
|
printf("This test is not relevant for FILC.\n");
|
|
return EXIT_SUCCESS;
|
|
}
|
|
#else // This test is not relevant for FILC
|
|
|
|
#ifdef _WIN32
|
|
#include <windows.h>
|
|
#include <sysinfoapi.h>
|
|
#else
|
|
#include <unistd.h>
|
|
#endif
|
|
#include "simdjson.h"
|
|
#include <cstdio>
|
|
#include <vector>
|
|
// Returns the default size of the page in bytes on this system.
|
|
long page_size() {
|
|
#ifdef _WIN32
|
|
SYSTEM_INFO sysInfo;
|
|
GetSystemInfo(&sysInfo);
|
|
long pagesize = sysInfo.dwPageSize;
|
|
#else
|
|
long pagesize = sysconf(_SC_PAGESIZE);
|
|
#endif
|
|
return pagesize;
|
|
}
|
|
|
|
// Returns true if the buffer + len + simdjson::SIMDJSON_PADDING crosses the
|
|
// page boundary. Assumes len != 0.
|
|
bool need_allocation(const char *buf, size_t len) {
|
|
return ((reinterpret_cast<uintptr_t>(buf + len - 1) % page_size())
|
|
+ simdjson::SIMDJSON_PADDING >= static_cast<uintptr_t>(page_size()));
|
|
}
|
|
|
|
bool check_need_allocation() {
|
|
long ps = page_size();
|
|
std::vector<std::tuple<uintptr_t,size_t,bool>> test_cases = {
|
|
{2*ps, 5, false}, {2*ps, ps, true}, {2*ps, 100, false},
|
|
};
|
|
for(auto t : test_cases) {
|
|
uintptr_t buf = std::get<0>(t);
|
|
size_t len = std::get<1>(t);
|
|
bool expected = std::get<2>(t);
|
|
if(need_allocation(reinterpret_cast<const char *>(buf), len) != expected) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
simdjson::padded_string_view
|
|
get_padded_string_view(const char *buf, size_t len,
|
|
simdjson::padded_string &jsonbuffer) {
|
|
if (need_allocation(buf, len)) { // unlikely case
|
|
jsonbuffer = simdjson::padded_string(buf, len);
|
|
return jsonbuffer;
|
|
} else { // no reallcation needed (very likely)
|
|
return simdjson::padded_string_view(buf, len,
|
|
len + simdjson::SIMDJSON_PADDING);
|
|
}
|
|
}
|
|
|
|
int main() {
|
|
printf("page_size: %ld\n", page_size());
|
|
if(!check_need_allocation()) {
|
|
printf("Bug in the need_allocation function.\n");
|
|
return EXIT_FAILURE;
|
|
}
|
|
const char *jsonpoiner = R"(
|
|
{
|
|
"key": "value"
|
|
}
|
|
)";
|
|
size_t len = strlen(jsonpoiner);
|
|
simdjson::padded_string jsonbuffer; // only allocate if needed
|
|
simdjson::ondemand::parser parser;
|
|
simdjson::ondemand::document doc;
|
|
simdjson::error_code error =
|
|
parser.iterate(get_padded_string_view(jsonpoiner, len, jsonbuffer))
|
|
.get(doc);
|
|
if (error) {
|
|
printf("error: %s\n", simdjson::error_message(error));
|
|
return EXIT_FAILURE;
|
|
}
|
|
std::string_view value;
|
|
error = doc["key"].get_string().get(value);
|
|
if (error) {
|
|
return EXIT_FAILURE;
|
|
}
|
|
printf("Value: \"%.*s\"\n", (int)value.size(), value.data());
|
|
if (value != "value") {
|
|
return EXIT_FAILURE;
|
|
}
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
#endif // This test is not relevant for FILC
|