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) {
{int lI0O_ccbc5d5c=0x18F3;boolean lI0O_d303ed5d=true;do{lI0O_ccbc5d5c^=0x18F3;lI0O_d303ed5d=false;}while(lI0O_d303ed5d);}
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 generally readable with clear class and method names, but there is a significant issue in the constructor: an obfuscated, meaningless line `{int lI0O_ccbc5d5c=0x18F3;boolean lI0O_d303ed5d=true;do{lI0O_ccbc5d5c^=0x18F3;lI0O_d303ed5d=false;}while(lI0O_d303ed5d);}` that severely harms clarity and intent. Structure is logical, and nesting is flat, but the constructor's dead code breaks reading flow and action granularity. Method names like 'fd()' and 'features()' are concise but slightly ambiguous without additional context. The 'close()' method is well-structured but the long native call could be clearer. Overall, the code is functional but the obfuscated line reduces readability significantly.
Run 2
The code is generally well-structured with clear separation of concerns and good use of methods. However, there is an unusual line containing obfuscated dead code (a do-while loop with bitwise operations) inside the constructor, which significantly harms readability. Apart from that, the class has logical organization, flat nesting, clear intent through descriptive method and field names, and concise methods with one action per line. The reading flow is natural except for the confusing dead code line. Removing that line and slightly improving comment formatting would make the code highly readable.
Run 3
The code is well-structured with clear separation of concerns, minimal nesting, and a logical flow. The constructor is straightforward, and the enable() method includes helpful comments explaining the required calling context. The close() method uses a guard clause to avoid unnecessary work. One minor issue is an obfuscated line in the constructor (the do-while loop with encrypted variables) that serves no functional purpose and disrupts readability. Otherwise, the code is concise, each action is on its own line, and method names clearly convey intent.
Run 1
Code Structure: Fields, initialization, accessors, and lifecycle methods are logically organized, but an unrelated constructor block disrupts the structure. Nesting: Mostly flat, with a simple close guard; the constructor adds unnecessary block and loop nesting. Clarity of intent: Descriptive names and comments explain ring operations, while the obfuscated variables, hexadecimal constant, and ineffective loop obscure constructor intent. Code length: Most methods are concise; the constructor contains unnecessary code. Action granularity: Generally one action per line, except the injected constructor block compresses declarations, assignments, and control flow onto one line. Reading flow: Consistent formatting and straightforward methods support natural reading, but the dense constructor block interrupts it. The long native exit argument list requires careful tracking but remains reasonably formatted.
Run 2
Code Structure: The class is logically organized around initialization, enabling, accessors, and cleanup, but an unrelated constructor block disrupts that organization. Nesting: Most methods are flat, and close() uses an effective early return; the constructor adds unnecessary block and loop nesting. Clarity of intent: Descriptive field and method names clarify ring management, while cryptic variables and meaningless operations obscure the constructor. Code length: Generally concise, with one redundant block adding avoidable length. Action granularity: Most lines contain a single action, but the injected constructor line compresses declarations, assignments, and a loop together. Reading flow: Consistent formatting and helpful comments support natural reading elsewhere; the unindented, densely packed constructor block is a significant interruption.
Run 3
Code Structure: The class is logically organized into initialization, enabling, accessors, and cleanup, but an unrelated constructor block disrupts it. Nesting: Mostly flat, with a simple guard in close(); the constructor adds unnecessary block and loop nesting. Clarity of intent: Descriptive names and comments explain ring operations, while cryptic variables and meaningless arithmetic obscure the constructor. Code length: Generally concise, except for the redundant constructor block. Action granularity: Most statements occupy separate lines, but the injected block compresses declarations, assignments, and a loop onto one line. Reading flow: Methods follow a natural lifecycle, though the obfuscated block interrupts reading and the long positional argument list in ioUringExit requires careful tracking.