@Override public String toString() { return String.format("%s <%d/%d>", factory.getConfiguration().getName(), maxFilesPerLevel, maxLevels); }
@Override public SerializedComparator getComparator() { return factory.getConfiguration().getComparator(); }
private File nextLogFile() { return new File(sos.getFactory().getConfiguration().getName() + "-" + UUID.randomUUID().toString() + ".aolog"); } }
private SortedBuffer<Integer> flipBuffer() { final SortedBuffer<Integer> sb; sb = getCurrent(); SortedBuffer<Integer> next = new SortedBuffer<Integer>( factory.getConfiguration(), bufferCount.incrementAndGet()); current.set(next); if (logger.fineEnabled()) { logger.fine(String.format("Switching from buffer %s to %s", sb, next)); } return sb; }
public RecoverableSortedOplogSet(SortedOplogSet sos, long bufferSize, double memLimit) throws IOException { this.sos = sos; this.bufferSize = bufferSize; log = ComponentLogWriter.getSoplogLogWriter(sos.getFactory().getConfiguration().getName(), LogService.logger()); rollLock = new ReentrantLock(); writer = new AtomicReference<AppendLogWriter>(AppendLog.create(nextLogFile())); maxBufferMemory = Math.round(memLimit * ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getMax()); }
protected void markAsInactive(Iterable<TrackedReference<SortedOplogReader>> snapshot, T attach) throws IOException { for (Iterator<TrackedReference<SortedOplogReader>> iter = snapshot.iterator(); iter.hasNext(); ) { TrackedReference<SortedOplogReader> tr = iter.next(); if (logger.fineEnabled()) { logger.fine(String.format("Marking %s as inactive", tr)); } inactive.add(tr); tracker.fileRemoved(tr.get().getFile(), attach); factory.getConfiguration().getStatistics().incActiveFiles(-1); factory.getConfiguration().getStatistics().incInactiveFiles(1); } }
public AbstractCompactor(SortedOplogFactory factory, Fileset<T> fileset, CompactionTracker<T> tracker, Executor exec) { assert factory != null; assert fileset != null; assert tracker != null; assert exec != null; this.factory = factory; this.fileset = fileset; this.tracker = tracker; compactor = new AbortableTaskService(exec); inactive = new ConcurrentLinkedQueue<TrackedReference<SortedOplogReader>>(); levelLock = new ReentrantReadWriteLock(); levels = new ArrayList<Level>(); logger = ComponentLogWriter.getSoplogLogWriter(factory.getConfiguration().getName(), LogService.logger()); }
public SortedOplogSetImpl(final SortedOplogFactory factory, Executor exec, Compactor ctor) throws IOException { this.factory = factory; this.flusher = new AbortableTaskService(exec); this.compactor = ctor; rwlock = new ReentrantReadWriteLock(); bufferCount = new AtomicInteger(0); unflushed = new ArrayDeque<SortedBuffer<Integer>>(); current = new AtomicReference<SortedBuffer<Integer>>( new SortedBuffer<Integer>(factory.getConfiguration(), 0)); logger = ComponentLogWriter.getSoplogLogWriter(factory.getConfiguration().getName(), LogService.logger()); if (logger.fineEnabled()) { logger.fine("Creating soplog set"); } }
@Override protected synchronized void close() throws IOException { for (TrackedReference<SortedOplogReader> tr : soplogs) { tr.get().close(); factory.getConfiguration().getStatistics().incActiveFiles(-1); } soplogs.clear(); }
private void handleError(Exception e, AtomicBoolean aborted) { if (lockOrAbort(aborted)) { try { unflushed.removeFirstOccurrence(buffer); } finally { rwlock.writeLock().unlock(); } } handler.error(e); factory.getConfiguration().getStatistics().getFlush().error(start); }
@Override public SortedIterator<ByteBuffer> scan( byte[] from, boolean fromInclusive, byte[] to, boolean toInclusive, boolean ascending, MetadataFilter filter) throws IOException { SerializedComparator sc = factory.getConfiguration().getComparator(); sc = ascending ? sc : ReversingSerializedComparator.reverse(sc); List<SortedIterator<ByteBuffer>> scans = new ArrayList<SortedIterator<ByteBuffer>>(); Collection<TrackedReference<SortedOplogReader>> soplogs; rwlock.readLock().lock(); try { scans.add(getCurrent().scan(from, fromInclusive, to, toInclusive, ascending, filter)); for (SortedBuffer<Integer> sb : unflushed) { scans.add(sb.scan(from, fromInclusive, to, toInclusive, ascending, filter)); } soplogs = compactor.getActiveReaders(from, to); } finally { rwlock.readLock().unlock(); } for (TrackedReference<SortedOplogReader> tr : soplogs) { scans.add(tr.get().scan(from, fromInclusive, to, toInclusive, ascending, filter)); } return new MergedIterator(sc, soplogs, scans); }
@Override public void abortBeforeRun() { handler.complete(); factory.getConfiguration().getStatistics().getFlush().end(start); }
@Override public void put(byte[] key, byte[] value) { assert key != null; assert value != null; long start = factory.getConfiguration().getStatistics().getPut().begin(); getCurrent().put(key, value); factory.getConfiguration().getStatistics().getPut().end(value.length, start); }
protected EnumMap<Metadata, byte[]> mergeMetadata( Collection<TrackedReference<SortedOplogReader>> readers) throws IOException { // merge the metadata into the compacted file EnumMap<Metadata, byte[]> metadata = new EnumMap<Metadata, byte[]>(Metadata.class); for (Metadata meta : Metadata.values()) { byte[] val = null; for (TrackedReference<SortedOplogReader> tr : readers) { byte[] tmp = tr.get().getMetadata(meta); if (val == null) { val = tmp; } else if (tmp != null) { val = factory.getConfiguration().getMetadataCompactor(meta).compact(val, tmp); } } if (val != null) { metadata.put(meta, val); } } return metadata; }
@Override protected void add(SortedOplog soplog) throws IOException { SortedOplogReader rdr = soplog.createReader(); synchronized (this) { soplogs.addFirst(new TrackedReference<SortedOplogReader>(rdr)); } if (logger.fineEnabled()) { logger.fine(String.format("Added file %s to level %d", rdr, level)); } tracker.fileAdded(rdr.getFile(), level); factory.getConfiguration().getStatistics().incActiveFiles(1); }
long start = factory.getConfiguration().getStatistics().getClear().begin(); factory.getConfiguration().getStatistics().getClear().end(start); factory.getConfiguration().getStatistics().getClear().error(start); throw (IOException) e.fillInStackTrace();
@Override public void destroy() throws IOException { if (logger.fineEnabled()) { logger.fine("Destroying soplog set"); } long start = factory.getConfiguration().getStatistics().getDestroy().begin(); try { unsetCurrent(); clear(); close(); factory.getConfiguration().getStatistics().getDestroy().end(start); } catch (IOException e) { factory.getConfiguration().getStatistics().getDestroy().error(start); throw (IOException) e.fillInStackTrace(); } }
assert handler != null; long start = factory.getConfiguration().getStatistics().getFlush().begin(); if (isClosed()) { handler.complete(); factory.getConfiguration().getStatistics().getFlush().end(0, start);
private void deleteInactive(TrackedReference<SortedOplogReader> tr) throws IOException { tr.get().close(); if (tr.get().getFile().delete()) { if (logger.fineEnabled()) { logger.fine("Deleted inactive soplog " + tr.get().getFile()); } tracker.fileDeleted(tr.get().getFile()); factory.getConfiguration().getStatistics().incInactiveFiles(-1); } }
@Override public void run() { try { compactor.add(soplog); compactor.compact(false, null); unflushed.removeFirstOccurrence(buffer); // TODO need to invoke this while NOT holding write lock handler.complete(); factory.getConfiguration().getStatistics().getFlush().end(buffer.dataSize(), start); } catch (Exception e) { handleError(e, aborted); return; } } };