为什么我的基于模数的缓冲区比写的LinkedList慢？

Question

Background:

I'm trying to find the fastest possible (regarding write speed) key-value store to back an application that I have. The capacity of the store is maximum 15k key-value pairs. I've tried the following:

• LinkedHashMap , overriding removeEldestEntry to remove the eldest entry when the number of items in the map has reached 15000:

   new LinkedHashMap<Long, Object>(10000, 0.75F, false) { private static final long serialVersionUID = 1L; protected boolean removeEldestEntry(Map.Entry<Long, Object> eldest) { return size() > 15000; } }; 

• LinkedList , removing the first element if the size is already max (to get element with key id , the list is searched sequentially):

   new LinkedList<Object>() { private static final long serialVersionUID = 1L; public boolean add(Object o) { while (size() >= 15000) remove(0); return super.add(o); } }; 

• ModBuffer , the fastest possible (in theory) store I could think of (as in the list, to find element with key id , the whole buffer is searched sequentially):

   public class ModBuffer<T> { private T[] buffer = (T[]) new Object[15000]; public add(Long key, T value) { int pos = (int) (key % (long) buffer.length); buffer[pos] = value; } 

Intuitively, it seems like the ModBuffer would be the fastest one to write. But it turns out that the LinkedList is the fastest one. I'm using these buffers to implement a network protocol. With the LinkedList, I manage to reach 850Mbps. With the ModBuffer, it doesn't go beyond 700Mbps.

Question:

Why is the LinkedList so much faster to write than the simple ModBuffer? Is it optimized somehow, since it's part of the standard Java Collections? I can't think of any other reason for that... This is quite intriguing.

Answer 1

I suspect it's the modulus operator that's slower than adding to the linked list. In the ModBuffer implementation, a modulus is always executed. On the other hand, the LinkedList implementation calls a O(1) size method then calls another O(1) add method to insert at the beginning of list. If the number of entries does not exceed the maximum of 15k, you can add to that a improvement due to branch prediction in the while condition:

while (size() >= 15000)
     remove(0);

which would return false most of the time if you're adding elements in a loop and the number of entries does not reach the maximum.

For a large number of entries, however, this should not be the case -- the modulus-buffer should be more efficient.

Answer 2

It sounds like you were talking about the speed of the protocol, not the write speed to your cache. If there is a retransmission portion of your protocol, then perhaps the lower speed is caused by the strange and probably poor retention characteristics of the ModBuffer. Where as your LinkedList-based solutions discard the oldest records in the queue, your ModBuffer solution effectively discards random records; it discards records whenever there is a cache collision. Perhaps the need to retransmit those lost records is what is slowing you down.