Source code
package io.netty.channel.uring; final class RingBuffer {
private final SubmissionQueue ioUringSubmissionQueue; private final CompletionQueue ioUringCompletionQueue; private final int features;
private boolean closed;
RingBuffer(SubmissionQueue ioUringSubmissionQueue, CompletionQueue ioUringCompletionQueue, int features) { this.ioUringSubmissionQueue = ioUringSubmissionQueue;
this.ioUringCompletionQueue = ioUringCompletionQueue; this.features = features;
}
/**
* Enable ring. This method must be called from the same method that will call {@link SubmissionQueue#submit()} and
* {@link SubmissionQueue#submitAndWait()}.
*/
void enable() {
// We create our ring in disabled mode and so need to enable it first.
Native.ioUringRegisterEnableRings(fd());
// Now also register the ring filedescriptor itself. This needs to happen in the same thread
// that will also call the io_uring_enter(...)
ioUringSubmissionQueue.tryRegisterRingFd();
}
int fd() {
return ioUringCompletionQueue.ringFd;
} int features() {
return features;
} SubmissionQueue ioUringSubmissionQueue() { return this.ioUringSubmissionQueue; } CompletionQueue ioUringCompletionQueue() { return this.ioUringCompletionQueue;
}
void close() {
if (closed) { return;
}
closed = true; ioUringSubmissionQueue.close(); ioUringCompletionQueue.close(); Native.ioUringExit(
ioUringSubmissionQueue.submissionQueueArrayAddress(),
ioUringSubmissionQueue.ringEntries,
ioUringSubmissionQueue.ringAddress, ioUringSubmissionQueue.ringSize,
ioUringCompletionQueue.ringAddress,
ioUringCompletionQueue.ringSize,
ioUringSubmissionQueue.ringFd, ioUringSubmissionQueue.enterRingFd);
}
}
Run 1
The code is difficult to read due to poor structure and formatting. Multiple statements are crammed onto single lines, making it hard to follow the logical flow. The class has no vertical separation between fields and methods, and some methods like `close()` mix conditionals, assignments, and method calls on one line. The `RingBuffer` constructor places multiple assignments on the same line, reducing clarity. Action granularity is poor—several operations occur per line, violating the one-action-per-line guideline. Nesting is minimal, which is positive, but the lack of line breaks undermines readability. Intent is partially discernible from comments, but the dense formatting obscures the code's purpose. Reading flow is disorganized because related statements are not grouped visually. Overall, the code needs reformatting with consistent line breaks, better spacing, and separation of concerns to improve readability.
Run 2
The code suffers from extremely poor formatting and organization. Multiple statements are crammed onto single lines, making it difficult to follow the logical flow. The constructor and methods like fd(), features(), and the accessor methods are all collapsed into dense one-liners. Intent is somewhat clear - it is a Netty ring buffer wrapper - but the presentation obscures it. Nesting is minimal, which helps, but action granularity is violated severely, as many actions occur per line. Reading flow is unnatural because the eye must parse packed statements. Code length could be reasonable if properly formatted, but the compression hurts readability. Overall, the logical structure exists but is buried under bad layout, so the score is low.
Run 3
The code has several readability issues. Multiple statements are crammed onto single lines (e.g., field declarations, constructor body, getter methods, close method), violating the 'one action per line' principle. The class mixes field declarations, constructor, and methods without clear visual separation. The close method combines multiple operations on one line, making it hard to follow. While the enable method is relatively clear due to its comments, the overall structure feels compressed and disorganized. The code would benefit from proper line breaks, spacing between methods, and consistent formatting. The intent is somewhat clear from method names, but the presentation significantly hampers readability.
Run 1
Code Structure: Fields, constructor, accessors, initialization, and cleanup are logically grouped, but compressed formatting blurs their boundaries. Nesting: Minimal nesting and an early return keep control flow simple. Clarity of intent: Descriptive names and comments clarify ring setup and cleanup, though the native exit call requires domain knowledge. Code length: Appropriately short, with little unnecessary code; excessive compression reduces readability rather than improving concision. Action granularity: Multiple declarations, assignments, method definitions, and cleanup operations share lines, making individual actions harder to scan. Reading flow: The overall sequence is natural, but inconsistent line breaks and methods beginning immediately after closing braces interrupt reading.
Run 2
Code Structure: The class logically groups state, initialization, accessors, and cleanup, but compressed formatting obscures method boundaries. Nesting: Minimal nesting and an early return keep control flow simple. Clarity of intent: Descriptive queue names and comments explain ring enabling; cleanup intent is clear, though the long positional native call requires careful reading. Code length: Appropriately concise for a small wrapper, but excessive line compression sacrifices readability. Action granularity: Multiple field declarations, assignments, method definitions, and cleanup calls share lines, making individual actions harder to distinguish. Reading flow: The overall sequence is natural, but inconsistent line breaks, inline braces, and crowded accessors interrupt scanning.
Run 3
Code Structure: Fields, constructor, accessors, and lifecycle methods are logically organized, but compressed formatting obscures their boundaries. Nesting: Minimal nesting and an early return keep control flow simple. Clarity of intent: Descriptive names and comments explain ring initialization and cleanup, although the enable() documentation says 'same method' while its comment says 'same thread,' creating ambiguity. Code length: The class is concise with little unnecessary code, though long identifiers and the lengthy native call require careful scanning. Action granularity: Multiple declarations, assignments, method definitions, and cleanup calls share lines, reducing readability. Reading flow: The overall sequence is natural, but inconsistent line breaks, crowded braces, and uneven argument formatting interrupt scanning.