#include "db.h"
-#include "vp4.h"
+#include "turbopfor-encode.h"
#include <algorithm>
-#include <arpa/inet.h>
#include <assert.h>
#include <chrono>
-#include <endian.h>
-#include <fcntl.h>
+#include <getopt.h>
+#include <iosfwd>
#include <math.h>
#include <memory>
+#include <stdint.h>
#include <stdio.h>
+#include <stdlib.h>
#include <string.h>
#include <string>
+#include <string_view>
#include <sys/stat.h>
-#include <sys/types.h>
-#include <unistd.h>
-#include <unordered_map>
+#include <utility>
#include <vector>
#include <zstd.h>
class PostingListBuilder {
public:
- void add_docid(uint32_t docid);
+ inline void add_docid(uint32_t docid);
void finish();
string encoded;
void write_header(uint32_t docid);
void append_block();
- vector<uint32_t> pending_docids;
+ vector<uint32_t> pending_deltas;
uint32_t last_block_end, last_docid = -1;
};
return;
}
+ pending_deltas.push_back(docid - last_docid - 1);
last_docid = docid;
- pending_docids.push_back(docid);
- if (pending_docids.size() == 128) {
+ if (pending_deltas.size() == 128) {
append_block();
- pending_docids.clear();
+ pending_deltas.clear();
last_block_end = docid;
}
++num_docids;
void PostingListBuilder::finish()
{
- if (pending_docids.empty()) {
+ if (pending_deltas.empty()) {
return;
}
// No interleaving for partial blocks.
unsigned char buf[P4NENC_BOUND(128)];
- unsigned char *end = p4d1enc32(pending_docids.data(), pending_docids.size(), buf, last_block_end);
+ unsigned char *end = encode_pfor_single_block<128>(pending_deltas.data(), pending_deltas.size(), /*interleaved=*/false, buf);
encoded.append(reinterpret_cast<char *>(buf), reinterpret_cast<char *>(end));
}
void PostingListBuilder::append_block()
{
unsigned char buf[P4NENC_BOUND(128)];
- assert(pending_docids.size() == 128);
- unsigned char *end = p4d1enc128v32(pending_docids.data(), 128, buf, last_block_end);
+ assert(pending_deltas.size() == 128);
+ unsigned char *end = encode_pfor_single_block<128>(pending_deltas.data(), 128, /*interleaved=*/true, buf);
encoded.append(reinterpret_cast<char *>(buf), reinterpret_cast<char *>(end));
}
void PostingListBuilder::write_header(uint32_t docid)
{
unsigned char buf[P4NENC_BOUND(1)];
- size_t bytes = p4nd1enc128v32(&docid, 1, buf);
- encoded.append(reinterpret_cast<char *>(buf), bytes);
+ unsigned char *end = write_baseval(docid, buf);
+ encoded.append(reinterpret_cast<char *>(buf), end - buf);
}
class Corpus {
public:
Corpus(FILE *outfp, size_t block_size)
- : invindex(new PostingListBuilder*[NUM_TRIGRAMS]), outfp(outfp), block_size(block_size) {}
+ : invindex(new PostingListBuilder *[NUM_TRIGRAMS]), outfp(outfp), block_size(block_size)
+ {
+ fill(invindex.get(), invindex.get() + NUM_TRIGRAMS, nullptr);
+ }
+ ~Corpus()
+ {
+ for (unsigned i = 0; i < NUM_TRIGRAMS; ++i) {
+ delete invindex[i];
+ }
+ }
+
void add_file(string filename);
void flush_block();
vector<uint64_t> filename_blocks;
size_t num_files = 0, num_files_in_block = 0, num_blocks = 0;
- bool seen_trigram(uint32_t trgm) {
+ bool seen_trigram(uint32_t trgm)
+ {
return invindex[trgm] != nullptr;
}
- PostingListBuilder& get_pl_builder(uint32_t trgm) {
+ PostingListBuilder &get_pl_builder(uint32_t trgm)
+ {
if (invindex[trgm] == nullptr) {
invindex[trgm] = new PostingListBuilder;
}
}
private:
- unique_ptr<PostingListBuilder*[]> invindex;
+ unique_ptr<PostingListBuilder *[]> invindex;
FILE *outfp;
string current_block;
string tempbuf;
string read_cstr(FILE *fp)
{
string ret;
- for ( ;; ) {
+ for (;;) {
int ch = getc(fp);
if (ch == -1) {
perror("getc");
hdr.version = -1; // Mark as broken.
hdr.hashtable_size = 0; // Not known yet.
hdr.extra_ht_slots = num_overflow_slots;
+ hdr.num_docids = 0;
hdr.hash_table_offset_bytes = -1; // We don't know these offsets yet.
hdr.filename_index_offset_bytes = -1;
fwrite(&hdr, sizeof(hdr), 1, outfp);
size_t trigrams = 0, longest_posting_list = 0;
size_t bytes_for_posting_lists = 0;
for (unsigned trgm = 0; trgm < NUM_TRIGRAMS; ++trgm) {
- if (!corpus.seen_trigram(trgm)) continue;
+ if (!corpus.seen_trigram(trgm))
+ continue;
PostingListBuilder &pl_builder = corpus.get_pl_builder(trgm);
pl_builder.finish();
longest_posting_list = max(longest_posting_list, pl_builder.num_docids);
dprintf("\n");
}
+void usage()
+{
+ printf(
+ "Usage: plocate-build MLOCATE_DB PLOCATE_DB\n"
+ "\n"
+ "Generate plocate index from mlocate.db, typically /var/lib/mlocate/mlocate.db.\n"
+ "Normally, the destination should be /var/lib/mlocate/plocate.db.\n"
+ "\n"
+ " -b, --block-size SIZE number of filenames to store in each block (default 32)\n"
+ " --help print this help\n"
+ " --version print version information\n");
+}
+
+void version()
+{
+ printf("plocate-build %s\n", PLOCATE_VERSION);
+ printf("Copyright 2020 Steinar H. Gunderson\n");
+ printf("License GPLv2+: GNU GPL version 2 or later <https://gnu.org/licenses/gpl.html>.\n");
+ printf("This is free software: you are free to change and redistribute it.\n");
+ printf("There is NO WARRANTY, to the extent permitted by law.\n");
+}
+
int main(int argc, char **argv)
{
- do_build(argv[1], argv[2], 32);
+ static const struct option long_options[] = {
+ { "block-size", required_argument, 0, 'b' },
+ { "help", no_argument, 0, 'h' },
+ { "version", no_argument, 0, 'V' },
+ { 0, 0, 0, 0 }
+ };
+
+ int block_size = 32;
+
+ setlocale(LC_ALL, "");
+ for (;;) {
+ int option_index = 0;
+ int c = getopt_long(argc, argv, "b:hV", long_options, &option_index);
+ if (c == -1) {
+ break;
+ }
+ switch (c) {
+ case 'b':
+ block_size = atoi(optarg);
+ break;
+ case 'h':
+ usage();
+ exit(0);
+ case 'v':
+ version();
+ exit(0);
+ default:
+ exit(1);
+ }
+ }
+
+ if (argc - optind != 2) {
+ usage();
+ exit(1);
+ }
+
+ do_build(argv[optind], argv[optind + 1], block_size);
exit(EXIT_SUCCESS);
}
projects / plocate / blobdiff