github_mirrors/vectorscan
3
0
Fork 1
mirror of https://github.com/VectorCamp/vectorscan.git synced 2025-06-28 16:41:01 +03:00
Code Issues Packages Projects Releases Wiki Activity

fdr/teddy: switch over remaining smart ptrs

Browse Source
This commit is contained in:
Justin Viiret 2016-03-01 16:46:25 +11:00 committed by Matthew Barr
parent aebbd4f169
commit 57cd2331f5
5 changed files with 38 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
src/fdr/fdr_compile.cpp
View File

@ -81,7 +81,7 @@ private:
void dumpMasks(const u8 *defaultMask);
#endif
void setupTab();
aligned_unique_ptr<FDR> setupFDR(pair<u8 *, size_t> link);
aligned_unique_ptr<FDR> setupFDR(pair<aligned_unique_ptr<u8>, size_t> &link);
void createInitialState(FDR *fdr);
public:
@ -90,7 +90,7 @@ public:
: eng(eng_in), tab(eng_in.getTabSizeBytes()), lits(lits_in),
make_small(make_small_in) {}
aligned_unique_ptr<FDR> build(pair<u8 *, size_t> link);
aligned_unique_ptr<FDR> build(pair<aligned_unique_ptr<u8>, size_t> &link);
};
u8 *FDRCompiler::tabIndexToMask(u32 indexInTable) {
@ -141,7 +141,8 @@ void FDRCompiler::createInitialState(FDR *fdr) {
}
}
aligned_unique_ptr<FDR> FDRCompiler::setupFDR(pair<u8 *, size_t> link) {
aligned_unique_ptr<FDR>
FDRCompiler::setupFDR(pair<aligned_unique_ptr<u8>, size_t> &link) {
size_t tabSize = eng.getTabSizeBytes();
auto floodControlTmp = setupFDRFloodControl(lits, eng);
@ -189,8 +190,7 @@ aligned_unique_ptr<FDR> FDRCompiler::setupFDR(pair<u8 *, size_t> link) {
if (link.first) {
fdr->link = verify_u32(ptr - fdr_base);
memcpy(ptr, link.first, link.second);
aligned_free(link.first);
memcpy(ptr, link.first.get(), link.second);
} else {
fdr->link = 0;
}
@ -498,7 +498,8 @@ void FDRCompiler::setupTab() {
#endif
}
aligned_unique_ptr<FDR> FDRCompiler::build(pair<u8 *, size_t> link) {
aligned_unique_ptr<FDR>
FDRCompiler::build(pair<aligned_unique_ptr<u8>, size_t> &link) {
assignStringsToBuckets();
setupTab();
return setupFDR(link);
@ -511,16 +512,15 @@ aligned_unique_ptr<FDR>
fdrBuildTableInternal(const vector<hwlmLiteral> &lits, bool make_small,
const target_t &target, const Grey &grey, u32 hint,
hwlmStreamingControl *stream_control) {
pair<u8 *, size_t> link(nullptr, 0);
pair<aligned_unique_ptr<u8>, size_t> link(nullptr, 0);
if (stream_control) {
link = fdrBuildTableStreaming(lits, stream_control);
link = fdrBuildTableStreaming(lits, *stream_control);
}
DEBUG_PRINTF("cpu has %s\n", target.has_avx2() ? "avx2" : "no-avx2");
if (grey.fdrAllowTeddy) {
aligned_unique_ptr<FDR> fdr
= teddyBuildTableHinted(lits, make_small, hint, target, link);
auto fdr = teddyBuildTableHinted(lits, make_small, hint, target, link);
if (fdr) {
DEBUG_PRINTF("build with teddy succeeded\n");
return fdr;

4
src/fdr/fdr_compile_internal.h
View File

@ -70,9 +70,9 @@ std::pair<aligned_unique_ptr<u8>, size_t>
setupFDRFloodControl(const std::vector<hwlmLiteral> &lits,
const EngineDescription &eng);
std::pair<u8 *, size_t>
std::pair<aligned_unique_ptr<u8>, size_t>
fdrBuildTableStreaming(const std::vector<hwlmLiteral> &lits,
hwlmStreamingControl *stream_control);
hwlmStreamingControl &stream_control);
static constexpr u32 HINT_INVALID = 0xffffffff;

32
src/fdr/fdr_streaming_compile.cpp
View File

@ -306,24 +306,24 @@ size_t maxMaskLen(const vector<hwlmLiteral> &lits) {
return rv;
}
pair<u8 *, size_t>
pair<aligned_unique_ptr<u8>, size_t>
fdrBuildTableStreaming(const vector<hwlmLiteral> &lits,
hwlmStreamingControl *stream_control) {
hwlmStreamingControl &stream_control) {
// refuse to compile if we are forced to have smaller than minimum
// history required for long-literal support, full stop
// otherwise, choose the maximum of the preferred history quantity
// (currently a fairly extravagant 32) or the already used history
// quantity - subject to the limitation of stream_control->history_max
// quantity - subject to the limitation of stream_control.history_max
const size_t MIN_HISTORY_REQUIRED = 32;
if (MIN_HISTORY_REQUIRED > stream_control->history_max) {
if (MIN_HISTORY_REQUIRED > stream_control.history_max) {
throw std::logic_error("Cannot set history to minimum history required");
}
size_t max_len =
MIN(stream_control->history_max,
MAX(MIN_HISTORY_REQUIRED, stream_control->history_min));
MIN(stream_control.history_max,
MAX(MIN_HISTORY_REQUIRED, stream_control.history_min));
assert(max_len >= MIN_HISTORY_REQUIRED);
size_t max_mask_len = maxMaskLen(lits);
@ -334,9 +334,9 @@ fdrBuildTableStreaming(const vector<hwlmLiteral> &lits,
// we want enough history to manage the longest literal and the longest
// mask.
stream_control->literal_history_required =
stream_control.literal_history_required =
max(maxLen(lits), max_mask_len) - 1;
stream_control->literal_stream_state_required = 0;
stream_control.literal_stream_state_required = 0;
return make_pair(nullptr, size_t{0});
}
@ -381,11 +381,11 @@ fdrBuildTableStreaming(const vector<hwlmLiteral> &lits,
streamBits[CASELESS] = lg2(roundUpToPowerOfTwo(positions[CASELESS] + 2));
u32 tot_state_bytes = (streamBits[CASEFUL] + streamBits[CASELESS] + 7) / 8;
u8 * secondaryTable = (u8 *)aligned_zmalloc(tabSize);
auto secondaryTable = aligned_zmalloc_unique<u8>(tabSize);
assert(secondaryTable); // otherwise would have thrown std::bad_alloc
// then fill it in
u8 * ptr = secondaryTable;
u8 * ptr = secondaryTable.get();
FDRSTableHeader * header = (FDRSTableHeader *)ptr;
// fill in header
header->pseudoEngineID = (u32)0xffffffff;
@ -411,7 +411,7 @@ fdrBuildTableStreaming(const vector<hwlmLiteral> &lits,
e = long_lits.end();
i != e; ++i) {
u32 entry = verify_u32(i - long_lits.begin());
u32 offset = verify_u32(ptr - secondaryTable);
u32 offset = verify_u32(ptr - secondaryTable.get());
// point the table entry to the string location
litTabPtr[entry].offset = offset;
@ -425,10 +425,10 @@ fdrBuildTableStreaming(const vector<hwlmLiteral> &lits,
}
// fill in final lit table entry with current ptr (serves as end value)
litTabPtr[long_lits.size()].offset = verify_u32(ptr - secondaryTable);
litTabPtr[long_lits.size()].offset = verify_u32(ptr - secondaryTable.get());
// fill hash tables
ptr = secondaryTable + htOffset[CASEFUL];
ptr = secondaryTable.get() + htOffset[CASEFUL];
for (u32 m = CASEFUL; m < MAX_MODES; ++m) {
fillHashes(long_lits, max_len, (FDRSHashEntry *)ptr, hashEntries[m],
(MODES)m, litToOffsetVal);
@ -436,9 +436,9 @@ fdrBuildTableStreaming(const vector<hwlmLiteral> &lits,
}
// tell the world what we did
stream_control->literal_history_required = max_len;
stream_control->literal_stream_state_required = tot_state_bytes;
return make_pair(secondaryTable, tabSize);
stream_control.literal_history_required = max_len;
stream_control.literal_stream_state_required = tot_state_bytes;
return make_pair(move(secondaryTable), tabSize);
}
} // namespace ue2

16
src/fdr/teddy_compile.cpp
View File

@ -74,7 +74,7 @@ public:
const TeddyEngineDescription &eng_in, bool make_small_in)
: eng(eng_in), lits(lits_in), make_small(make_small_in) {}
aligned_unique_ptr<FDR> build(pair<u8 *, size_t> link);
aligned_unique_ptr<FDR> build(pair<aligned_unique_ptr<u8>, size_t> &link);
bool pack(map<BucketIndex, std::vector<LiteralIndex> > &bucketToLits);
};
@ -281,7 +281,8 @@ bool TeddyCompiler::pack(map<BucketIndex,
return true;
}
aligned_unique_ptr<FDR> TeddyCompiler::build(pair<u8 *, size_t> link) {
aligned_unique_ptr<FDR>
TeddyCompiler::build(pair<aligned_unique_ptr<u8>, size_t> &link) {
if (lits.size() > eng.getNumBuckets() * TEDDY_BUCKET_LOAD) {
DEBUG_PRINTF("too many literals: %zu\n", lits.size());
return nullptr;
@ -342,8 +343,7 @@ aligned_unique_ptr<FDR> TeddyCompiler::build(pair<u8 *, size_t> link) {
if (link.first) {
teddy->link = verify_u32(ptr - teddy_base);
memcpy(ptr, link.first, link.second);
aligned_free(link.first);
memcpy(ptr, link.first.get(), link.second);
} else {
teddy->link = 0;
}
@ -436,10 +436,10 @@ aligned_unique_ptr<FDR> TeddyCompiler::build(pair<u8 *, size_t> link) {
} // namespace
aligned_unique_ptr<FDR> teddyBuildTableHinted(const vector<hwlmLiteral> &lits,
bool make_small, u32 hint,
const target_t &target,
pair<u8 *, size_t> link) {
aligned_unique_ptr<FDR>
teddyBuildTableHinted(const vector<hwlmLiteral> &lits, bool make_small,
u32 hint, const target_t &target,
pair<aligned_unique_ptr<u8>, size_t> &link) {
unique_ptr<TeddyEngineDescription> des;
if (hint == HINT_INVALID) {
des = chooseTeddyEngine(target, lits);

4
src/fdr/teddy_compile.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2015, Intel Corporation
* Copyright (c) 2015-2016, Intel Corporation
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
@ -49,7 +49,7 @@ struct hwlmLiteral;
ue2::aligned_unique_ptr<FDR>
teddyBuildTableHinted(const std::vector<hwlmLiteral> &lits, bool make_small,
u32 hint, const target_t &target,
std::pair<u8 *, size_t> link);
std::pair<aligned_unique_ptr<u8>, size_t> &link);
} // namespace ue2