mirror of
https://github.com/felt/tippecanoe.git
synced 2026-10-03 00:45:41 +02:00
Erica Fischer
e2a7a409c7
* Add a way to run tippecanoe single-threaded for profiling * Do less work when the tilestats sample values list is already full * Save a copy when retrieving the attribute key * Fewer atomic operations * Move string hashing from mbtiles to text * Only do approximate attribute deduplication when writing tiles * Feature dropping tests are sensitive to exact tile size * All tile creators now create a string pool for the tile * Features clipped away to nothing should not participate in that tile * Revert "Only do approximate attribute deduplication when writing tiles" This reverts commitc42b34b498. * Also revert the related test changes * Revert "Revert "Only do approximate attribute deduplication when writing tiles"" This reverts commit18509876c3. * Be more specific about the string hash function * Use fnv1a instead of std::hash for everything * Reduce the chance of hash collisions * Stick a hash search on the front of the tree search in addpool * Eliminate repeated hashing of the same string * Switch instead of ifs in json parsing * A few more cases to populate the hash in addpool * Store the hash in the tree instead of recalculating * Add explanatory comment for mysterious argument * Fewer copies in attribute stringification * Clean up ancient weirdness in JSON attribute stringification * More serial_val cleanup * Pass a serial_feature to rewrite instead of many broken-down arguments * Get rid of the multiple geometries within `partial` * Revert "Pass a serial_feature to rewrite instead of many broken-down arguments" This reverts commit6f4ab9b725. * Goodbye, struct coalesce * Revert "Features clipped away to nothing should not participate in that tile" This reverts commit124462fbdc. * Migrating fields from partial to serial_feature * Name reconciliation between serial_feature and partial * Replace struct partial with an augmented serial_feature * Fix some overzealous search-and-replace renaming * Don't say struct so often * Remove more of the former partial construction * Commenting and cleaning up * Trying again to avoid all these arguments to rewrite * I swear I did this same thing before and it didn't work. * More rewrite cleanup * Exile --detect-shared-borders to its own file * Add missing headers * More commenting and cleanup * More comments * Sprinkle consts around * Emplacing and std::moving * More cleanup * That shouldn't have worked after a std::move * Don't need to allocate memory to compare keys * Reduce use of the global string pool in tiling * Another avoidable mvt_value construction * Further reduction to explicit string pool passing * These reverses are no longer optimizations * These layernames can all be references * Don't drag an unused layername string around with every feature * Heed a compiler warning about potential buffer overflow * Fix my confusion about which feature's string pool is relevant * Avoid some unnecessary allocations in attribute accumulation * Maybe faster serialization? * Eliminate a comparison * Do the same here * Save a couple of allocations when parsing numbers in JSON * Immediately assign features to layers instead of subdividing later * Maintain tilestats for tippecanoe:retain_points_multiplier_sequence * Crunch out more duplicate attribute values when writing out the tile * Do tilestats for tippecanoe:retain_points_multiplier_first too * Shell filters need to be real threads, even if nothing else does * Simplify tippecanoe_minzoom/maxzoom representation * Update version and changelog
92 lines
1.9 KiB
C++
92 lines
1.9 KiB
C++
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
#include <sys/mman.h>
|
|
#include <errno.h>
|
|
#include "memfile.hpp"
|
|
|
|
#define INCREMENT 131072
|
|
#define INITIAL 256
|
|
|
|
struct memfile *memfile_open(int fd) {
|
|
if (ftruncate(fd, INITIAL) != 0) {
|
|
return NULL;
|
|
}
|
|
|
|
struct memfile *mf = new memfile;
|
|
if (mf == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
mf->fd = fd;
|
|
mf->tree = 0;
|
|
mf->off = 0;
|
|
|
|
return mf;
|
|
}
|
|
|
|
int memfile_close(struct memfile *file) {
|
|
// If it isn't full yet, flush out the string to the file now.
|
|
// If it is full, close out the buffered file writer.
|
|
|
|
if (file->fp == NULL) {
|
|
if (write(file->fd, file->map.c_str(), file->map.size()) != (ssize_t) file->map.size()) {
|
|
return -1;
|
|
}
|
|
|
|
if (file->fd >= 0) {
|
|
if (close(file->fd) != 0) {
|
|
return -1;
|
|
}
|
|
}
|
|
} else {
|
|
if (fclose(file->fp) != 0) {
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
delete file;
|
|
return 0;
|
|
}
|
|
|
|
int memfile_write(struct memfile *file, void *s, long long len, bool &in_memory) {
|
|
// If it is full, append to the file.
|
|
// If it is not full yet, append to the string in memory.
|
|
|
|
in_memory = false;
|
|
if (file->fp != NULL) {
|
|
if (fwrite(s, sizeof(char), len, file->fp) != (size_t) len) {
|
|
return 0;
|
|
}
|
|
file->off += len;
|
|
} else {
|
|
file->map.append(std::string((char *) s, len));
|
|
file->off += len;
|
|
in_memory = true;
|
|
}
|
|
|
|
return len;
|
|
}
|
|
|
|
void memfile_full(struct memfile *file) {
|
|
// The file is full. Write out a copy of whatever has accumulated in memory
|
|
// to the file, and switch to appending to the file. Existing references
|
|
// into the memory still work.
|
|
|
|
if (file->fp != NULL) {
|
|
fprintf(stderr, "memfile marked full twice\n");
|
|
exit(EXIT_IMPOSSIBLE);
|
|
}
|
|
|
|
file->fp = fdopen(file->fd, "wb");
|
|
if (file->fp == NULL) {
|
|
fprintf(stderr, "fdopen memfile: %s\n", strerror(errno));
|
|
exit(EXIT_OPEN);
|
|
}
|
|
|
|
if (fwrite(file->map.c_str(), sizeof(char), file->map.size(), file->fp) != file->map.size()) {
|
|
fprintf(stderr, "memfile write: %s\n", strerror(errno));
|
|
exit(EXIT_WRITE);
|
|
}
|
|
}
|