org.jgroups.tests.RoundTripMulticast Maven / Gradle / Ivy
Go to download
This artifact provides a single jar that contains all classes required to use remote Jakarta Enterprise Beans and Jakarta Messaging, including
all dependencies. It is intended for use by those not using maven, maven users should just import the Jakarta Enterprise Beans and
Jakarta Messaging BOM's instead (shaded JAR's cause lots of problems with maven, as it is very easy to inadvertently end up
with different versions on classes on the class path).
package org.jgroups.tests;
import org.jgroups.Global;
import org.jgroups.ReceiverAdapter;
import org.jgroups.stack.IpAddress;
import org.jgroups.util.Util;
import java.io.IOException;
import java.net.*;
import java.nio.ByteBuffer;
/**
* Class that measure RTT between a client and server using multicast sockets
* @author Bela Ban
*/
public class RoundTripMulticast extends ReceiverAdapter {
MulticastSocket mcast_recv_sock; // to receive mcast traffic
MulticastSocket mcast_send_sock; // to send mcast traffic
DatagramSocket ucast_sock; // to receive and send unicast traffic
InetAddress bind_addr, mcast_addr;
int mcast_port=7500;
int num=1000;
int msg_size=10;
boolean server=false;
final byte[] RSP_BUF=new byte[]{1}; // 1=response
int num_responses=0;
final Object mutex=new Object();
IpAddress local_addr;
interface Receiver {
void receive(byte[] buffer, int offset, int length, InetAddress sender, int sender_port);
}
private void start(boolean server, int num, int msg_size, InetAddress bind_addr,
InetAddress mcast_addr, int mcast_port) throws Exception {
this.server=server;
this.num=num;
this.msg_size=msg_size;
this.bind_addr=bind_addr;
this.mcast_addr=mcast_addr;
this.mcast_port=mcast_port;
// SocketAddress saddr=new InetSocketAddress(bind_addr, mcast_port);
mcast_send_sock=new MulticastSocket(mcast_port);
mcast_send_sock.setTimeToLive(2);
mcast_send_sock.setInterface(bind_addr);
SocketAddress group=new InetSocketAddress(mcast_addr, mcast_port);
mcast_send_sock.joinGroup(group, null);
mcast_recv_sock=new MulticastSocket(mcast_port);
mcast_recv_sock.setTimeToLive(2);
mcast_recv_sock.setInterface(bind_addr);
mcast_recv_sock.joinGroup(group, null);
ucast_sock=new DatagramSocket(0, bind_addr);
ucast_sock.setTrafficClass(16); // 0x10
local_addr=new IpAddress(ucast_sock.getLocalAddress(), ucast_sock.getLocalPort());
if(server) {
Receiver r=new Receiver() {
public void receive(byte[] buf, int offset, int length, InetAddress sender, int sender_port) {
ByteBuffer buffer=ByteBuffer.wrap(buf, offset, length);
byte r=buffer.get();
// System.out.println("received " + (r == 0? "request" : "response"));
short len=buffer.getShort();
byte[] tmp=new byte[len];
buffer.get(tmp, 0, len);
try {
IpAddress real_sender=(IpAddress)Util.streamableFromByteBuffer(IpAddress.class, tmp);
DatagramPacket packet=new DatagramPacket(RSP_BUF, 0, RSP_BUF.length, real_sender.getIpAddress(), real_sender.getPort());
ucast_sock.send(packet); // send the response via DatagramSocket
}
catch(Exception e) {
e.printStackTrace();
}
}
};
ReceiverThread rt=new ReceiverThread(r, mcast_recv_sock);
rt.start();
System.out.println("server started (ctrl-c to kill)");
while(true) {
Util.sleep(60000);
}
}
else {
System.out.println("sending " + num + " requests");
sendRequests();
}
mcast_recv_sock.close();
mcast_send_sock.close();
ucast_sock.close();
}
private void sendRequests() throws Exception {
byte[] marshalled_addr=Util.streamableToByteBuffer(local_addr);
int length=Global.BYTE_SIZE + // request or response byte
Global.SHORT_SIZE + // length of marshalled IpAddress
marshalled_addr.length +
msg_size;
long start, stop, total;
double requests_per_sec;
double ms_per_req;
int print=num / 10;
int count=0;
num_responses=0;
ByteBuffer buffer=ByteBuffer.allocate(length);
buffer.put((byte)0); // request
buffer.putShort((short)marshalled_addr.length);
buffer.put(marshalled_addr, 0, marshalled_addr.length);
byte[] payload=new byte[msg_size];
buffer.put(payload, 0, payload.length);
byte[] array=buffer.array();
ReceiverThread mcast_receiver=new ReceiverThread(
new Receiver() {
public void receive(byte[] buffer, int offset, int length, InetAddress sender, int sender_port) {
// System.out.println("mcast from " + sender + ":" + sender_port + " was discarded");
}
},
mcast_recv_sock
);
mcast_receiver.start();
ReceiverThread ucast_receiver=new ReceiverThread(
new Receiver() {
public void receive(byte[] buffer, int offset, int length, InetAddress sender, int sender_port) {
synchronized(mutex) {
num_responses++;
mutex.notify();
}
}
},
ucast_sock);
ucast_receiver.start();
start=System.currentTimeMillis();
for(int i=0; i < num; i++) {
DatagramPacket packet=new DatagramPacket(array, 0, array.length, mcast_addr, mcast_port);
try {
mcast_send_sock.send(packet);
synchronized(mutex) {
while(num_responses != count +1) {
mutex.wait(1000);
}
count=num_responses;
if(num_responses >= num) {
System.out.println("received all responses (" + num_responses + ")");
break;
}
}
if(num_responses % print == 0) {
System.out.println("- received " + num_responses);
}
}
catch(Exception e) {
e.printStackTrace();
}
}
stop=System.currentTimeMillis();
/*start=System.currentTimeMillis();
for(int i=0; i < num; i++) {
DatagramPacket packet=new DatagramPacket(array, 0, array.length, mcast_addr, mcast_port);
try {
mcast_send_sock.send(packet);
if(num_responses % print == 0) {
System.out.println("- received " + num_responses);
}
synchronized(mutex) {
if(num_responses >= num) {
System.out.println("received all responses (" + num_responses + ")");
break;
}
else
mutex.wait();
}
}
catch(Exception e) {
e.printStackTrace();
}
}
stop=System.currentTimeMillis();*/
total=stop-start;
requests_per_sec=num / (total / 1000.0);
ms_per_req=total / (double)num;
System.out.println("Took " + total + "ms for " + num + " requests: " + requests_per_sec +
" requests/sec, " + ms_per_req + " ms/request");
}
static class ReceiverThread implements Runnable {
Receiver receiver;
Thread thread;
DatagramSocket sock;
byte[] buf=new byte[65000];
DatagramPacket packet;
public ReceiverThread(Receiver r, DatagramSocket sock) {
this.receiver=r;
this.sock=sock;
}
public final void start() {
thread=new Thread(this);
thread.start();
}
public void stop() {
thread=null;
sock.close();
}
public void run() {
while(thread != null && thread.equals(Thread.currentThread())) {
packet=new DatagramPacket(buf, 0, buf.length);
try {
sock.receive(packet);
if(receiver != null) {
receiver.receive(packet.getData(), packet.getOffset(), packet.getLength(), packet.getAddress(), packet.getPort());
}
}
catch(IOException e) {
break;
}
}
}
}
public static void main(String[] args) throws Exception {
boolean server=false;
int num=100;
int msg_size=10; // 10 bytes
InetAddress bind_addr=null, mcast_addr=null;
int mcast_port=7500;
for(int i=0; i < args.length; i++) {
if(args[i].equals("-num")) {
num=Integer.parseInt(args[++i]);
continue;
}
if(args[i].equals("-server")) {
server=true;
continue;
}
if(args[i].equals("-size")) {
msg_size=Integer.parseInt(args[++i]);
continue;
}
if(args[i].equals("-bind_addr")) {
bind_addr=InetAddress.getByName(args[++i]);
continue;
}
if(args[i].equals("-mcast_addr")) {
mcast_addr=InetAddress.getByName(args[++i]);
continue;
}
if(args[i].equals("-mcast_port")) {
mcast_port=Integer.parseInt(args[++i]);
continue;
}
RoundTripMulticast.help();
return;
}
if(bind_addr == null)
bind_addr=InetAddress.getLocalHost();
if(mcast_addr == null)
mcast_addr=InetAddress.getByName("225.5.5.5");
new RoundTripMulticast().start(server, num, msg_size, bind_addr, mcast_addr, mcast_port);
}
private static void help() {
System.out.println("RoundTrip [-server] [-num ] " +
"[-size ] [-bind_addr ] " +
"[-mcast_addr ] [-mcast_port ]");
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy