* A buffer may be used to send one or more messages at the same time in * multiple threads. If a buffer is being used to send a message or messages, * the buffer must not be used to receive a message at the same time. *
* A buffer may be used to receive one message at a time. If a buffer is being * used to receive a message, the buffer must not be used to receive another * message in a different thread, and the buffer must not be used to send a * message or messages. *
* A buffer is a conduit for retrieving and storing data in some underlying data * structure. If the underlying data structure is multiple thread safe, then one * thread can be retrieving or storing data via the buffer at the same time as * other threads are accessing the data structure. If the underlying data * structure is not multiple thread safe, then other threads must not access the * data structure while one thread is retrieving or storing data via the buffer. * * @author Alan Kaminsky * @version 27-Jun-2007 */ class Vector2DArrayDoubleBuf extends DoubleBuf { // Hidden data members. Vector2D[] myArray; Range myRange; int myArrayOffset; int myStride; // Hidden constructors. /** * Construct a new vector array buffer. * * @param theArray Array. * @param theRange Range of elements to include. * * @exception NullPointerException * (unchecked exception) Thrown if any argument is null. * @exception IndexOutOfBoundsException * (unchecked exception) Thrown if theArray's allocation does * not include theRange. */ public Vector2DArrayDoubleBuf (Vector2D[] theArray, Range theRange) { super (theRange.length() * 2); if (0 > theRange.lb() || theRange.ub() >= theArray.length) { throw new IndexOutOfBoundsException ("Vector2DArrayDoubleBuf(): theArray index range = 0.." + (theArray.length-1) + "1, theRange = " + theRange); } myArray = theArray; myRange = theRange; myArrayOffset = theRange.lb(); myStride = theRange.stride(); } // Exported operations. /** * Obtain the given item from this buffer. *
* The get() method must not block the calling thread; if it does, * all message I/O in MP will be blocked. * * @param i Item index in the range 0 .. length()-1. * * @return Item at index i. */ public double get (int i) { int index = myArrayOffset + (i >>> 1) * myStride; if ((i & 1) == 0) { return myArray[index].x; } else { return myArray[index].y; } } /** * Store the given item in this buffer. *
* The put() method must not block the calling thread; if it does, * all message I/O in MP will be blocked. * * @param i Item index in the range 0 .. length()-1. * @param item Item to be stored at index i. */ public void put (int i, double item) { int index = myArrayOffset + (i >>> 1) * myStride; if ((i & 1) == 0) { myArray[index].x = item; } else { myArray[index].y = item; } } /** * Copy items from the given buffer to this buffer. The number of items * copied is this buffer's length or theSrc's length, whichever is * smaller. * * @param theSrc Source of items to copy into this buffer. * * @exception ClassCastException * (unchecked exception) Thrown if theSrc's item data type is * not the same as this buffer's item data type. */ public void copy (Buf theSrc) { if (theSrc == this) { } else if (theSrc instanceof Vector2DArrayDoubleBuf) { Vector2DArrayDoubleBuf src = (Vector2DArrayDoubleBuf) theSrc; if (src.myArray != this.myArray || src.myArrayOffset > this.myArrayOffset) { int n = Math.min (src.myLength/2, this.myLength/2); int srcindex = src.myArrayOffset; int thisindex = this.myArrayOffset; for (int i = 0; i < n; ++ i) { this.myArray[thisindex].assign (src.myArray[srcindex]); srcindex += src.myStride; thisindex += this.myStride; } } else if (src.myArrayOffset < this.myArrayOffset) { int n = Math.min (src.myLength/2, this.myLength/2); int srcindex = src.myArrayOffset + (n-1) * src.myStride; int thisindex = this.myArrayOffset + (n-1) * this.myStride; for (int i = n-1; i >= 0; -- i) { this.myArray[thisindex].assign (src.myArray[srcindex]); srcindex -= src.myStride; thisindex -= this.myStride; } } } else { DoubleBuf.defaultCopy ((DoubleBuf) theSrc, this); } } /** * Create a buffer for performing parallel reduction using the given binary * operation. The results of the reduction are placed into this buffer. *
* Note: Class Vector2DArrayBuf does not support reduction. The * getReductionBuf() method throws an * UnsupportedOperationException. * * @param op Binary operation. * * @exception ClassCastException * (unchecked exception) Thrown if this buffer's element data type and * the given binary operation's argument data type are not the same. */ public Buf getReductionBuf (Op op) { throw new UnsupportedOperationException(); } // Hidden operations. /** * Send as many items as possible from this buffer to the given byte * buffer. *
* The sendItems() method must not block the calling thread; if it * does, all message I/O in MP will be blocked. * * @param i Index of first item to send, in the range 0 .. * length-1. * @param buffer Byte buffer. * * @return Number of items sent. */ protected int sendItems (int i, ByteBuffer buffer) { int index = myArrayOffset + (i >>> 1) * myStride; int off = i; while (off < myLength && buffer.remaining() >= 16) { Vector2D item = myArray[index]; buffer.putDouble (item.x); buffer.putDouble (item.y); index += myStride; off += 2; } return off - i; } /** * Receive as many items as possible from the given byte buffer to this * buffer. *
* The receiveItems() method must not block the calling thread; if * it does, all message I/O in MP will be blocked. * * @param i Index of first item to receive, in the range 0 .. * length-1. * @param num Maximum number of items to receive. * @param buffer Byte buffer. * * @return Number of items received. */ protected int receiveItems (int i, int num, ByteBuffer buffer) { int index = myArrayOffset + (i >>> 1) * myStride; int off = i; int max = Math.min (i + num, myLength); while (off < max && buffer.remaining() >= 16) { Vector2D item = myArray[index]; item.x = buffer.getDouble(); item.y = buffer.getDouble(); index += myStride; off += 2; } return off - i; } }