Re: Atomic integer array class question
On Jan 9, 6:56 pm, Patricia Shanahan <p...@acm.org> wrote:
Spin waiting, especially spin waiting that has no delay and includes
access to a volatile variable, can be very expensive in terms of load on
the processor-memory interconnect.
So, add a Thread.sleep(1); or something ?
I'm still unclear what is intent, and what is infrastructure to do with
how you are trying to implement the intent. Could you provide a
description of what you want to have happen?
It's basically a store that has 3 parts per element
id (short)
data (short)
auxData (Object)
However, for most places (say 95%+), it is (0, 0, null), so it really
only needs only a short.
I am planning to have a short array for the main store. That will be
based on AtomicInteger and storing two shorts per index (it uses
compareAndSet to allow one short out of the int to be updated
atomically).
I also plan to reserve some of the short values as indexes into a
second array.
This array will store AtomicInteger (sequence number), int (both
shorts), Object. (The AtomicInteger is one from an
AtomicIntegerArray)
Then the set and gets will be something like
set(int index, short id) {
if (isReserved(index)) {
set(index, id, 0, null);
} else {
setRaw(index, id);
}
}
setRaw(int index, short id) {
short oldId = shortArray.getAndSet(index, id);
if (isReserved(oldId)) {
// oldId is actually an index into the aux store
auxStore.remove(oldId);
}
}
set(int index, short id, short data, Object o) {
int newId = auxStore.add(id, data, o);
setRaw(index, newId);
}
Gets, which pull a non-reserved short, don't have/need the sequence
numbers.
However, for complex read operations on the object, the process would
read the sequence number before and after the read to make sure it is
stable. Also, the sequence number has a reserved "UNSTABLE" value
when updates are actually happening. As long as the sequence number
is not UNSTABLE before or after the read and the two numbers are
equal, then it was a safe read.
The main reason for the question was that I was wondering if having
writes to the store using a write lock would slow things down.
However, using a sequence number system works just as well and means
that I can use AtomicIntegerArray directly anyway.