From 76a80b6dab1b4a4fff6403bc01ea421c8774484d Mon Sep 17 00:00:00 2001 From: Arjun Mittal Date: Mon, 8 Mar 2021 19:02:15 -0500 Subject: [PATCH] M2 Performance Tests (#53) --- .gitignore | 3 +- src/testing/PerformanceTests.java | 204 ++----------- .../performance/BasePerformanceTest.java | 283 ++++++++++++++++++ .../Server01Client01PerformanceTest.java | 49 +++ .../Server01Client05PerformanceTest.java | 49 +++ .../Server01Client20PerformanceTest.java | 49 +++ .../Server05Client01PerformanceTest.java | 53 ++++ .../Server05Client05PerformanceTest.java | 53 ++++ .../Server05Client20PerformanceTest.java | 53 ++++ .../Server10Client01PerformanceTest.java | 58 ++++ .../Server10Client05PerformanceTest.java | 58 ++++ .../Server10Client20PerformanceTest.java | 58 ++++ 12 files changed, 782 insertions(+), 188 deletions(-) create mode 100644 src/testing/performance/BasePerformanceTest.java create mode 100644 src/testing/performance/Server01Client01PerformanceTest.java create mode 100644 src/testing/performance/Server01Client05PerformanceTest.java create mode 100644 src/testing/performance/Server01Client20PerformanceTest.java create mode 100644 src/testing/performance/Server05Client01PerformanceTest.java create mode 100644 src/testing/performance/Server05Client05PerformanceTest.java create mode 100644 src/testing/performance/Server05Client20PerformanceTest.java create mode 100644 src/testing/performance/Server10Client01PerformanceTest.java create mode 100644 src/testing/performance/Server10Client05PerformanceTest.java create mode 100644 src/testing/performance/Server10Client20PerformanceTest.java diff --git a/.gitignore b/.gitignore index 733d3e5..592c8c7 100644 --- a/.gitignore +++ b/.gitignore @@ -44,4 +44,5 @@ data/ apache-zookeeper-3.6.2-bin/ -Design Document ECE496 M1.pdf \ No newline at end of file +Design Document ECE496 M1.pdf +ECE419 Design Document 2.pdf \ No newline at end of file diff --git a/src/testing/PerformanceTests.java b/src/testing/PerformanceTests.java index f365d42..b5a6db1 100644 --- a/src/testing/PerformanceTests.java +++ b/src/testing/PerformanceTests.java @@ -1,204 +1,34 @@ package testing; -import app_kvServer.IKVServer.CacheStrategy; -import app_kvServer.KVServer; -import app_kvServer.storage.IKVStorage.KVPair; -import client.KVStore; +import junit.framework.Test; import junit.framework.TestCase; +import junit.framework.TestSuite; import logger.LogSetup; import org.apache.log4j.Level; -import org.junit.Test; -import shared.ObjectFactory; -import shared.messages.KVMessage; -import shared.messages.KVMessageProto; +import testing.performance.*; -import java.util.*; -import java.util.concurrent.Callable; -import java.util.concurrent.ExecutorService; -import java.util.concurrent.Executors; -import java.util.concurrent.Future; -import java.util.function.Predicate; -import java.util.stream.Collectors; -import java.util.stream.IntStream; +import java.io.IOException; public class PerformanceTests extends TestCase { - /** - * NUM_UNIQ_REQS: the number of unique key/value pairs to generate - * REQ_DUPLICITY: how many times each of the unique requests should be re-attempted - * NUM_CLIENTS: number of clients (and threads) to spin up - *

- * In total, the server will be hit with NUM_UNIQ_REQS * REQ_DUPLICITY * NUM_CLIENTS requests, though concurrency - * and caching results may differ as you play around with the 3 vars - */ - private static final int NUM_UNIQ_REQS = 100, REQ_DUPLICITY = 2, NUM_CLIENTS = 8; - - private static final int CACHE_SIZE = NUM_UNIQ_REQS; - private static final CacheStrategy CACHE_STRATEGY = CacheStrategy.FIFO; - - private static KVServer SERVER; - private static List CLIENTS; - private static List REQUEST_TEST_SET; - static { try { - // 1. Test init new LogSetup("logs/testing/test.log", Level.ERROR); - - REQUEST_TEST_SET = new ArrayList<>(NUM_UNIQ_REQS * REQ_DUPLICITY); - List uniqueRequests = IntStream.range(0, NUM_UNIQ_REQS) - .mapToObj(i -> new KVPair(generateRandomString(KVMessageProto.MAX_KEY_SIZE), generateRandomString(KVMessageProto.MAX_VALUE_SIZE))) - .collect(Collectors.toList()); - for (int i = 0; i < REQ_DUPLICITY; i++) REQUEST_TEST_SET.addAll(uniqueRequests); - - // 2. Client-server init - SERVER = (KVServer) ObjectFactory.createKVServerObject(50000, CACHE_SIZE, CACHE_STRATEGY.toString()); - CLIENTS = new ArrayList<>(NUM_CLIENTS); - for (int i = 0; i < NUM_CLIENTS; i++) CLIENTS.add(new KVStore("localhost", 50000)); - - // 3. Start communications - for (KVStore kvClient : CLIENTS) kvClient.connect(); - } catch (Exception e) { + } catch (IOException e) { e.printStackTrace(); } } - public static String generateRandomString(int maxlength) { - String alphaNumeric = String.join("", "ABCDEFGHIJKLMNOPQRSTUVWXYZ", "abcdefghijklmnopqrstuvwxyz", "0123456789"); - - StringBuilder sb = new StringBuilder(); - Random random = new Random(); - - int length = random.nextInt(maxlength); - - for (int i = 0; i <= length; i++) { - int index = random.nextInt(alphaNumeric.length()); - char randomChar = alphaNumeric.charAt(index); - sb.append(randomChar); - } - - return sb.toString(); - } - - public ThroughputResults singleClientPerformance(KVStore store, List tests, Predicate isGetIteration) throws Exception { - int msgSize = 0, executionTime = 0, iterations = 0; - - Collections.shuffle(tests); - for (KVPair test : tests) { - iterations++; - String key = test.key, value = test.value; - if (isGetIteration.test(iterations)) { - msgSize += new KVMessageProto(KVMessage.StatusType.GET, key, iterations).getByteRepresentation().length; - long start = System.currentTimeMillis(); - final KVMessage res = store.get(key); - long finish = System.currentTimeMillis(); - executionTime += (finish - start); - assertNotSame("GET failed: " + res, KVMessage.StatusType.FAILED, res.getStatus()); - } else { - msgSize += new KVMessageProto(KVMessage.StatusType.PUT, key, value, iterations).getByteRepresentation().length; - long start = System.currentTimeMillis(); - final KVMessage res = store.put(key, value); - long finish = System.currentTimeMillis(); - executionTime += (finish - start); - assertNotSame("PUT failed: " + res, KVMessage.StatusType.FAILED, res.getStatus()); - } - } - - - return new ThroughputResults(Thread.currentThread().getId(), - msgSize / (double) iterations, - executionTime / (double) iterations, - msgSize / (double) executionTime - ); - } - - public void putGetPerformance(String testName, Predicate isGetIteration) { - ExecutorService threadPool = Executors.newFixedThreadPool(NUM_CLIENTS); - List> threads = CLIENTS.stream() - .map(client -> (Callable) - () -> singleClientPerformance(client, new ArrayList<>(REQUEST_TEST_SET), isGetIteration)) - .collect(Collectors.toList()); - - try { - double serverAverageThroughput = 0; // since requests are evenly distributed among clients, sum of averages is equal to average of sums - for (Future future : threadPool.invokeAll(threads)) { - ThroughputResults result = future.get(); - System.out.printf("%s | Thread %d | Average Message Size (KB) | %.3f\n", testName, result.id, result.averageMessageSize / 1000); - System.out.printf("%s | Thread %d | Average Client Latency (ms) | %.3f\n", testName, result.id, result.averageLatency); - System.out.printf("%s | Thread %d | Average Client Throughput (KB/s) | %.3f\n", testName, result.id, result.averageThroughput); - serverAverageThroughput += result.averageThroughput; - } - System.out.printf("%s | Server | Average Server Throughput (KB/s) | %.3f\n", testName, serverAverageThroughput); - } catch (Exception e) { - throw new RuntimeException("Threadpool encountered an error", e); - } finally { - SERVER.clearCache(); - SERVER.clearStorage(); - } - } - - @Test - public void test10Get90PutPerformance() { - System.out.println("10/90 Get-Put Ratio"); - putGetPerformance("10/90", i -> i % 10 == 0); - } - - @Test - public void test20Get80PutPerformance() { - System.out.println("20/80 Get-Put Ratio"); - putGetPerformance("20/80", i -> i % 5 == 0); - } - - @Test - public void test30Get70PutPerformance() { - System.out.println("30/70 Get-Put Ratio"); - putGetPerformance("30/70", i -> Arrays.asList(0, 1, 2).contains(i % 10)); - } - - @Test - public void test40Get60PutPerformance() { - System.out.println("40/60 Get-Put Ratio"); - putGetPerformance("40/60", i -> Arrays.asList(0, 1).contains(i % 5)); - } - - @Test - public void test50Get50PutPerformance() { - System.out.println("50/50 Get-Put Ratio"); - putGetPerformance("50/50", i -> i % 2 == 0); - } - - @Test - public void test60Get40PutPerformance() { - System.out.println("60/40 Get-Put Ratio"); - putGetPerformance("60/40", i -> i % 5 > 1); - } - - @Test - public void test70Get30PutPerformance() { - System.out.println("70/30 Get-Put Ratio"); - putGetPerformance("70/30", i -> i % 10 > 2); - } - - @Test - public void test80Get20PutPerformance() { - System.out.println("80/20 Get-Put Ratio"); - putGetPerformance("80/20", i -> i % 5 > 0); - } - - @Test - public void test90Get10PutPerformance() { - System.out.println("90/10 Get-Put Ratio"); - putGetPerformance("90/10", i -> i % 10 > 0); - } - - private static class ThroughputResults { - final long id; - final double averageMessageSize, averageLatency, averageThroughput; - - ThroughputResults(long id, double averageMessageSize, double averageLatency, double averageThroughput) { - this.id = id; - this.averageMessageSize = averageMessageSize; - this.averageLatency = averageLatency; - this.averageThroughput = averageThroughput; - } + public static Test suite() { + TestSuite clientSuite = new TestSuite("Basic Storage Server PERFORMANCE Test-Suite"); + clientSuite.addTestSuite(Server01Client01PerformanceTest.class); + clientSuite.addTestSuite(Server01Client05PerformanceTest.class); + clientSuite.addTestSuite(Server01Client20PerformanceTest.class); + clientSuite.addTestSuite(Server05Client01PerformanceTest.class); + clientSuite.addTestSuite(Server05Client05PerformanceTest.class); + clientSuite.addTestSuite(Server05Client20PerformanceTest.class); + clientSuite.addTestSuite(Server10Client01PerformanceTest.class); + clientSuite.addTestSuite(Server10Client05PerformanceTest.class); + clientSuite.addTestSuite(Server10Client20PerformanceTest.class); + return clientSuite; } } diff --git a/src/testing/performance/BasePerformanceTest.java b/src/testing/performance/BasePerformanceTest.java new file mode 100644 index 0000000..8d299bd --- /dev/null +++ b/src/testing/performance/BasePerformanceTest.java @@ -0,0 +1,283 @@ +package testing.performance; + +import app_kvECS.ECSClient; +import app_kvServer.IKVServer; +import app_kvServer.storage.IKVStorage.KVPair; +import client.KVStore; +import junit.framework.TestCase; +import logger.LogSetup; +import org.apache.log4j.Level; +import org.junit.*; +import shared.messages.KVMessage; +import shared.messages.KVMessageProto; + +import java.io.File; +import java.io.IOException; +import java.nio.file.Files; +import java.util.*; +import java.util.concurrent.Callable; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Future; +import java.util.function.Predicate; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +public abstract class BasePerformanceTest extends TestCase { + /** + * ENRON_MAIL_DIR: path to the *UNCOMPRESSED* dataset + * ENRON_SUBSET_MAILBOX: path to a mailbox within the dataset to use for our tests + */ + private static final String ENRON_MAIL_DIR = "enron_mail_20150507", + ENRON_SUBSET_MAILBOX = "dasovich-j/all_documents"; + + /** + * NUM_UNIQ_REQS: the number of unique key/value pairs to generate + * REQ_DUPLICITY: how many times each of the unique requests should be re-attempted + *

+ * In total, the server will be hit with NUM_UNIQ_REQS * REQ_DUPLICITY * NUM_CLIENTS requests, though concurrency + * and caching results may differ as you play around with the 3 vars + */ + protected static final int NUM_UNIQ_REQS = 100, REQ_DUPLICITY = 2; + + protected static final int CACHE_SIZE = NUM_UNIQ_REQS / 2; + protected static final IKVServer.CacheStrategy CACHE_STRATEGY = IKVServer.CacheStrategy.FIFO; + + + private static final List REQUEST_TEST_SET; + private static ECSClient ECS; + private static List CLIENTS; + + /* + * Global set up + */ + static { + try { + REQUEST_TEST_SET = generateTestSet(); + System.out.println(String.join(" | ", + "Clients", + "Servers", + "GET/Request Ratio", + "Average GET Latency (ms)", + "Average GET Throughput (MB/s)", + "Average PUT Latency (ms)", + "Average PUT Throughput (MB/s)" + )); + } catch (Exception e) { + throw new RuntimeException("Could not generate test set", e); + } + } + + /** + * Generate a KVPair test set from a subset of the enron mail dataset + */ + protected static List generateTestSet() { + List allRequests = new ArrayList<>(NUM_UNIQ_REQS * REQ_DUPLICITY); + File emailDirectory = new File(ENRON_MAIL_DIR, ENRON_SUBSET_MAILBOX); + + List uniqueRequests = Arrays.asList(Objects.requireNonNull(emailDirectory.listFiles())) + .subList(0, NUM_UNIQ_REQS) + .stream() + .map(file -> { + String key = file.getName(), value; + try (Stream lines = Files.lines(file.toPath())) { + value = String.join("+", lines.toArray(String[]::new)); + if (value.length() > KVMessageProto.MAX_VALUE_SIZE) { + value = value.substring(0, KVMessageProto.MAX_VALUE_SIZE); + } + } catch (Exception e) { + return null; + } + return new KVPair(key, value); + }) + .filter(Objects::nonNull) + .collect(Collectors.toList()); + + for (int i = 0; i < REQ_DUPLICITY; i++) allRequests.addAll(uniqueRequests); + return allRequests; + } + + /** + * Per-test setup + */ + @Before + public void setUp() throws Exception { + ECS = generateNewServers(); + CLIENTS = generateNewClients(); + + ECS.addNodes(getNumServers(), CACHE_STRATEGY.toString(), CACHE_SIZE); + boolean started = ECS.start(); + if (!started) { + throw new Exception("Unable to start all specified servers"); + } + for (KVStore kvClient : CLIENTS) kvClient.connect(); + } + + /** + * Per-test teardown + */ + @After + public void tearDown() throws IOException { + for (KVStore kvClient : CLIENTS) kvClient.disconnect(); + ECS.shutdown(); + // Shutdown is ack-ed right away, but needs some time to complete + try { + Thread.sleep(500); + } catch (InterruptedException e) { + e.printStackTrace(); + } + ECS.close(); + } + + protected abstract List generateNewClients(); + + protected abstract ECSClient generateNewServers(); + + protected abstract int getNumClients(); + + protected abstract int getNumServers(); + + public ThroughputResults singleClientPerformance(KVStore store, List tests, Predicate isGetIteration) throws Exception { + long getMsgSize = 0, getExecTime = 0, getCount = 0, putMsgSize = 0, putExecTime = 0, putCount = 0; + + Collections.shuffle(tests); + tests = tests.subList(0, tests.size() / getNumClients()); + + int iterations = 0; + List gettableKeys = new LinkedList<>(); + for (KVPair test : tests) { + iterations++; + if (isGetIteration.test(iterations) && !gettableKeys.isEmpty()) { + String key = gettableKeys.get(0); + + long start = System.nanoTime(); + final KVMessage res = store.get(key); + long finish = System.nanoTime(); + assertNotSame("GET failed: " + res, KVMessage.StatusType.FAILED, res.getStatus()); + assertNotSame("GET failed: " + res, KVMessage.StatusType.SERVER_STOPPED, res.getStatus()); + getCount++; + getExecTime += (finish - start); + getMsgSize += ((KVMessageProto) res).getByteRepresentation().length / 1000; + } else { + String key = test.key, value = test.value; + + long start = System.nanoTime(); + final KVMessage res = store.put(key, value); + long finish = System.nanoTime(); + assertNotSame("PUT failed: " + res, KVMessage.StatusType.FAILED, res.getStatus()); + assertNotSame("PUT failed: " + res, KVMessage.StatusType.SERVER_STOPPED, res.getStatus()); + putCount++; + putExecTime += (finish - start); + putMsgSize += ((KVMessageProto) res).getByteRepresentation().length / 1000; + + gettableKeys.add(key); + Collections.shuffle(gettableKeys); + } + } + + return new ThroughputResults(Thread.currentThread().getId(), + getCount, + putCount, + getExecTime / 1e6, // nanos->millis + putExecTime / 1e6, // nanos->millis + getMsgSize, + putMsgSize + ); + } + + public void putGetPerformance(String getRequestRatio, Predicate isGetIteration) { + final int NUM_CLIENTS = CLIENTS.size(); + ExecutorService threadPool = Executors.newFixedThreadPool(NUM_CLIENTS); + List> threads = CLIENTS.stream() + .map(client -> (Callable) + () -> singleClientPerformance(client, new ArrayList<>(REQUEST_TEST_SET), isGetIteration)) + .collect(Collectors.toList()); + + try { + // Since requests are evenly distributed among clients, sum of averages is equal to average of sums + long totalGets = 0, totalPuts = 0; + double totalGetsTime = 0, totalGetsBandwidth = 0, totalPutsTime = 0, totalPutsBandwidth = 0; + for (Future future : threadPool.invokeAll(threads)) { + ThroughputResults result = future.get(); + totalGets += result.getsCount; + totalPuts += result.putsCount; + totalGetsTime += result.totalGetsTime; + totalPutsTime += result.totalPutsTime; + totalGetsBandwidth += result.totalGetsBandwidth; + totalPutsBandwidth += result.totalPutsBandwidth; + } + + System.out.printf("%d | %d | %s | %.3f | %.3f | %.3f | %.3f%n", + getNumClients(), + getNumServers(), + getRequestRatio, + (totalGetsTime / totalGets) / (double) NUM_CLIENTS, + totalGetsBandwidth / (totalGetsTime / totalGets), + (totalPutsTime / totalPuts) / (double) NUM_CLIENTS, + totalPutsBandwidth / (totalPutsTime / totalPuts) + ); + } catch (Exception e) { + throw new RuntimeException("Threadpool encountered an error", e); + } + } + + @Test + public void test10Get90PutPerformance() { + putGetPerformance("0.1", i -> i % 10 == 0); + } + + @Test + public void test20Get80PutPerformance() { + putGetPerformance("0.2", i -> i % 5 == 0); + } + + @Test + public void test30Get70PutPerformance() { + putGetPerformance("0.3", i -> Arrays.asList(0, 1, 2).contains(i % 10)); + } + + @Test + public void test40Get60PutPerformance() { + putGetPerformance("0.4", i -> Arrays.asList(0, 1).contains(i % 5)); + } + + @Test + public void test50Get50PutPerformance() { + putGetPerformance("0.5", i -> i % 2 == 0); + } + + @Test + public void test60Get40PutPerformance() { + putGetPerformance("0.6", i -> i % 5 > 1); + } + + @Test + public void test70Get30PutPerformance() { + putGetPerformance("0.7", i -> i % 10 > 2); + } + + @Test + public void test80Get20PutPerformance() { + putGetPerformance("0.8", i -> i % 5 > 0); + } + + @Test + public void test90Get10PutPerformance() { + putGetPerformance("0.9", i -> i % 10 > 0); + } + + private static class ThroughputResults { + final long id, getsCount, putsCount; + final double totalGetsTime, totalPutsTime, totalGetsBandwidth, totalPutsBandwidth; + + public ThroughputResults(long id, long getsCount, long putsCount, double totalGetsTime, double totalPutsTime, double totalGetsBandwidth, double totalPutsBandwidth) { + this.id = id; + this.getsCount = getsCount; + this.putsCount = putsCount; + this.totalGetsTime = totalGetsTime; + this.totalPutsTime = totalPutsTime; + this.totalGetsBandwidth = totalGetsBandwidth; + this.totalPutsBandwidth = totalPutsBandwidth; + } + } +} diff --git a/src/testing/performance/Server01Client01PerformanceTest.java b/src/testing/performance/Server01Client01PerformanceTest.java new file mode 100644 index 0000000..2819ec5 --- /dev/null +++ b/src/testing/performance/Server01Client01PerformanceTest.java @@ -0,0 +1,49 @@ +package testing.performance; + +import app_kvECS.ECSClient; +import client.KVStore; +import ecs.zk.ZooKeeperService; + +import java.io.FileWriter; +import java.io.PrintWriter; +import java.util.List; +import java.util.stream.Collectors; +import java.util.stream.IntStream; +import java.util.stream.Stream; + +public class Server01Client01PerformanceTest extends BasePerformanceTest { + @Override + protected List generateNewClients() { + return IntStream.range(0, getNumClients()) + .mapToObj(i -> new KVStore("ug132", 50000)) + .collect(Collectors.toList()); + } + + @Override + protected ECSClient generateNewServers() { + ECSClient ecsClient; + try { + final String TEMP_FILE_NAME = "ecs.tmp.config"; + try (PrintWriter writer = new PrintWriter(new FileWriter(TEMP_FILE_NAME))) { + Stream.of( + "server1 ug132 50000" + ).forEach(writer::println); + } + ecsClient = new ECSClient(TEMP_FILE_NAME, ZooKeeperService.LOCALHOST_CONNSTR); + } catch (Exception e) { + throw new RuntimeException("Unable to create ECS", e); + } + + return ecsClient; + } + + @Override + protected int getNumClients() { + return 1; + } + + @Override + protected int getNumServers() { + return 1; + } +} diff --git a/src/testing/performance/Server01Client05PerformanceTest.java b/src/testing/performance/Server01Client05PerformanceTest.java new file mode 100644 index 0000000..e8abbc0 --- /dev/null +++ b/src/testing/performance/Server01Client05PerformanceTest.java @@ -0,0 +1,49 @@ +package testing.performance; + +import app_kvECS.ECSClient; +import client.KVStore; +import ecs.zk.ZooKeeperService; + +import java.io.FileWriter; +import java.io.PrintWriter; +import java.util.List; +import java.util.stream.Collectors; +import java.util.stream.IntStream; +import java.util.stream.Stream; + +public class Server01Client05PerformanceTest extends BasePerformanceTest { + @Override + protected List generateNewClients() { + return IntStream.range(0, getNumClients()) + .mapToObj(i -> new KVStore("ug132", 50000)) + .collect(Collectors.toList()); + } + + @Override + protected ECSClient generateNewServers() { + ECSClient ecsClient; + try { + final String TEMP_FILE_NAME = "ecs.tmp.config"; + try (PrintWriter writer = new PrintWriter(new FileWriter(TEMP_FILE_NAME))) { + Stream.of( + "server1 ug132 50000" + ).forEach(writer::println); + } + ecsClient = new ECSClient(TEMP_FILE_NAME, ZooKeeperService.LOCALHOST_CONNSTR); + } catch (Exception e) { + throw new RuntimeException("Unable to create ECS", e); + } + + return ecsClient; + } + + @Override + protected int getNumClients() { + return 5; + } + + @Override + protected int getNumServers() { + return 1; + } +} diff --git a/src/testing/performance/Server01Client20PerformanceTest.java b/src/testing/performance/Server01Client20PerformanceTest.java new file mode 100644 index 0000000..b649f63 --- /dev/null +++ b/src/testing/performance/Server01Client20PerformanceTest.java @@ -0,0 +1,49 @@ +package testing.performance; + +import app_kvECS.ECSClient; +import client.KVStore; +import ecs.zk.ZooKeeperService; + +import java.io.FileWriter; +import java.io.PrintWriter; +import java.util.List; +import java.util.stream.Collectors; +import java.util.stream.IntStream; +import java.util.stream.Stream; + +public class Server01Client20PerformanceTest extends BasePerformanceTest { + @Override + protected List generateNewClients() { + return IntStream.range(0, getNumClients()) + .mapToObj(i -> new KVStore("ug132", 50000)) + .collect(Collectors.toList()); + } + + @Override + protected ECSClient generateNewServers() { + ECSClient ecsClient; + try { + final String TEMP_FILE_NAME = "ecs.tmp.config"; + try (PrintWriter writer = new PrintWriter(new FileWriter(TEMP_FILE_NAME))) { + Stream.of( + "server1 ug132 50000" + ).forEach(writer::println); + } + ecsClient = new ECSClient(TEMP_FILE_NAME, ZooKeeperService.LOCALHOST_CONNSTR); + } catch (Exception e) { + throw new RuntimeException("Unable to create ECS", e); + } + + return ecsClient; + } + + @Override + protected int getNumClients() { + return 20; + } + + @Override + protected int getNumServers() { + return 1; + } +} diff --git a/src/testing/performance/Server05Client01PerformanceTest.java b/src/testing/performance/Server05Client01PerformanceTest.java new file mode 100644 index 0000000..bc9eb36 --- /dev/null +++ b/src/testing/performance/Server05Client01PerformanceTest.java @@ -0,0 +1,53 @@ +package testing.performance; + +import app_kvECS.ECSClient; +import client.KVStore; +import ecs.zk.ZooKeeperService; + +import java.io.FileWriter; +import java.io.PrintWriter; +import java.util.List; +import java.util.stream.Collectors; +import java.util.stream.IntStream; +import java.util.stream.Stream; + +public class Server05Client01PerformanceTest extends BasePerformanceTest { + @Override + protected List generateNewClients() { + return IntStream.range(0, getNumClients()) + .mapToObj(i -> new KVStore("ug132", 50000)) + .collect(Collectors.toList()); + } + + @Override + protected ECSClient generateNewServers() { + ECSClient ecsClient; + try { + final String TEMP_FILE_NAME = "ecs.tmp.config"; + try (PrintWriter writer = new PrintWriter(new FileWriter(TEMP_FILE_NAME))) { + Stream.of( + "server1 ug132 50000", + "server2 ug133 50000", + "server3 ug134 50000", + "server4 ug135 50000", + "server5 ug136 50000" + ).forEach(writer::println); + } + ecsClient = new ECSClient(TEMP_FILE_NAME, ZooKeeperService.LOCALHOST_CONNSTR); + } catch (Exception e) { + throw new RuntimeException("Unable to create ECS", e); + } + + return ecsClient; + } + + @Override + protected int getNumClients() { + return 1; + } + + @Override + protected int getNumServers() { + return 5; + } +} diff --git a/src/testing/performance/Server05Client05PerformanceTest.java b/src/testing/performance/Server05Client05PerformanceTest.java new file mode 100644 index 0000000..b9979ab --- /dev/null +++ b/src/testing/performance/Server05Client05PerformanceTest.java @@ -0,0 +1,53 @@ +package testing.performance; + +import app_kvECS.ECSClient; +import client.KVStore; +import ecs.zk.ZooKeeperService; + +import java.io.FileWriter; +import java.io.PrintWriter; +import java.util.List; +import java.util.stream.Collectors; +import java.util.stream.IntStream; +import java.util.stream.Stream; + +public class Server05Client05PerformanceTest extends BasePerformanceTest { + @Override + protected List generateNewClients() { + return IntStream.range(0, getNumClients()) + .mapToObj(i -> new KVStore("ug132", 50000)) + .collect(Collectors.toList()); + } + + @Override + protected ECSClient generateNewServers() { + ECSClient ecsClient; + try { + final String TEMP_FILE_NAME = "ecs.tmp.config"; + try (PrintWriter writer = new PrintWriter(new FileWriter(TEMP_FILE_NAME))) { + Stream.of( + "server1 ug132 50000", + "server2 ug133 50000", + "server3 ug134 50000", + "server4 ug135 50000", + "server5 ug136 50000" + ).forEach(writer::println); + } + ecsClient = new ECSClient(TEMP_FILE_NAME, ZooKeeperService.LOCALHOST_CONNSTR); + } catch (Exception e) { + throw new RuntimeException("Unable to create ECS", e); + } + + return ecsClient; + } + + @Override + protected int getNumClients() { + return 5; + } + + @Override + protected int getNumServers() { + return 5; + } +} diff --git a/src/testing/performance/Server05Client20PerformanceTest.java b/src/testing/performance/Server05Client20PerformanceTest.java new file mode 100644 index 0000000..da7383a --- /dev/null +++ b/src/testing/performance/Server05Client20PerformanceTest.java @@ -0,0 +1,53 @@ +package testing.performance; + +import app_kvECS.ECSClient; +import client.KVStore; +import ecs.zk.ZooKeeperService; + +import java.io.FileWriter; +import java.io.PrintWriter; +import java.util.List; +import java.util.stream.Collectors; +import java.util.stream.IntStream; +import java.util.stream.Stream; + +public class Server05Client20PerformanceTest extends BasePerformanceTest { + @Override + protected List generateNewClients() { + return IntStream.range(0, getNumClients()) + .mapToObj(i -> new KVStore("ug132", 50000)) + .collect(Collectors.toList()); + } + + @Override + protected ECSClient generateNewServers() { + ECSClient ecsClient; + try { + final String TEMP_FILE_NAME = "ecs.tmp.config"; + try (PrintWriter writer = new PrintWriter(new FileWriter(TEMP_FILE_NAME))) { + Stream.of( + "server1 ug132 50000", + "server2 ug133 50000", + "server3 ug134 50000", + "server4 ug135 50000", + "server5 ug136 50000" + ).forEach(writer::println); + } + ecsClient = new ECSClient(TEMP_FILE_NAME, ZooKeeperService.LOCALHOST_CONNSTR); + } catch (Exception e) { + throw new RuntimeException("Unable to create ECS", e); + } + + return ecsClient; + } + + @Override + protected int getNumClients() { + return 20; + } + + @Override + protected int getNumServers() { + return 5; + } +} diff --git a/src/testing/performance/Server10Client01PerformanceTest.java b/src/testing/performance/Server10Client01PerformanceTest.java new file mode 100644 index 0000000..cf6e557 --- /dev/null +++ b/src/testing/performance/Server10Client01PerformanceTest.java @@ -0,0 +1,58 @@ +package testing.performance; + +import app_kvECS.ECSClient; +import client.KVStore; +import ecs.zk.ZooKeeperService; + +import java.io.FileWriter; +import java.io.PrintWriter; +import java.util.List; +import java.util.stream.Collectors; +import java.util.stream.IntStream; +import java.util.stream.Stream; + +public class Server10Client01PerformanceTest extends BasePerformanceTest { + @Override + protected List generateNewClients() { + return IntStream.range(0, getNumClients()) + .mapToObj(i -> new KVStore("ug132", 50000)) + .collect(Collectors.toList()); + } + + @Override + protected ECSClient generateNewServers() { + ECSClient ecsClient; + try { + final String TEMP_FILE_NAME = "ecs.tmp.config"; + try (PrintWriter writer = new PrintWriter(new FileWriter(TEMP_FILE_NAME))) { + Stream.of( + "server1 ug132 50000", + "server2 ug133 50000", + "server3 ug134 50000", + "server4 ug135 50000", + "server5 ug136 50000", + "server6 ug137 50000", + "server7 ug138 50000", + "server8 ug139 50000", + "server9 ug140 50000", + "server10 ug141 50000" + ).forEach(writer::println); + } + ecsClient = new ECSClient(TEMP_FILE_NAME, ZooKeeperService.LOCALHOST_CONNSTR); + } catch (Exception e) { + throw new RuntimeException("Unable to create ECS", e); + } + + return ecsClient; + } + + @Override + protected int getNumClients() { + return 1; + } + + @Override + protected int getNumServers() { + return 10; + } +} diff --git a/src/testing/performance/Server10Client05PerformanceTest.java b/src/testing/performance/Server10Client05PerformanceTest.java new file mode 100644 index 0000000..616f776 --- /dev/null +++ b/src/testing/performance/Server10Client05PerformanceTest.java @@ -0,0 +1,58 @@ +package testing.performance; + +import app_kvECS.ECSClient; +import client.KVStore; +import ecs.zk.ZooKeeperService; + +import java.io.FileWriter; +import java.io.PrintWriter; +import java.util.List; +import java.util.stream.Collectors; +import java.util.stream.IntStream; +import java.util.stream.Stream; + +public class Server10Client05PerformanceTest extends BasePerformanceTest { + @Override + protected List generateNewClients() { + return IntStream.range(0, getNumClients()) + .mapToObj(i -> new KVStore("ug132", 50000)) + .collect(Collectors.toList()); + } + + @Override + protected ECSClient generateNewServers() { + ECSClient ecsClient; + try { + final String TEMP_FILE_NAME = "ecs.tmp.config"; + try (PrintWriter writer = new PrintWriter(new FileWriter(TEMP_FILE_NAME))) { + Stream.of( + "server1 ug132 50000", + "server2 ug133 50000", + "server3 ug134 50000", + "server4 ug135 50000", + "server5 ug136 50000", + "server6 ug137 50000", + "server7 ug138 50000", + "server8 ug139 50000", + "server9 ug140 50000", + "server10 ug141 50000" + ).forEach(writer::println); + } + ecsClient = new ECSClient(TEMP_FILE_NAME, ZooKeeperService.LOCALHOST_CONNSTR); + } catch (Exception e) { + throw new RuntimeException("Unable to create ECS", e); + } + + return ecsClient; + } + + @Override + protected int getNumClients() { + return 5; + } + + @Override + protected int getNumServers() { + return 10; + } +} diff --git a/src/testing/performance/Server10Client20PerformanceTest.java b/src/testing/performance/Server10Client20PerformanceTest.java new file mode 100644 index 0000000..e48b232 --- /dev/null +++ b/src/testing/performance/Server10Client20PerformanceTest.java @@ -0,0 +1,58 @@ +package testing.performance; + +import app_kvECS.ECSClient; +import client.KVStore; +import ecs.zk.ZooKeeperService; + +import java.io.FileWriter; +import java.io.PrintWriter; +import java.util.List; +import java.util.stream.Collectors; +import java.util.stream.IntStream; +import java.util.stream.Stream; + +public class Server10Client20PerformanceTest extends BasePerformanceTest { + @Override + protected List generateNewClients() { + return IntStream.range(0, getNumClients()) + .mapToObj(i -> new KVStore("ug132", 50000)) + .collect(Collectors.toList()); + } + + @Override + protected ECSClient generateNewServers() { + ECSClient ecsClient; + try { + final String TEMP_FILE_NAME = "ecs.tmp.config"; + try (PrintWriter writer = new PrintWriter(new FileWriter(TEMP_FILE_NAME))) { + Stream.of( + "server1 ug132 50000", + "server2 ug133 50000", + "server3 ug134 50000", + "server4 ug135 50000", + "server5 ug136 50000", + "server6 ug137 50000", + "server7 ug138 50000", + "server8 ug139 50000", + "server9 ug140 50000", + "server10 ug141 50000" + ).forEach(writer::println); + } + ecsClient = new ECSClient(TEMP_FILE_NAME, ZooKeeperService.LOCALHOST_CONNSTR); + } catch (Exception e) { + throw new RuntimeException("Unable to create ECS", e); + } + + return ecsClient; + } + + @Override + protected int getNumClients() { + return 20; + } + + @Override + protected int getNumServers() { + return 10; + } +}