public void testAddWithWrapAround() {
Table<Integer> buf = new Table<Integer>(3, 10, 5);
for (int i = 6; i <= 15; i++) assert buf.add(i, i) : "addition of seqno " + i + " failed";
System.out.println("buf = " + buf);
for (int i = 0; i < 3; i++) {
Integer val = buf.remove(false);
System.out.println("removed " + val);
assert val != null;
}
System.out.println("buf = " + buf);
long low = buf.getLow();
buf.purge(8);
System.out.println("buf = " + buf);
assert buf.getLow() == 8;
for (long i = low; i <= 8; i++)
assert buf._get(i) == null : "message with seqno=" + i + " is not null";
for (int i = 16; i <= 18; i++) assert buf.add(i, i);
System.out.println("buf = " + buf);
while (buf.remove(false) != null) ;
System.out.println("buf = " + buf);
assert buf.isEmpty();
assert buf.getNumMissing() == 0;
low = buf.getLow();
buf.purge(18);
assert buf.getLow() == 18;
for (long i = low; i <= 18; i++)
assert buf._get(i) == null : "message with seqno=" + i + " is not null";
}
public void testGetMissing5() {
Table<Integer> buf = new Table<Integer>(3, 10, 0);
buf.add(1, 1);
SeqnoList missing = buf.getMissing();
System.out.println("missing = " + missing);
assert missing == null && buf.getNumMissing() == 0;
buf = new Table<Integer>(3, 10, 0);
buf.add(10, 10);
missing = buf.getMissing();
System.out.println("missing = " + missing);
assert buf.getNumMissing() == missing.size();
buf = new Table<Integer>(3, 10, 0);
buf.add(5, 5);
missing = buf.getMissing();
System.out.println("missing = " + missing);
assert buf.getNumMissing() == missing.size();
buf = new Table<Integer>(3, 10, 0);
buf.add(5, 5);
buf.add(7, 7);
missing = buf.getMissing();
System.out.println("missing = " + missing);
assert missing.size() == 5;
assert buf.getNumMissing() == missing.size();
}
public void testPurgeForce() {
Table<Integer> table = new Table<Integer>(3, 10, 0);
for (int i = 1; i <= 30; i++) table.add(i, i);
System.out.println("table = " + table);
table.purge(15, true);
System.out.println("table = " + table);
assertIndices(table, 15, 15, 30);
for (int i = 1; i <= 15; i++) assert table._get(i) == null;
for (int i = 16; i <= 30; i++) assert table._get(i) != null;
assert table.get(5) == null && table.get(25) != null;
table.purge(30, true);
System.out.println("table = " + table);
assertIndices(table, 30, 30, 30);
assert table.isEmpty();
for (int i = 1; i <= 30; i++) assert table._get(i) == null;
for (int i = 31; i <= 40; i++) table.add(i, i);
System.out.println("table = " + table);
assert table.size() == 10;
assertIndices(table, 30, 30, 40);
table.purge(50, true);
System.out.println("table = " + table);
assert table.isEmpty();
assertIndices(table, 40, 40, 40);
}
public void testAddMissing() {
Table<Integer> buf = new Table<Integer>(3, 10, 0);
for (int i : Arrays.asList(1, 2, 4, 5, 6)) buf.add(i, i);
System.out.println("buf = " + buf);
assert buf.size() == 5 && buf.getNumMissing() == 1;
Integer num = buf.remove();
assert num == 1;
num = buf.remove();
assert num == 2;
num = buf.remove();
assert num == null;
buf.add(3, 3);
System.out.println("buf = " + buf);
assert buf.size() == 4 && buf.getNumMissing() == 0;
for (int i = 3; i <= 6; i++) {
num = buf.remove();
System.out.println("buf = " + buf);
assert num == i;
}
num = buf.remove();
assert num == null;
}
public void testAddWithInvalidSeqno() {
Table<Integer> buf = new Table<Integer>(3, 10, 20);
boolean success = buf.add(10, 0);
assert !success;
success = buf.add(20, 0);
assert !success;
assert buf.isEmpty();
}
public static void testMove3() {
Table<Integer> table = new Table<Integer>(3, 10, 0);
for (int i = 1; i < 30; i++) table.add(i, i);
table.removeMany(true, 23);
System.out.println("table = " + table);
table.add(30, 30); // triggers a resize() --> move()
for (int i = 1; i <= 23; i++) assert table._get(i) == null;
for (int i = 24; i < 30; i++) assert table._get(i) != null;
}
public static void testGetNullMessages() {
Table<Integer> table = new Table<Integer>(3, 10, 0);
table.add(1, 1);
table.add(100, 100);
System.out.println("table = " + table);
int num_null_elements = table.getNumMissing();
assert num_null_elements == 98; // [2 .. 99]
table.add(50, 50);
System.out.println("table = " + table);
assert table.size() == 3;
assert table.getNumMissing() == 97;
}
public void testGetHighestDeliverable() {
Table<Integer> table = new Table<Integer>(3, 10, 0);
System.out.println("table = " + table);
long highest_deliverable = table.getHighestDeliverable(), hd = table.getHighestDelivered();
System.out.println("highest delivered=" + hd + ", highest deliverable=" + highest_deliverable);
assert hd == 0;
assert highest_deliverable == 0;
for (int num : Arrays.asList(1, 2, 3, 4, 5, 6, 8)) table.add(num, num);
System.out.println("table = " + table);
highest_deliverable = table.getHighestDeliverable();
hd = table.getHighestDelivered();
System.out.println("highest delivered=" + hd + ", highest deliverable=" + highest_deliverable);
assert hd == 0;
assert highest_deliverable == 6;
table.removeMany(true, 4);
System.out.println("table = " + table);
highest_deliverable = table.getHighestDeliverable();
hd = table.getHighestDelivered();
System.out.println("highest delivered=" + hd + ", highest deliverable=" + highest_deliverable);
assert hd == 4;
assert highest_deliverable == 6;
table.removeMany(true, 100);
System.out.println("table = " + table);
highest_deliverable = table.getHighestDeliverable();
hd = table.getHighestDelivered();
System.out.println("highest delivered=" + hd + ", highest deliverable=" + highest_deliverable);
assert hd == 6;
assert highest_deliverable == 6;
table.add(7, 7);
System.out.println("table = " + table);
highest_deliverable = table.getHighestDeliverable();
hd = table.getHighestDelivered();
System.out.println("highest delivered=" + hd + ", highest deliverable=" + highest_deliverable);
assert hd == 6;
assert highest_deliverable == 8;
table.removeMany(true, 100);
System.out.println("table = " + table);
highest_deliverable = table.getHighestDeliverable();
hd = table.getHighestDelivered();
System.out.println("highest delivered=" + hd + ", highest deliverable=" + highest_deliverable);
assert hd == 8;
assert highest_deliverable == 8;
}
public void testPurge3() {
Table<Integer> table = new Table<Integer>(3, 10, 0);
for (int i = 1; i <= 100; i++) table.add(i, i);
System.out.println("table = " + table);
table.removeMany(true, 53);
for (int i = 54; i <= 100; i++) assert table.get(i) == i;
}
public static void testAdditionList() {
Table<Integer> table = new Table<Integer>(3, 10, 0);
List<Tuple<Long, Integer>> msgs = createList(0);
assert !table.add(msgs);
long[] seqnos = {1, 5, 9, 10, 11, 19, 20, 29};
msgs = createList(seqnos);
assert table.add(msgs);
System.out.println("table: " + table.dump());
for (long seqno : seqnos) assert table.get(seqno) == seqno;
assert table.size() == 8;
int size = table.computeSize();
assert size == 8;
assert table.size() == table.computeSize();
assertCapacity(table.capacity(), 3, 10);
assertIndices(table, 0, 0, 29);
}
public void testAdd() {
Table<Integer> buf = new Table<Integer>(3, 10, 0);
buf.add(1, 322649);
buf.add(2, 100000);
System.out.println("buf = " + buf);
assert buf.size() == 2;
}
public static void testPurge() {
Table<Integer> table = new Table<Integer>(5, 10, 0);
for (int seqno = 1; seqno <= 25; seqno++) table.add(seqno, seqno);
int[] seqnos = {30, 31, 32, 37, 38, 39, 40, 41, 42, 47, 48, 49};
for (int seqno : seqnos) table.add(seqno, seqno);
System.out.println("table (before remove):\n" + table.dump());
for (int seqno = 1; seqno <= 22; seqno++) table.remove(false);
System.out.println("\ntable (after remove 22, before purge):\n" + table.dump());
table.purge(22);
System.out.println("\ntable: (after purge 22):\n" + table.dump());
assert table.size() == 3 + seqnos.length;
assert table.computeSize() == table.size();
}
public static void testForEach() {
class MyVisitor<T> implements Table.Visitor<T> {
List<int[]> list = new ArrayList<int[]>(20);
public boolean visit(long seqno, T element, int row, int column) {
System.out.println("#" + seqno + ": " + element + ", row=" + row + ", column=" + column);
list.add(new int[] {row, column});
return true;
}
}
MyVisitor<Integer> visitor = new MyVisitor<Integer>();
Table<Integer> table = new Table<Integer>(3, 10, 0);
for (int i = 1; i <= 20; i++) table.add(i, i);
System.out.println("table = " + table);
table.forEach(table.getLow() + 1, table.getHighestReceived() - 1, visitor);
int count = 1;
for (int[] pair : visitor.list) {
int row = pair[0], column = pair[1];
if (count < Util.getNextHigherPowerOfTwo(10)) {
assert row == 0;
assert column == count;
} else {
assert row == 1;
assert column == count - Util.getNextHigherPowerOfTwo(10);
}
count++;
}
}
protected static void addAndGet(Table<Integer> table, int... seqnos) {
for (int seqno : seqnos) {
boolean added = table.add((long) seqno, seqno);
assert added;
Integer val = table.get(seqno);
assert val != null && val == seqno;
}
}
public void testAddList() {
Table<Integer> buf = new Table<Integer>(3, 10, 0);
List<Tuple<Long, Integer>> msgs = createList(1, 2);
boolean rc = buf.add(msgs);
System.out.println("buf = " + buf);
assert rc;
assert buf.size() == 2;
}
public static void testDuplicateAddition() {
Table<Integer> table = new Table<Integer>(3, 10, 0);
addAndGet(table, 1, 5, 9, 10);
assert !table.add(5, 5);
assert table.get(5) == 5;
assert table.size() == 4;
assertIndices(table, 0, 0, 10);
}
public void testGet() {
final Table<Integer> buf = new Table<Integer>(3, 10, 0);
for (int i : Arrays.asList(1, 2, 3, 4, 5)) buf.add(i, i);
assert buf.get(0) == null;
assert buf.get(1) == 1;
assert buf.get(10) == null;
assert buf.get(5) == 5;
assert buf.get(6) == null;
}
public void run() {
try {
latch.await();
Util.sleepRandom(10, 500);
buf.add(seqno, seqno);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void testGetMissingFirst() {
Table<Integer> table = new Table<Integer>(3, 10, 0);
for (int num : Arrays.asList(2, 3, 4, 5)) table.add(num, num);
System.out.println("table = " + table);
SeqnoList missing = table.getMissing();
System.out.println("missing=" + missing);
assert missing.size() == 1;
assert table.getNumMissing() == 1;
}
public void testRemoveMany2() {
Table<Integer> buf = new Table<Integer>(3, 10, 0);
for (int i : Arrays.asList(1, 2, 3, 4, 5, 6, 7, 9, 10)) buf.add(i, i);
List<Integer> list = buf.removeMany(false, 3);
System.out.println("list = " + list);
assert list != null && list.size() == 3;
list = buf.removeMany(false, 0);
System.out.println("list = " + list);
assert list != null && list.size() == 4;
list = buf.removeMany(false, 10);
assert list == null;
buf.add(8, 8);
list = buf.removeMany(false, 0);
System.out.println("list = " + list);
assert list != null && list.size() == 3;
}
public static void testAddListWithResizing2() {
Table<Integer> table = new Table<Integer>(3, 500, 0);
List<Tuple<Long, Integer>> msgs = new ArrayList<Tuple<Long, Integer>>();
for (int i = 1; i < 100; i++) msgs.add(new Tuple<Long, Integer>((long) i, i));
table.add(msgs, false);
System.out.println("table = " + table);
int num_resizes = table.getNumResizes();
System.out.println("num_resizes = " + num_resizes);
assert num_resizes == 0 : "number of resizings=" + num_resizes + " (expected 0)";
}
public static void testMassAddition() {
Table<Integer> table = new Table<Integer>(3, 10, 0);
final int NUM_ELEMENTS = 10005;
for (int i = 1; i <= NUM_ELEMENTS; i++) table.add(i, i);
System.out.println("table = " + table);
assert table.size() == NUM_ELEMENTS;
assertCapacity(table.capacity(), table.getNumRows(), 10);
assertIndices(table, 0, 0, NUM_ELEMENTS);
assert table.getNumMissing() == 0;
}
public static void testComputeSize2() {
Table<Integer> table = new Table<Integer>(3, 10, 0);
table.add(1, 1);
System.out.println("table = " + table);
assert table.computeSize() == table.size();
assert table.computeSize() == 1;
table.remove(false);
System.out.println("table = " + table);
assert table.computeSize() == table.size();
assert table.computeSize() == 0;
}
public static void testAdditionListWithOffset() {
Table<Integer> table = new Table<Integer>(3, 10, 100);
long seqnos[] = {101, 105, 109, 110, 111, 119, 120, 129};
List<Tuple<Long, Integer>> msgs = createList(seqnos);
System.out.println("table: " + table.dump());
assert table.add(msgs);
assert table.size() == 8;
for (long seqno : seqnos) assert table.get(seqno) == seqno;
assertCapacity(table.capacity(), 3, 10);
assertIndices(table, 100, 100, 129);
}
public void testGetMissing4() {
Table<Integer> buf = new Table<Integer>(3, 30, 0);
for (int i : Arrays.asList(2, 5, 10, 11, 12, 13, 15, 20, 28, 30)) buf.add(i, i);
System.out.println("buf = " + buf);
int missing = buf.getNumMissing();
assert missing == 20;
System.out.println("missing=" + missing);
SeqnoList missing_list = buf.getMissing();
System.out.println("missing_list = " + missing_list);
assert missing_list.size() == missing;
}
public static void testAddition() {
Table<Integer> table = new Table<Integer>(3, 10, 0);
assert !table.add(0, 0);
addAndGet(table, 1, 5, 9, 10, 11, 19, 20, 29);
System.out.println("table: " + table.dump());
assert table.size() == 8;
int size = table.computeSize();
assert size == 8;
assert table.size() == table.computeSize();
assertCapacity(table.capacity(), 3, 10);
assertIndices(table, 0, 0, 29);
}
public static void testRemoveMany() {
Table<Integer> table = new Table<Integer>(3, 10, 0);
for (int seqno : Arrays.asList(1, 2, 3, 4, 5, 7, 8, 9, 10)) table.add(seqno, seqno);
System.out.println("table = " + table);
assertIndices(table, 0, 0, 10);
List<Integer> list = table.removeMany(true, 4);
System.out.println("list=" + list + ", table=" + table);
assert table.size() == 5 && table.getNumMissing() == 1;
assert list != null && list.size() == 4;
for (int num : Arrays.asList(1, 2, 3, 4)) assert list.contains(num);
assertIndices(table, 4, 4, 10);
}
protected void handleBatchReceived(Address sender, Map<Short, List<Message>> map) {
for (Map.Entry<Short, List<Message>> element : map.entrySet()) {
final List<Message> msg_list = element.getValue();
if (log.isTraceEnabled()) {
StringBuilder sb = new StringBuilder();
sb.append(local_addr)
.append(" <-- DATA(")
.append(sender)
.append(": " + printMessageList(msg_list))
.append(')');
log.trace(sb);
}
short conn_id = element.getKey();
ReceiverEntry entry = null;
for (Message msg : msg_list) {
UnicastHeader hdr = (UnicastHeader) msg.getHeader(id);
entry = getReceiverEntry(sender, hdr.seqno, hdr.first, conn_id);
if (entry == null) continue;
Table<Message> win = entry.received_msgs;
boolean msg_added =
win.add(hdr.seqno, msg); // win is guaranteed to be non-null if we get here
num_msgs_received++;
if (hdr.first && msg_added)
sendAck(
sender, hdr.seqno,
conn_id); // send an ack immediately when we received the first message of a conn
// An OOB message is passed up immediately. Later, when remove() is called, we discard it.
// This affects ordering !
// http://jira.jboss.com/jira/browse/JGRP-377
if (msg.isFlagSet(Message.Flag.OOB) && msg_added) {
try {
up_prot.up(new Event(Event.MSG, msg));
} catch (Throwable t) {
log.error("couldn't deliver OOB message " + msg, t);
}
}
}
if (entry != null && conn_expiry_timeout > 0) entry.update();
}
ReceiverEntry entry = recv_table.get(sender);
Table<Message> win = entry != null ? entry.received_msgs : null;
if (win != null) {
final AtomicBoolean processing = win.getProcessing();
if (processing.compareAndSet(false, true)) {
removeAndDeliver(processing, win, sender);
sendAck(sender, win.getHighestDeliverable(), entry.recv_conn_id);
}
}
}
/**
* Check whether the hashtable contains an entry e for <code>sender</code> (create if not). If
* e.received_msgs is null and <code>first</code> is true: create a new AckReceiverWindow(seqno)
* and add message. Set e.received_msgs to the new window. Else just add the message.
*/
protected void handleDataReceived(
Address sender, long seqno, short conn_id, boolean first, Message msg, Event evt) {
if (log.isTraceEnabled()) {
StringBuilder sb = new StringBuilder();
sb.append(local_addr).append(" <-- DATA(").append(sender).append(": #").append(seqno);
if (conn_id != 0) sb.append(", conn_id=").append(conn_id);
if (first) sb.append(", first");
sb.append(')');
log.trace(sb);
}
ReceiverEntry entry = getReceiverEntry(sender, seqno, first, conn_id);
if (entry == null) return;
if (conn_expiry_timeout > 0) entry.update();
Table<Message> win = entry.received_msgs;
boolean added = win.add(seqno, msg); // win is guaranteed to be non-null if we get here
num_msgs_received++;
// An OOB message is passed up immediately. Later, when remove() is called, we discard it. This
// affects ordering !
// http://jira.jboss.com/jira/browse/JGRP-377
if (msg.isFlagSet(Message.OOB) && added) {
try {
up_prot.up(evt);
} catch (Throwable t) {
log.error("couldn't deliver OOB message " + msg, t);
}
}
final AtomicBoolean processing = win.getProcessing();
if (!processing.compareAndSet(false, true)) {
return;
}
// try to remove (from the AckReceiverWindow) as many messages as possible as pass them up
// Prevents concurrent passing up of messages by different threads
// (http://jira.jboss.com/jira/browse/JGRP-198);
// this is all the more important once we have a concurrent stack
// (http://jira.jboss.com/jira/browse/JGRP-181),
// where lots of threads can come up to this point concurrently, but only 1 is allowed to pass
// at a time
// We *can* deliver messages from *different* senders concurrently, e.g. reception of P1, Q1,
// P2, Q2 can result in
// delivery of P1, Q1, Q2, P2: FIFO (implemented by UNICAST) says messages need to be delivered
// only in the
// order in which they were sent by their senders
int num_msgs = removeAndDeliver(processing, win);
if (num_msgs > 0) {
long hd = win.getHighestDelivered();
sendAck(sender, hd);
}
}
public static void testRemove() {
Table<Integer> table = new Table<Integer>(3, 10, 0);
for (int i = 1; i <= 9; i++) table.add(i, i);
table.add(20, 20);
System.out.println("table = " + table);
assert table.size() == 10;
assertIndices(table, 0, 0, 20);
int num_null_msgs = table.getNumMissing();
System.out.println("num_null_msgs = " + num_null_msgs);
assert num_null_msgs == 10;
for (long i = 1; i <= 10; i++) // 10 is missing
table.remove();
System.out.println("table = " + table);
assert table.size() == 1;
assertIndices(table, 9, 9, 20);
num_null_msgs = table.getNumMissing();
System.out.println("num_null_msgs = " + num_null_msgs);
assert num_null_msgs == 10;
}