Skip to content

Latest commit

 

History

History
133 lines (84 loc) · 5.2 KB

README.md

File metadata and controls

133 lines (84 loc) · 5.2 KB
Raw

MACSAD

The Multi-Architecture Compiler System for Abstract Dataplanes (MACSAD) is a P4 compiler that uses ODP aiming to archive portability of dataplane applications without compromising the target performance. MACSAD integrates the ODP APIs with P4, defining a programmable dataplane across multiple targets in an unified compiler system. MACSAD has a designed compiler module that generates an Intermediate Representation (IR) for P4 applications.

To run MACSAD, follow the steps below. We have tested on Ubuntu 16.04.

Note: We suggest to install MACSAD using install.sh (inside scripts folder). This script cover all the necessary installation, running it allow the user to skip to section "Running MACSAD".

ODP installation

MACSAD uses ODP for forwarding plane developement.

  1. Download ODP v1.19.0.2, compile and install it:

     apt-get install -y build-essential autoconf automake pkg-config libssl-dev libconfig-dev libtool
 wget https://github.com/Linaro/odp/archive/v1.19.0.2.tar.gz
 tar xzvf v1.19.0.2.tar.gz; rm v1.19.0.2.tar.gz
 mv odp-1.19.0.2/ odp/
 cd odp
 ./bootstrap
 ./configure --disable-abi-compat --prefix=`pwd`/build
 make
 make install

  2. Set the library and pkg-config info for ODP (make sure you are at the root of the ODP build directory before running any of these commands):

     echo `pwd`/build/lib | sudo tee /etc/ld.so.conf.d/odp.conf
 ldconfig
 export PKG_CONFIG_PATH=`pwd`/build/lib/pkgconfig
 echo "export PKG_CONFIG_PATH=`pwd`/build/lib/pkgconfig" >> ~/.bashrc
 cd ..

MACSAD installation

  1. Clone the MACSAD project:

     apt install -y git
 git clone --recursive https://github.com/intrig-unicamp/macsad.git
 cd macsad

  2. MACSAD has added P4-hlir as a submodule. Download/update and then install it (along with its dependencies):

     apt-get install -y python-yaml graphviz python-setuptools
 cd p4-hlir
 python setup.py install --user

    For any issues with p4-hlir, please refer to its README.md file.

  3. Translate the P4 program to MACSAD:

     cd ..
 python src/transpiler.py examples/p4_src/l2_fwd.p4

  4. Install build dependencies, project dependencies and compile MACSAD:

     apt-get install -y autoconf build-essential pkg-config autoconf-archive libpcap-dev python-scapy
 ./autogen.sh
 ./configure
 make

  5. Set hugepages number and create interfaces for the test:

     sysctl -w vm.nr_hugepages=512
 ./scripts/veth_create.sh

Running MACSAD

  1. Start the minimalistic controller (required for installing flows in the switch):

     ./ctrl/mac_controller

    The controller will run in the foreground, so feel free to open another screen or terminal session.

  2. Run the MACSAD switch:

     ./macsad -i veth1,veth2 -c 0 -m 0 --out_mode 0

    NOTE: To allow portability ODP sets a table size limit of 8192, to allow a higher limit:

     sed -i 's/max_queue_size = 8192/max_queue_size = YYY/' /root/odp/config/odp-linux-generic.conf

    Where YYY is the new limit. Then, odp needs to be recompiled. However, this will impact the memory usage and it has a limit of up to 1048576.

  3. Now open a new terminal and we will use the veth interfaces created in step #5. veth1 and veth2 will be part of the switch. We will send packet to veth0 (which is veth1's pair) and monitor at veth3 (which is veth2's pair) for packets. Similary we will send packet to veth3 and expect packets to arrive at veth0:

     cd /root/macsad
 python run_test.py

    You should see output similar to this:

     $ python run_test.py
 WARNING: No route found for IPv6 destination :: (no default route?)
 Sending 1 packets to  veth3 ...
 DISTRIBUTION:
 port veth0:   1 [ 100.0% ]
 port veth3:   1 [ 100.0% ]

Optionally we can manually build our packet using scapy, this step is explained on our next section.

MANUALLY BUILD/SEND PACKETS USING SCAPY (OPTIONAL)

We will use veth'x' interfaces with this example. Veth1 and veth2 will be part of the switch. We will send packet to veth0 and monitor at veth3. Similary we will send packet to veth3 and recieve the packets at veth0.

It is necessary to use the MAC addresses of veth1 and veth2 interfaces while forming the packets.

Let us assume that the MAC addresses are:

veth3 - a2:5e:37:ac:a1:7f

veth0 - fa:4f:e8:df:b1:5f

$ scapy
>>> pkt2 = Ether(dst='a2:5e:37:ac:a1:7f',src='fa:4f:e8:df:b1:5f')/IP(dst='192.168.0.2',src='192.168.0.1')
>>> sendp(pkt2,iface="veth0",count=1);

The first packet with an unknown destination mac address will be broadcasted by the switch while the source mac address is learned. Now after the two packets were sent, the switch has already learned the mac addresses of veth0 and veth3. Now if we send those packets again, switch will forward those packets via corresponding ports instead of broadcasting them.

Usecases

Other tested P4 usecases with its dependency graphs can be found at macsad-usecases repository.

Acknowledgment

This work was supported by the Innovation Center, Ericsson Telecomunicações S.A., Brazil under grant agreement UNI.61.