motiejus/turbonss
1
Fork 0
Code Releases Activity

Improved const-correctness.

Browse Source
This commit is contained in:
Davi de Castro Reis 2011-05-15 23:24:12 -03:00
parent 37a57c18e8
commit 5a4ba7516c
2 changed files with 46 additions and 17 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

52
cxxmph/mph_table.cc
View File

@ -116,9 +116,10 @@ void MPHTable::Assigning(
// Initialize vector of half nibbles with all bits set.
g_size_ = static_cast<uint32_t>(ceil(n_/4.0));
delete [] g_;
g_ = new uint8_t[g_size_];
memset(g_, std::numeric_limits<uint8_t>::max(), g_size_);
assert(g_[g_size_ - 1] == 255);
g_ = NULL;
uint8_t* g = new uint8_t[g_size_];
memset(g, std::numeric_limits<uint8_t>::max(), g_size_);
assert(g[g_size_ - 1] == 255);
uint32_t nedges = m_; // for legibility
for (int i = nedges - 1; i + 1 >= 1; --i) {
@ -132,34 +133,35 @@ void MPHTable::Assigning(
*/
if (!marked_vertices[e[0]]) {
if (!marked_vertices[e[1]]) {
set_2bit_value(g_, e[1], kUnassigned);
set_2bit_value(g, e[1], kUnassigned);
marked_vertices[e[1]] = true;
}
if (!marked_vertices[e[2]]) {
set_2bit_value(g_, e[2], kUnassigned);
set_2bit_value(g, e[2], kUnassigned);
assert(marked_vertices.size() > e[2]);
marked_vertices[e[2]] = true;
}
set_2bit_value(g_, e[0], (6 - (get_2bit_value(g_, e[1]) + get_2bit_value(g_, e[2]))) % 3);
set_2bit_value(g, e[0], (6 - (get_2bit_value(g, e[1]) + get_2bit_value(g, e[2]))) % 3);
marked_vertices[e[0]] = true;
} else if (!marked_vertices[e[1]]) {
if (!marked_vertices[e[2]]) {
set_2bit_value(g_, e[2], kUnassigned);
set_2bit_value(g, e[2], kUnassigned);
marked_vertices[e[2]] = true;
}
set_2bit_value(g_, e[1], (7 - (get_2bit_value(g_, e[0]) + get_2bit_value(g_, e[2]))) % 3);
set_2bit_value(g, e[1], (7 - (get_2bit_value(g, e[0]) + get_2bit_value(g, e[2]))) % 3);
marked_vertices[e[1]] = true;
} else {
set_2bit_value(g_, e[2], (8 - (get_2bit_value(g_, e[0]) + get_2bit_value(g_, e[1]))) % 3);
set_2bit_value(g, e[2], (8 - (get_2bit_value(g, e[0]) + get_2bit_value(g, e[1]))) % 3);
marked_vertices[e[2]] = true;
}
/*
cerr << "A: " << e[0] << " " << e[1] << " " << e[2] << " -> "
<< get_2bit_value(g_, e[0]) << " "
<< get_2bit_value(g_, e[1]) << " "
<< get_2bit_value(g_, e[2]) << " " << endl;
<< get_2bit_value(g, e[0]) << " "
<< get_2bit_value(g, e[1]) << " "
<< get_2bit_value(g, e[2]) << " " << endl;
*/
}
g_ = g;
}
void MPHTable::Ranking() {
@ -168,8 +170,9 @@ void MPHTable::Ranking() {
ranktable_size_ = static_cast<uint32_t>(
ceil(n_ / static_cast<double>(k_)));
delete [] ranktable_;
ranktable_ = new uint32_t[ranktable_size_];
memset(ranktable_, 0, ranktable_size_*sizeof(uint32_t));
ranktable_ = NULL;
uint32_t* ranktable = new uint32_t[ranktable_size_];
memset(ranktable, 0, ranktable_size_*sizeof(uint32_t));
uint32_t offset = 0;
uint32_t count = 0;
uint32_t i = 1;
@ -177,11 +180,12 @@ void MPHTable::Ranking() {
if (i == ranktable_size_) break;
uint32_t nbytes = size < nbytes_total ? size : nbytes_total;
for (uint32_t j = 0; j < nbytes; ++j) count += kBdzLookupTable[g_[offset + j]];
ranktable_[i] = count;
ranktable[i] = count;
offset += nbytes;
nbytes_total -= size;
++i;
}
ranktable_ = ranktable;
}
uint32_t MPHTable::Rank(uint32_t vertex) const {
@ -209,4 +213,22 @@ uint32_t MPHTable::Rank(uint32_t vertex) const {
return base_rank;
}
uint32_t MPHTable::serialize_bytes_needed() const {
return sizeof(MPHTable) + g_size_ + ranktable_size_*sizeof(uint32_t);
}
void MPHTable::serialize(char* memory) const {
memcpy(memory, this, sizeof(MPHTable));
memcpy(memory + sizeof(MPHTable), g_, g_size_);
memcpy(memory + sizeof(MPHTable) + g_size_,
ranktable_, ranktable_size_*sizeof(uint32_t));
}
bool MPHTable::deserialize(const char* serialized_memory) {
memcpy(this, serialized_memory, sizeof(MPHTable));
g_ = reinterpret_cast<const uint8_t*>(serialized_memory + sizeof(MPHTable));
ranktable_ = reinterpret_cast<const uint32_t*>(
serialized_memory + sizeof(MPHTable) + g_size_);
return true;
}
} // namespace cxxmph

11
cxxmph/mph_table.h
View File

@ -34,6 +34,13 @@ class MPHTable {
uint32_t size() const { return m_; }
void clear();
// Serialization machinery for mmap usage.
// Serialized tables are not guaranteed to work across versions or different
// endianness (although they could easily be made to be).
uint32_t serialize_bytes_needed() const;
void serialize(char *memory) const;
bool deserialize(const char* serialized_memory);
private:
template <class SeededHashFcn, class ForwardIterator>
bool Mapping(ForwardIterator begin, ForwardIterator end,
@ -60,10 +67,10 @@ class MPHTable {
uint32_t r_;
// The array containing the minimal perfect hash function graph. Do not use
// c++ vector to make mmap based backing easier.
uint8_t* g_;
const uint8_t* g_;
uint32_t g_size_;
// The table used for the rank step of the minimal perfect hash function
uint32_t* ranktable_;
const uint32_t* ranktable_;
uint32_t ranktable_size_;
// The selected hash seed triplet for finding the edges in the minimal
// perfect hash function graph.