Its highly unlikely we need the 8 KiB surrounding the pack file header
or footer immediately after opening the pack file. Reading those as
full blocks and registering them in the WindowCache is probably just
churning garbage through the cache. Instead, read the header with a
single 12 byte read, and the footer with a single 20 byte read, and
bypass the cache altogether.
This nicely removes a deadlock condition we had previously where the
WindowCache was recursively calling itself during the pack file open,
and got stuck on its own locks.
Signed-off-by: Shawn O. Pearce <spearce@xxxxxxxxxxx>
---
This I think can be applied as-is.
We could quibble about whether or not caching the header and footer
window is worthwhile during the pack open event. But really I
wrote this to remove a deadlock in the next patch. Its just soooo
much simpler to not make PackFile rely on WindowCache.
.../src/org/spearce/jgit/lib/PackFile.java | 5 +--
org.spearce.jgit/src/org/spearce/jgit/util/NB.java | 32 ++++++++++++++++++++
2 files changed, 34 insertions(+), 3 deletions(-)
diff --git a/org.spearce.jgit/src/org/spearce/jgit/lib/PackFile.java b/org.spearce.jgit/src/org/spearce/jgit/lib/PackFile.java
index 813ebc7..360442f 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/lib/PackFile.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/lib/PackFile.java
@@ -389,10 +389,9 @@ void allocWindow(final WindowCursor curs, final int windowId,
private void onOpenPack() throws IOException {
final PackIndex idx = idx();
- final WindowCursor curs = new WindowCursor();
final byte[] buf = new byte[20];
- readFully(0, buf, 0, 12, curs);
+ NB.readFully(fd.getChannel(), 0, buf, 0, 12);
if (RawParseUtils.match(buf, 0, Constants.PACK_SIGNATURE) != 4)
throw new IOException("Not a PACK file.");
final long vers = NB.decodeUInt32(buf, 4);
@@ -406,7 +405,7 @@ private void onOpenPack() throws IOException {
+ " index " + idx.getObjectCount()
+ ": " + getPackFile());
- readFully(length - 20, buf, 0, 20, curs);
+ NB.readFully(fd.getChannel(), length - 20, buf, 0, 20);
if (!Arrays.equals(buf, idx.packChecksum))
throw new PackMismatchException("Pack checksum mismatch:"
+ " pack " + ObjectId.fromRaw(buf).name()
diff --git a/org.spearce.jgit/src/org/spearce/jgit/util/NB.java b/org.spearce.jgit/src/org/spearce/jgit/util/NB.java
index c65c6fa..4a9c9b9 100644
--- a/org.spearce.jgit/src/org/spearce/jgit/util/NB.java
+++ b/org.spearce.jgit/src/org/spearce/jgit/util/NB.java
@@ -40,6 +40,8 @@
import java.io.EOFException;
import java.io.IOException;
import java.io.InputStream;
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
/** Conversion utilities for network byte order handling. */
public final class NB {
@@ -71,6 +73,36 @@ public static void readFully(final InputStream fd, final byte[] dst,
}
/**
+ * Read the entire byte array into memory, or throw an exception.
+ *
+ * @param fd
+ * file to read the data from.
+ * @param pos
+ * position to read from the file at.
+ * @param dst
+ * buffer that must be fully populated, [off, off+len).
+ * @param off
+ * position within the buffer to start writing to.
+ * @param len
+ * number of bytes that must be read.
+ * @throws EOFException
+ * the stream ended before dst was fully populated.
+ * @throws IOException
+ * there was an error reading from the stream.
+ */
+ public static void readFully(final FileChannel fd, long pos,
+ final byte[] dst, int off, int len) throws IOException {
+ while (len > 0) {
+ final int r = fd.read(ByteBuffer.wrap(dst, off, len), pos);
+ if (r <= 0)
+ throw new EOFException("Short read of block.");
+ pos += r;
+ off += r;
+ len -= r;
+ }
+ }
+
+ /**
* Skip an entire region of an input stream.
* <p>
* The input stream's position is moved forward by the number of requested
--
1.6.3.rc1.205.g37f8
--
To unsubscribe from this list: send the line "unsubscribe git" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html