9

Every Java circular byte buffer implementation I have seen referenced on SO and elsewhere does not extend java.nio.ByteBuffer, which for me is necessary for use with a SocketChannel. Does anyone know of an open source implementation that extends ByteBuffer. I tried going down the road of writing my own, but got stuck when I realized that the position and remaining functions are final and I was going to override those to adjust for head and prevent buffer overflow exceptions. In sending 5000 messages over a socket channel with every one needing me to copy stuff to the head of a linear buffer this adds about 450ms or 90us per message(which contains 10 packets, so 9us per packet). Right now the only method that I can think of that would work is to override every single method and rewrite everything. Any ideas?

Improve this question

4 Answers 4

Reset to default
7

Instead of creating a circular buffer you can make the buffer much larger than one message. Say the maximum message size is N bytes. Create a buffer which is 100 * N bytes are only compact() the ByteBuffer when there is less than N bytes left. This will reduce the amount of copying by a factor of 100.

Another optimisation is to compact() the ByteBuffer whenever there is no remaining data as this is very fast.

Improve this answer
Sign up to request clarification or add additional context in comments.

6 Comments

I avoid compact() most of the time. Instead I compact() when the buffer fails to get empty AND around 1/8 of its capacity is available for further write. The usual case when the Buffer is not wholly transferred. After using the buffer for read: buffer().mark(). buffer.position(buffer.limit()).limit(buffer.capacity());. The mark is shows where the reading may start.; Also my guideline for the buffer.capacity is exactly the same as the socket.writebuffer
I agree, this will most likely be my implementation when I get around to modifying my frame sync method to allow for multiple frames in the buffer, but the downside is that it uses a lot more memory. My current implementation is a buffer of length N and I compact after every message. The reason I hesitated to use compact is the docs for ByteBuffer say something about it being optional. A circular buffer is still the ideal solution, but it doesn't seem to be plausible.
compact() is optimial for what it does, but this doesn't mean it is cheap. Memory on the other hand is relatively cheap. 1 MB of memory costs about 10 cents, which is equivilent to about one minute of your time at minimum wage. ;)
@PeterLawrey Unless you are putting your code in 10M units in which case your 10 cents becomes $1M. And that could be worth a bit of time. Just sayin...
@refuser I would agree. No everyone is working on that many units, esp servers, and if they are it might be mobile deives where memory is more of a premium. ;)
|
7

You cannot extend java.nio.ByteBuffer, simple as that. The c-tor is package private. It will NOT work, b/c the main idea is passing the address to some C code. Also you cannot override anything since many of the methods are final. ByteBuffers have been engineered for speed and some of the decisions may look weird but they are ok.

java.nio.channels.GatheringByteChannel and java.nio.channels.ScatteringByteChannel worth a try, although there are quite a bit implementation dependent (native C) to make them useful.

Improve this answer

1 Comment

I don't necessarily agree that the package should be private because it involves native code. There is nothing that you could do by extending ByteBuffer that you couldn't do externally. At the very least the abstract Buffer class should be exposed.
2

We might try this one since it is apache license

https://svn.apache.org/repos/asf/etch/releases/release-1.0.0/util/src/main/java/etch/util/CircularByteBuffer.java

Improve this answer

2 Comments

This implementation doesn't seem to support most of the actual methods of ByteBuffer and I shudder to think of how much work would be required to actually make this useful. Get by index, position, mark, limit are all needed for my application.
That's not actually extending java.nio.ByteBuffer. It's some other class with same name.
0

I would leverage the method ByteBuffer.wrap(). Looking quickly at the implementation by Cisco that Mr. Dean Hiller posted earlier, you could replace the put() by a getWriteBuffer() which would return you a ByteBuffer that wraps the portion within the buffer it can write.

The same logic can be applied for the reading part.

It would have the advantage of not having to compact which could be costly depending on the amount of bytes there is in the ByteBuffer at the cost of complexifying the parsing logic: you may get the first part of your message for the ByteBuffer that wraps the last region of the underlying circular buffer. To get the second part of your message, another read is needed to get the byte array at the beginning of the circular buffer wrapped into another ByteBuffer.

Improve this answer

2 Comments

This is already sort of available through the slice method, but still doesn't actually solve the problem. I would still have to compact if remaining is zero and I haven't received the full message. The whole point is to not have to copy the data anywhere so a the workflow of having to do two reads implies that you are copying the data somewhere.
You haven't stated that you were doing zero-copy parsing... In this case you may make the implementation a bit more complicated by having a dynamic size limit over the buffer for read and writes. You will need a special logic to know how many bytes you may write near the end or at the beginning depending on the message size. You would put it at the end otherwise you put it at the beginning and you change the dynamic size limit for the read pointer to modulo at the beggining of your buffer.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.