News Blog

Our blog's archive is available here.

EuroSys'16 Turorial

A tutorial, Server Benchmarking with CloudSuite 3.0, will be presented on April 18th at EuroSys 2016.

  • Where? In conjunction with EuroSys in London, UK.
  • When? April 18th, 2016.
  • Intended audience: Academic/industrial researchers interested in datacenter workloads and their performance evaluation via both existing state- of-the-art servers and cycle-accurate simulation.
  • Team: Alexandros Daglis, Mario Paulo Drumond, Javier Picorel, Dmitrii Ustiugov, Babak Falsafi
  • Keywords: Scale-out workloads, server benchmarking, rigorous measurement methodologies, performance evaluation.
  • Registration: Please follow the registration link on the conference web page.
  • Slides: Download


Tutorial In Brief

Since its inception, CloudSuite (cloudsuite.ch) has emerged as a popular suite of benchmarks both in industry and among academics for the performance evaluation of cloud services. The EuroCloud Server project blueprinted key optimizations in server SoCs based on the salient features of CloudSuite workloads that lead to an order of magnitude improvement in efficiency while preserving QoS. ARM-based server products (e.g., Cavium ThunderX) have now emerged following these guidelines and showcasing the improved efficiency.

CloudSuite 3.0 is a major enhancement over prior releases both in workloads and infrastructure. It includes benchmarks that represent massive data manipulation with tight latency constraints such as in-memory data analytics using Apache Spark, a new real-time video streaming benchmark following today’s most popular video-sharing website setups, and a new web serving benchmark mirroring today’s multi-tier web server software stacks with a caching layer.

To ease the deployment of CloudSuite into private and public cloud systems, the benchmarks are integrated into the Docker container system and Google’s PerfKit Benchmarker. PerfKit helps at automate the process of benchmarking with a performance comparison across existing cloud server systems. CloudSuite 3.0 will be released and supported to run both on real hardware and a QEMU- based emulation platform.


Organizers

  • Alexandros Daglis is a fourth year PhD student that works at EPFL under the supervision of Babak Falsafi. His research interests include rack-scale computing and datacenter architectures. His current focus is on system design for high performance remote memory access.
  • Javier Picorel is a fifth year PhD student working at EPFL under the supervision of Babak Falsafi. His research interests are in computer architecture, especially architectures and system support for processing-in-memory systems.
  • Mario Paulo Drumond is a second year PhD student that works at EPFL under the supervision of Babak Falsafi. His research interests include reconfigurable computing and computer architecture. His current focus is on using FPGAs to accelerate machine learning algorithms.
  • Dmitrii Ustiugov is a second year PhD student working at EPFL under the supervision of Babak Falsafi and Edouard Bugnion. His research interests include rack-scale computing and datacenter architectures. His current focus is on architectural support for combining high performance and strong consistency for rack-scale systems.

Agenda

Time Slot TopicMaterial
9:30 - 10:30CloudSuite 3.0Overview of CloudSuite 3.0
10:30 - 11:00 Coffee break
11:00 - 12:00CloudSuite 3.0 on Real HardwareRunning CloudSuite on real hardware
12:20 - 14:00Lunch break
14:00 - 15:00CloudSuite 3.0 Full-System SimulationIntroduction to Flexus and its interaction with the QEMU full-system simulator

Setting up a Docker Swarm cluster

Instructions on how to setup a cluster of Docker nodes using Docker Swarm.

This document explains by example how to set up a cluster of Docker nodes (a Docker Swarm), and how to set up an overlay network between nodes in this cluster, so that containers started on the nodes can communicate.

The Docker overlay network requires a key-value store reachable from every node to store the network’s configuration. We will be using Consul for the key-value store, and also for node discovery.

Get images

We will need the Swarm image on all nodes in the cluster.

$ docker pull swarm

We will need the Consul image on one of the nodes.

$ docker pull progrium/consul

Configure Docker daemons

We need to configure Docker daemons running on all nodes to:

  1. Listen on port 2375 for connection from the Swarm manager, in addition to listening on a local Unix socket.
  2. Be able to find the Consul store.
  3. Advertise the Consul host’s IP for the Swarm manager to discover.

On ubuntu, add the following to /etc/default/docker:

$ DOCKER_OPTS="-H unix:///var/run/docker.sock -H tcp://0.0.0.0:2375 \
                --cluster-store consul:/$CONSUL_HOST_IP:8500 \
                --cluster-advertise eth1:2375"

This assumes you have defined the environment variable CONSUL_HOST_IP:

$ export CONSUL_HOST_IP=<Consul node IP>

Then restart the Docker service:

$ sudo service docker restart

Create the key-value store

$ docker run -d -p 8500:8500 --hostname consul --name consul-store progrium/consul -server -bootstrap

Create the Swarm

Start a Swarm agent on each node to advertise the node to Consul:

$ docker run -d --name swarm-agent swarm join \ 
            --advertise=`hostname`:2375 consul://$CONSUL_HOST_IP:8500

Start a Swarm manager on one node (we will use port 22222 as the manager port):

$ docker run -d -p 22222:2375 --name swarm-manager swarm manage \
            consul://$CONSUL_HOST_IP:8500

To verify that the Swarm is set up correctly, you can run:

$ export MANAGER_HOST_IP=<Swarm manager node IP>
$ docker -H tcp://$MANAGER_HOST_IP:22222 info

This should give you the listing of nodes, with the number of containers running on them, among other information. You can also list the advertised nodes with:

$ docker run --rm swarm list consul://$CONSUL_HOST_IP:8500

Create the overlay network

With an overlay network, containers running on different nodes can see each other. This is implemented by adding the container name to the hosts file of all other containers on the network when they are started. To create an overlay network for use with our Swarm:

$ docker -H tcp://$MANAGER_HOST_IP:22222 network create --driver \
            overlay swarm-network

To check that the network is created:

$ docker -H tcp://$MANAGER_HOST_IP:22222 network ls

Example 1: running containers with Swarm and swarm-network

In the example, we will run two containers from the Ubuntu image on different nodes of the cluster (let’s call them nodes n1 and n2), attaching them to the swarm-network overlay network, and ping one from the other for 3s.

Run the containers, and verify that they are running on different nodes from the output of docker ps:

$ docker -H tcp://$MANAGER_HOST_IP:22222 run -itd \
        --net swarm-network -e constraint:node==n1 --name u1 ubuntu
$ docker -H tcp://$MANAGER_HOST_IP:22222 run -itd \
        --net swarm-network -e constraint:node==n2 --name u2 ubuntu
$ docker -H tcp://$MANAGER_HOST_IP:22222 ps

Attach to one of the containers and ping the other:

$ docker -H tcp://$MANAGER_HOST_IP:22222 attach u1
$ ping -w3 u2

Example 2: running Memcached containers with Swarm and swarm-network

In this example, we will run the simplest deployment of CloudSuite’s Data Caching benchmark (i.e., a single client and a single server), where each container runs on a different host. Let’s assume we run the Memcached server on node n1 and the Memcached client on node n2. We assume that the respective Docker images have been pulled to their respective hosts.

Run the server container on n1:

$ docker -H tcp://$MANAGER_HOST_IP:22222 run --net swarm-network \
         -e constraint:node==n1 --name dc-server \
         -d cloudsuite/data-caching:server -t 4 -m 4096 -n 550

Run the client container on n2:

$ docker run -it --net swarm-network --name dc-client \
             cloudsuite/data-caching:client bash

Prepare the client and run its traffic generator, as described here.

Setup environment for Swarm

To avoid typing -H tcp://$MANAGER_HOST_IP:22222 with every docker command you can:

$ export DOCKER_HOST=tcp://$MANAGER_HOST_IP:22222

HiPEAC'16 Tutorial

A tutorial, Server Benchmarking with CloudSuite 3.0, will be presented on January 20th at HiPEAC 2016.

  • Where? In conjunction with HiPEAC in Prague, Czech Republic.
  • When? January 20th, 2016.
  • Intended audience: Academic/industrial researchers interested in datacenter workloads and their performance evaluation via both existing state- of-the-art servers and cycle-accurate simulation.
  • Team: Alexandros Daglis, Mario Paulo Drumond, Javier Picorel, Babak Falsafi
  • Keywords: Scale-out workloads, server benchmarking, rigorous measurement methodologies, performance evaluation.
  • Registration: Please follow the registration link on the conference web page.
  • Slides: Download


Tutorial In Brief

Since its inception, CloudSuite (cloudsuite.ch) has emerged as a popular suite of benchmarks both in industry and among academics for the performance evaluation of cloud services. The EuroCloud Server project blueprinted key optimizations in server SoCs based on the salient features of CloudSuite workloads that lead to an order of magnitude improvement in efficiency while preserving QoS. ARM-based server products (e.g., Cavium ThunderX) have now emerged following these guidelines and showcasing the improved efficiency.

CloudSuite 3.0 is a major enhancement over prior releases both in workloads and infrastructure. It includes benchmarks that represent massive data manipulation with tight latency constraints such as in-memory data analytics using Apache Spark, a new real-time video streaming benchmark following today’s most popular video-sharing website setups, and a new web serving benchmark mirroring today’s multi-tier web server software stacks with a caching layer.

To ease the deployment of CloudSuite into private and public cloud systems, the benchmarks are integrated into the Docker container system and Google’s PerfKit Benchmarker. PerfKit helps at automating the process of benchmarking with a performance comparison across existing cloud server systems. CloudSuite 3.0 will be released and supported to run both on real hardware and a QEMU-based emulation platform.


Organizers

  • Alexandros Daglis is a fourth year PhD student that works at EPFL under the supervision of Babak Falsafi. His research interests include rack-scale computing and datacenter architectures. His current focus is on system design for high performance remote memory access.
  • Javier Picorel is a fifth year PhD student working at EPFL under the supervision of Babak Falsafi. His research interests are in computer architecture, especially architectures and system support for processing-in-memory systems.
  • Mario Drumond is a second year PhD student that works at EPFL under the supervision of Babak Falsafi. His research interests include reconfigurable computing and computer architecture. His current focus is on using FPGAs to acelerate machine learning algorithms.

Agenda

Time Slot TopicMaterial
14:00 - 15:00CloudSuite 3.0Overview of CloudSuite 3.0
15:00 - 15:15 Coffee break
15:15 - 16:15CloudSuite 3.0 on Real Hardware (Docker)Running CloudSuite on real hardware
16:15 - 16:30Coffee break
16:30 - 17:30CloudSuite 3.0 Full-System SimulationIntroduction to Flexus and its interaction with the QEMU full-system simulator