private static DB constructDB(File file) { return DBMaker.newFileDB(file) .transactionDisable() .mmapFileEnable() .asyncWriteEnable() .compressionEnable() .make(); }
@Override protected void init() throws FailStoreException { try { String dbName = dbPath.getPath() + "/lts.db"; db = DBMaker.fileDB(new File(dbName)) .closeOnJvmShutdown() .encryptionEnable("lts") .make(); } catch (Exception e) { throw new FailStoreException(e); } }
m = DBMaker.newFileDB(new File(rootPath.toFile(), storageType.toString())); m = DBMaker.newTempFileDB().deleteFilesAfterClose(); m = m.compressionEnable(); m = m.cacheLRUEnable().cacheSize(storageConfiguration.getCacheSize()) ; m = m.cacheDisable(); m = m.asyncWriteEnable(); m = m.transactionDisable(); m = m.closeOnJvmShutdown(); storage = m.make(); storageRegistry.put(storageType, storage);
/** Create a GTFS feed in a temp file */ public GTFSFeed () { // calls to this must be first operation in constructor - why, Java? this(DBMaker.newTempFileDB() .transactionDisable() .mmapFileEnable() .asyncWriteEnable() .deleteFilesAfterClose() .compressionEnable() // .cacheSize(1024 * 1024) this bloats memory consumption .make()); // TODO db.close(); }
.newFileDB(tmpFile) .closeOnJvmShutdown() .transactionDisable() .deleteFilesAfterClose() .strictDBGet() .asyncWriteEnable() .mmapFileEnable() .commitFileSyncDisable() .cacheSize(config.getNumBufferedEntries()) .make(); try { lifecycle.addMaybeStartHandler(
DBMaker<?> dbMaker = DBMaker.newFileDB(file); if (this.cacheSize != null) { dbMaker.cacheSize(cacheSize); logger().debug("MapDB cache size set to {0} for index provider {1}", cacheSize, getName()); dbMaker.cacheLRUEnable(); logger().debug("MapDB cacheLRU enabled for index provider {0}", getName()); dbMaker.mmapFileEnableIfSupported(); logger().debug("MapDB mmapFiles enabled for index provider {0}", getName()); dbMaker.commitFileSyncDisable(); logger().debug("MapDB commitFileSync enabled for index provider {0}", getName()); dbMaker.transactionDisable(); logger().debug("MapDB transactions disabled for index provider {0}", getName()); dbMaker.asyncWriteEnable(); logger().debug("MapDB async writes enabled for index provider {0}", getName()); dbMaker.closeOnJvmShutdown(); this.db = dbMaker.make(); this.indexUpdater = new IndexUpdater(db);
public static synchronized DBMaker<?> SafeDefaultDb(String loc,String name){ File dbFile = new File(loc); if (!dbFile.exists()) dbFile.mkdirs(); dbFile = new File(dbFile, "mapdb"); logger.info("Opening DB "+name+" at " + dbFile); // Storing gigantic maps in this temporary DB return DBMaker.newFileDB(dbFile).freeSpaceReclaimQ(3) .mmapFileEnablePartial() .cacheLRUEnable() .closeOnJvmShutdown(); } public static <K extends Comparable<K>, V> BTreeMap<K, V> batchCreate(final Map<K, V> map,
private void init() { DBMaker maker; if (file == null) maker = DBMaker.newMemoryDB(); else { if (overwrite) wipe(file); maker = DBMaker.newFileDB(new File(file)); maker = maker.cacheSize(cache_size); if (async) { maker = maker.asyncWriteEnable(); maker = maker.asyncWriteFlushDelay(10000); } if (mmap) maker = maker.mmapFileEnableIfSupported(); if (compression) maker = maker.compressionEnable(); if (snapshot) maker = maker.snapshotEnable(); if (notxn) maker = maker.transactionDisable(); } db = maker.make(); if (!db.exists("idmap")) idmap = db.createHashMap("idmap") .valueSerializer(new RecordSerializer()) .make(); else idmap = db.getHashMap("idmap"); }
public OrderIterator(CloseableIteration<BindingSet, QueryEvaluationException> iter, Comparator<BindingSet> comparator, long limit, boolean distinct, long iterationSyncThreshold) { this.iter = iter; this.comparator = comparator; this.limit = limit; this.distinct = distinct; this.iterationSyncThreshold = iterationSyncThreshold; if (iterationSyncThreshold > 0) { try { this.tempFile = File.createTempFile("order-eval", null); } catch (IOException e) { throw new IOError(e); } this.db = DBMaker.newFileDB(tempFile).deleteFilesAfterClose().closeOnJvmShutdown().make(); } else { this.tempFile = null; this.db = null; } }
comparisonDb = DBMaker.newFileDB(new File(args[1])) .readOnly() .transactionDisable() .closeOnJvmShutdown() .cacheSize(24) .asyncWriteEnable() .make(); DB outputDb = DBMaker.newFileDB(new File(outputName)) .transactionDisable() .cacheSize(48) .closeOnJvmShutdown() .make();
db = DBMaker.newFileDB(dbFile) .closeOnJvmShutdown() .transactionDisable() .syncOnCommitDisable() .deleteFilesAfterClose() .cacheDisable() .mmapFileEnableIfSupported() .make(); queueSet = db.createHashSet("QueueSet " + " - " + backingStore.getName()).make();
DBMaker dbMaker = DBMaker.newFileDB(new File(journalFileLocation, RECORDS_FIELD)) .compressionEnable() .checksumEnable() .mmapFileEnableIfSupported() .closeOnJvmShutdown(); dbMaker.asyncWriteEnable(); this.journalDB = dbMaker.make(); this.records = this.journalDB.createTreeMap(RECORDS_FIELD) .keySerializer(BTreeKeySerializer.ZERO_OR_POSITIVE_LONG)
if (diskPath == null) { LOG.info("OSM will be stored in a temporary file."); dbMaker = DBMaker.newTempFileDB().deleteFilesAfterClose(); } else { if (diskPath.equals("__MEMORY__")) { LOG.info("OSM will be stored in memory."); dbMaker = DBMaker.newMemoryDirectDB(); } else { File dp = new File(diskPath); dbMaker = DBMaker.newFileDB(dp); .transactionDisable() .compressionEnable() .mmapFileEnableIfSupported() .make(); } else { db = dbMaker.asyncWriteEnable() .transactionDisable() .compressionEnable() .mmapFileEnableIfSupported() .closeOnJvmShutdown() .make();
@Override public V put(K key, V value) { if (hashMap.size() == THRESHOLD) { File dbFile; try { dbFile = File.createTempFile("mapdb", "temp"); } catch (IOException e) { throw new UncheckedIOException(e); } mapDB = DBMaker.newFileDB(dbFile).deleteFilesAfterClose().transactionDisable().make(); map = mapDB.createHashMap("map").make(); map.putAll(hashMap); hashMap.clear(); } if (map == null) { return hashMap.put(key, value); } return map.put(key, value); }
@Override public boolean loadExisting() { this.data = DBMaker.newFileDB(new File(dir.getLocation() + "/transit_schedule")).transactionDisable().mmapFileEnable().readOnly().make(); init(); for (String gtfsFeedId : this.gtfsFeedIds) { GTFSFeed feed = new GTFSFeed(new File(dir.getLocation() + "/" + gtfsFeedId)); this.gtfsFeeds.put(gtfsFeedId, feed); this.transfers.put(gtfsFeedId, new Transfers(feed)); } return true; }
/** * Create a new DataStore. * @param directory Where should it be created? */ public JumperDataStore(File directory) { if(!directory.exists()) directory.mkdirs(); DBMaker dbm = DBMaker.newFileDB(new File(directory, "jumpers.db")) .mmapFileEnableIfSupported() .cacheLRUEnable() .cacheSize(100000) .asyncWriteEnable() .asyncWriteFlushDelay(1000) .closeOnJvmShutdown(); db = dbm.make(); jumperMap = db.createTreeMap("jumperMap") .valueSerializer(new JumperSerializer()) .makeOrGet(); jumperStartIndex = db.createTreeSet("startIndex") .serializer(BTreeKeySerializer.TUPLE2) .makeOrGet(); jumperEndIndex = db.createTreeSet("endIndex") .serializer(BTreeKeySerializer.TUPLE2) .makeOrGet(); }
public DB initDb(String cacheName) throws PropertyEnricherException { File mapdbCacheDir = new File(getCacheDir(), "mapdb"); createCacheDir(mapdbCacheDir, isTemporary()); DBMaker dbMaker = DBMaker .newFileDB(new File(mapdbCacheDir, cacheName)) .mmapFileEnableIfSupported() .closeOnJvmShutdown() .transactionDisable(); if (isTemporary()) { dbMaker.deleteFilesAfterClose(); } return dbMaker .make(); }
public LocalLinkSet() { this.db = DBMaker .newTempFileDB() .mmapFileEnable() .transactionDisable() .asyncWriteEnable() .asyncWriteFlushDelay(100) .make(); this.setMaker = db.createTreeSet("linkHashes"); long heapMaxSize = Runtime.getRuntime().maxMemory(); int presortMem = (int) Math.min(Integer.MAX_VALUE, Math.max(MIN_SORT_MEMORY, heapMaxSize / 20)); setMaker.pumpIgnoreDuplicates(); setMaker.pumpPresort(presortMem / LONG_MEMORY_BYTES); worker = new Thread() { @Override public void run() { setMaker.pumpSource(new LinkHashIterator()); set = setMaker.makeLongSet(); } }; worker.start(); }
@Activate public void activate() { dbFolderName = ConfigConstants.getUserDataFolder() + File.separator + dbFolderName; File folder = new File(dbFolderName); if (!folder.exists()) { folder.mkdirs(); } File dbFile = new File(dbFolderName, DB_FILE_NAME); db = DBMaker.newFileDB(dbFile).closeOnJvmShutdown().make(); logger.debug("Opened MapDB file at '{}'.", dbFile.getAbsolutePath()); }
@Provides @Singleton DB getMaker() { File dbLocation = new File(configuration.getLocation(), "SciGraphIdMap"); return DBMaker.newFileDB(dbLocation).closeOnJvmShutdown().transactionDisable().mmapFileEnable() .make(); }