private void syncAndClose(Bin bin) { try { bin.sync(); } finally { bin.close(); } }
/** * Gets the level associated with the given bin number. * * @param bin The bin for which to determine the level. * @return the level associated with the given bin number. */ public int getLevelForBin(final Bin bin) { if (bin.getBinNumber() >= GenomicIndexUtil.MAX_BINS) throw new SAMException("Tried to get level for invalid bin."); for (int i = getNumIndexLevels() - 1; i >= 0; i--) { if (bin.getBinNumber() >= GenomicIndexUtil.LEVEL_STARTS[i]) return i; } throw new SAMException("Unable to find correct bin for bin " + bin); }
private void updateGaps(Bin<T> prev, Bin<T> next) { Gap<T> newGap = new Gap<T>(prev, next, gapWeight(prev, next)); Gap<T> prevGap = _binsToGaps.get(prev.getMean()); if (prevGap != null) { _gaps.remove(prevGap); } _binsToGaps.put(prev.getMean(), newGap); _gaps.add(newGap); }
private void updateGaps(Bin<T> newBin) { Bin<T> prev = lower(newBin.getMean()); if (prev != null) { updateGaps(prev, newBin); } Bin<T> next = higher(newBin.getMean()); if (next != null) { updateGaps(newBin, next); } }
private void writeToLockFile(int lockSignal) { ByteArrayBuffer lockBuffer = newLockFileBuffer(); lockBuffer.writeInt(lockSignal); lockBuffer.writeInt(lockSignal); write(_lockFile, lockBuffer); _lockFile.sync(); }
@Override public void applySlotChanges( Visitable<SlotChange> slotChangeTree, int slotChangeCount, Slot reservedSlot) { if (slotChangeCount < 1) { return; } Runnable commitHook = _container.commitHook(); flushDatabaseFile(); ensureLogAndLock(); int length = transactionLogSlotLength(slotChangeCount); ByteArrayBuffer logBuffer = new ByteArrayBuffer(length); logBuffer.writeInt(length); logBuffer.writeInt(slotChangeCount); appendSlotChanges(logBuffer, slotChangeTree); write(_logFile, logBuffer); _logFile.sync(); writeToLockFile(LOCK_INT); writeSlots(slotChangeTree); commitHook.run(); flushDatabaseFile(); writeToLockFile(0); }
/** * Gets the last locus that this bin can index into. * * @param bin The bin to test. * @return The last position that the given bin can represent. */ public int getLastLocusInBin(final Bin bin) { final int level = getLevelForBin(bin); final int levelStart = GenomicIndexUtil.LEVEL_STARTS[level]; final int levelSize = ((level == getNumIndexLevels() - 1) ? GenomicIndexUtil.MAX_BINS - 1 : GenomicIndexUtil.LEVEL_STARTS[level + 1]) - levelStart; return (bin.getBinNumber() - levelStart + 1) * (GenomicIndexUtil.BIN_GENOMIC_SPAN / levelSize); }
@Override public void merge() { while (_bins.size() > getMaxBins()) { Gap<T> smallestGap = _gaps.pollFirst(); Bin<T> newBin = smallestGap.getStartBin().combine(smallestGap.getEndBin()); Gap<T> followingGap = _binsToGaps.get(smallestGap.getEndBin().getMean()); if (followingGap != null) { _gaps.remove(followingGap); } _bins.remove(smallestGap.getStartBin().getMean()); _bins.remove(smallestGap.getEndBin().getMean()); _binsToGaps.remove(smallestGap.getStartBin().getMean()); _binsToGaps.remove(smallestGap.getEndBin().getMean()); updateGaps(newBin); _bins.put(newBin.getMean(), newBin); } }
public static Solution fit(Solution sol, List<Integer> sticks) { Collections.sort(sticks); Collections.reverse(sticks); Set<Bin> set = sol.getBins(); List<Bin> bins = new ArrayList<>(set); Collections.sort(bins); Collections.reverse(bins); boolean added = false; for (Integer i : sticks) { added = false; for (Bin bin : bins) { if (bin.add(i)) { added = true; break; } } if (!added) { bins.add(new Bin(i, sol.getCapacity())); } } return new Solution(new HashSet<>(bins), sol.getCapacity()); }
private void write(Bin storage, ByteArrayBuffer buffer) { storage.write(0, buffer._buffer, buffer.length()); }
private void read(Bin storage, ByteArrayBuffer buffer) { storage.read(0, buffer._buffer, buffer.length()); }
/** * Constructor. * * @param bin base64 input * @param ii input info * @throws QueryException query exception */ public B64(final Bin bin, final InputInfo ii) throws QueryException { this(bin.binary(ii)); }
protected BAMIndexContent query( final int referenceSequence, final int startPos, final int endPos) { seek(4); final List<Chunk> metaDataChunks = new ArrayList<Chunk>(); final int sequenceCount = readInteger(); if (referenceSequence >= sequenceCount) { return null; } final BitSet regionBins = GenomicIndexUtil.regionToBins(startPos, endPos); if (regionBins == null) { return null; } skipToSequence(referenceSequence); final int binCount = readInteger(); boolean metaDataSeen = false; final Bin[] bins = new Bin[getMaxBinNumberForReference(referenceSequence) + 1]; for (int binNumber = 0; binNumber < binCount; binNumber++) { final int indexBin = readInteger(); final int nChunks = readInteger(); List<Chunk> chunks = null; // System.out.println("# bin[" + i + "] = " + indexBin + ", nChunks = " + nChunks); Chunk lastChunk = null; if (regionBins.get(indexBin)) { chunks = new ArrayList<Chunk>(nChunks); for (int ci = 0; ci < nChunks; ci++) { final long chunkBegin = readLong(); final long chunkEnd = readLong(); lastChunk = new Chunk(chunkBegin, chunkEnd); chunks.add(lastChunk); } } else if (indexBin == GenomicIndexUtil.MAX_BINS) { // meta data - build the bin so that the count of bins is correct; // but don't attach meta chunks to the bin, or normal queries will be off for (int ci = 0; ci < nChunks; ci++) { final long chunkBegin = readLong(); final long chunkEnd = readLong(); lastChunk = new Chunk(chunkBegin, chunkEnd); metaDataChunks.add(lastChunk); } metaDataSeen = true; continue; // don't create a Bin } else { skipBytes(16 * nChunks); chunks = Collections.emptyList(); } final Bin bin = new Bin(referenceSequence, indexBin); bin.setChunkList(chunks); bin.setLastChunk(lastChunk); bins[indexBin] = bin; } final int nLinearBins = readInteger(); final int regionLinearBinStart = LinearIndex.convertToLinearIndexOffset(startPos); final int regionLinearBinStop = endPos > 0 ? LinearIndex.convertToLinearIndexOffset(endPos) : nLinearBins - 1; final int actualStop = Math.min(regionLinearBinStop, nLinearBins - 1); long[] linearIndexEntries = new long[0]; if (regionLinearBinStart < nLinearBins) { linearIndexEntries = new long[actualStop - regionLinearBinStart + 1]; skipBytes(8 * regionLinearBinStart); for (int linearBin = regionLinearBinStart; linearBin <= actualStop; linearBin++) linearIndexEntries[linearBin - regionLinearBinStart] = readLong(); } final LinearIndex linearIndex = new LinearIndex(referenceSequence, regionLinearBinStart, linearIndexEntries); return new BAMIndexContent( referenceSequence, bins, binCount - (metaDataSeen ? 1 : 0), new BAMIndexMetaData(metaDataChunks), linearIndex); }
@Override public void insert(Bin<T> bin) { addTotalCount(bin); if (isFrozen() && getBins().size() == getMaxBins()) { Double floorDiff = Double.MAX_VALUE; Bin<T> floorBin = floor(bin.getMean()); if (floorBin != null) { floorDiff = Math.abs(floorBin.getMean() - bin.getMean()); } Double ceilDiff = Double.MAX_VALUE; Bin<T> ceilBin = ceiling(bin.getMean()); if (ceilBin != null) { ceilDiff = Math.abs(ceilBin.getMean() - bin.getMean()); } if (floorDiff <= ceilDiff) { floorBin.sumUpdate(bin); } else { ceilBin.sumUpdate(bin); } } else { Bin<T> existingBin = get(bin.getMean()); if (existingBin != null) { existingBin.sumUpdate(bin); if (isWeightGaps()) { updateGaps(existingBin); } } else { updateGaps(bin); _bins.put(bin.getMean(), bin); } } }
@Override public IBin binFromNameRecurseUp(String name) { Pointer p = gst_bin_get_by_name_recurse_up(ptr, name); if (p == null || p == Pointer.NULL) return null; return Bin.from(p); }