protected DirectByteBuffer(MemoryBlock block, int capacity, int offset, boolean isReadOnly, MapMode mapMode) { super(block, capacity, mapMode); long baseSize = block.getSize(); if (baseSize >= 0 && (capacity + offset) > baseSize) { throw new IllegalArgumentException("capacity + offset > baseSize"); } this.effectiveDirectAddress = block.toLong() + offset; this.offset = offset; this.isReadOnly = isReadOnly; }
/** * Attempts to load every page of this buffer into RAM. See {@link #isLoaded}. * @return this buffer. */ public final MappedByteBuffer load() { checkIsMapped(); try { Libcore.os.mlock(block.toLong(), block.getSize()); Libcore.os.munlock(block.toLong(), block.getSize()); } catch (ErrnoException ignored) { } return this; }
/** * Flushes changes made to the in-memory buffer back to the mapped file. * Unless you call this, changes may not be written back until the finalizer * runs. This method waits for the write to complete before returning. * * @return this buffer. */ public final MappedByteBuffer force() { checkIsMapped(); if (mapMode == MapMode.READ_WRITE) { try { Libcore.os.msync(block.toLong(), block.getSize(), MS_SYNC); } catch (ErrnoException errnoException) { // The RI doesn't throw, presumably on the assumption that you can't get into // a state where msync(2) could return an error. throw new AssertionError(errnoException); } } return this; }
/** * Returns true if there is a high probability that every page of this buffer is currently * loaded in RAM, meaning that accesses will not cause a page fault. It is impossible to give * a strong guarantee since this is only a snapshot of a dynamic situation. */ public final boolean isLoaded() { checkIsMapped(); long address = block.toLong(); long size = block.getSize(); if (size == 0) { return true; } try { int pageSize = (int) Libcore.os.sysconf(_SC_PAGE_SIZE); int pageOffset = (int) (address % pageSize); address -= pageOffset; size += pageOffset; int pageCount = (int) ((size + pageSize - 1) / pageSize); byte[] vector = new byte[pageCount]; Libcore.os.mincore(address, size, vector); for (int i = 0; i < vector.length; ++i) { if ((vector[i] & 1) != 1) { return false; } } return true; } catch (ErrnoException errnoException) { return false; } }
protected DirectByteBuffer(MemoryBlock block, int capacity, int offset, boolean isReadOnly, MapMode mapMode) { super(block, capacity, mapMode); long baseSize = block.getSize(); if (baseSize >= 0 && (capacity + offset) > baseSize) { throw new IllegalArgumentException("capacity + offset > baseSize"); } this.effectiveDirectAddress = block.toLong() + offset; this.offset = offset; this.isReadOnly = isReadOnly; }
protected DirectByteBuffer(MemoryBlock block, int capacity, int offset, boolean isReadOnly, MapMode mapMode) { super(block, capacity, mapMode); long baseSize = block.getSize(); if (baseSize >= 0 && (capacity + offset) > baseSize) { throw new IllegalArgumentException("capacity + offset > baseSize"); } this.effectiveDirectAddress = block.toLong() + offset; this.offset = offset; this.isReadOnly = isReadOnly; }
protected DirectByteBuffer(MemoryBlock block, int capacity, int offset, boolean isReadOnly, MapMode mapMode) { super(block, capacity, mapMode); long baseSize = block.getSize(); if (baseSize >= 0 && (capacity + offset) > baseSize) { throw new IllegalArgumentException("capacity + offset > baseSize"); } this.effectiveDirectAddress = block.toLong() + offset; this.offset = offset; this.isReadOnly = isReadOnly; }
protected DirectByteBuffer(MemoryBlock block, int capacity, int offset, boolean isReadOnly, MapMode mapMode) { super(block, capacity, mapMode); long baseSize = block.getSize(); if (baseSize >= 0 && (capacity + offset) > baseSize) { throw new IllegalArgumentException("capacity + offset > baseSize"); } this.effectiveDirectAddress = block.toLong() + offset; this.offset = offset; this.isReadOnly = isReadOnly; }
protected DirectByteBuffer(MemoryBlock block, int capacity, int offset, boolean isReadOnly, MapMode mapMode) { super(block, capacity, mapMode); long baseSize = block.getSize(); if (baseSize >= 0 && (capacity + offset) > baseSize) { throw new IllegalArgumentException("capacity + offset > baseSize"); } this.effectiveDirectAddress = block.toLong() + offset; this.offset = offset; this.isReadOnly = isReadOnly; }
protected DirectByteBuffer(MemoryBlock block, int capacity, int offset, boolean isReadOnly, MapMode mapMode) { super(block, capacity, mapMode); long baseSize = block.getSize(); if (baseSize >= 0 && (capacity + offset) > baseSize) { throw new IllegalArgumentException("capacity + offset > baseSize"); } this.effectiveDirectAddress = block.toLong() + offset; this.offset = offset; this.isReadOnly = isReadOnly; }
/** * Attempts to load every page of this buffer into RAM. See {@link #isLoaded}. * @return this buffer. */ public final MappedByteBuffer load() { checkIsMapped(); try { Libcore.os.mlock(block.toLong(), block.getSize()); Libcore.os.munlock(block.toLong(), block.getSize()); } catch (ErrnoException ignored) { } return this; }
/** * Attempts to load every page of this buffer into RAM. See {@link #isLoaded}. * @return this buffer. */ public final MappedByteBuffer load() { checkIsMapped(); try { Libcore.os.mlock(block.toLong(), block.getSize()); Libcore.os.munlock(block.toLong(), block.getSize()); } catch (ErrnoException ignored) { } return this; }
/** * Attempts to load every page of this buffer into RAM. See {@link #isLoaded}. * @return this buffer. */ public final MappedByteBuffer load() { checkIsMapped(); try { Libcore.os.mlock(block.toLong(), block.getSize()); Libcore.os.munlock(block.toLong(), block.getSize()); } catch (ErrnoException ignored) { } return this; }
/** * Attempts to load every page of this buffer into RAM. See {@link #isLoaded}. * @return this buffer. */ public final MappedByteBuffer load() { checkIsMapped(); try { Libcore.os.mlock(block.toLong(), block.getSize()); Libcore.os.munlock(block.toLong(), block.getSize()); } catch (ErrnoException ignored) { } return this; }
/** * Attempts to load every page of this buffer into RAM. See {@link #isLoaded}. * @return this buffer. */ public final MappedByteBuffer load() { checkIsMapped(); try { Libcore.os.mlock(block.toLong(), block.getSize()); Libcore.os.munlock(block.toLong(), block.getSize()); } catch (ErrnoException ignored) { } return this; }
/** * Attempts to load every page of this buffer into RAM. See {@link #isLoaded}. * @return this buffer. */ public final MappedByteBuffer load() { checkIsMapped(); try { Libcore.os.mlock(block.toLong(), block.getSize()); Libcore.os.munlock(block.toLong(), block.getSize()); } catch (ErrnoException ignored) { } return this; }
/** * Flushes changes made to the in-memory buffer back to the mapped file. * Unless you call this, changes may not be written back until the finalizer * runs. This method waits for the write to complete before returning. * * @return this buffer. */ public final MappedByteBuffer force() { checkIsMapped(); if (mapMode == MapMode.READ_WRITE) { try { Libcore.os.msync(block.toLong(), block.getSize(), MS_SYNC); } catch (ErrnoException errnoException) { // The RI doesn't throw, presumably on the assumption that you can't get into // a state where msync(2) could return an error. throw new AssertionError(errnoException); } } return this; }
/** * Flushes changes made to the in-memory buffer back to the mapped file. * Unless you call this, changes may not be written back until the finalizer * runs. This method waits for the write to complete before returning. * * @return this buffer. */ public final MappedByteBuffer force() { checkIsMapped(); if (mapMode == MapMode.READ_WRITE) { try { Libcore.os.msync(block.toLong(), block.getSize(), MS_SYNC); } catch (ErrnoException errnoException) { // The RI doesn't throw, presumably on the assumption that you can't get into // a state where msync(2) could return an error. throw new AssertionError(errnoException); } } return this; }
/** * Flushes changes made to the in-memory buffer back to the mapped file. * Unless you call this, changes may not be written back until the finalizer * runs. This method waits for the write to complete before returning. * * @return this buffer. */ public final MappedByteBuffer force() { checkIsMapped(); if (mapMode == MapMode.READ_WRITE) { try { Libcore.os.msync(block.toLong(), block.getSize(), MS_SYNC); } catch (ErrnoException errnoException) { // The RI doesn't throw, presumably on the assumption that you can't get into // a state where msync(2) could return an error. throw new AssertionError(errnoException); } } return this; }
/** * Flushes changes made to the in-memory buffer back to the mapped file. * Unless you call this, changes may not be written back until the finalizer * runs. This method waits for the write to complete before returning. * * @return this buffer. */ public final MappedByteBuffer force() { checkIsMapped(); if (mapMode == MapMode.READ_WRITE) { try { Libcore.os.msync(block.toLong(), block.getSize(), MS_SYNC); } catch (ErrnoException errnoException) { // The RI doesn't throw, presumably on the assumption that you can't get into // a state where msync(2) could return an error. throw new AssertionError(errnoException); } } return this; }