├── iisy_sw
    ├── simple_example
    │   ├── decision_tree
    │   │   ├── action.txt
    │   │   ├── topology.json
    │   │   ├── tree.txt
    │   │   ├── Makefile
    │   │   ├── decision_tree.p4
    │   │   └── mycontroller.py
    │   ├── kmeans
    │   │   ├── topology.json
    │   │   ├── Makefile
    │   │   ├── mycontroller.py
    │   │   └── kmeans.p4
    │   ├── naive_bayes
    │   │   ├── topology.json
    │   │   ├── Makefile
    │   │   ├── mycontroller.py
    │   │   └── bayes.p4
    │   ├── svm
    │   │   ├── topology.json
    │   │   ├── Makefile
    │   │   ├── mycontroller.py
    │   │   └── svm.p4
    │   └── readme.md
    ├── framework
    │   ├── action.txt
    │   ├── README.md
    │   ├── Makefile
    │   ├── Extractfeature.py
    │   ├── svm.py
    │   ├── kmeans.py
    │   ├── Machinelearning.py
    │   ├── naivebayes.py
    │   ├── basic.p4
    │   ├── Runtime.py
    │   └── mycontroller.py
    └── IoT_ML
    │   ├── README.md
    │   ├── iot_kmeans.py
    │   ├── iot_svm.py
    │   ├── iot_naivebayes.py
    │   └── iot_decisiontree.py
├── trace_processing
    ├── replacement_numeric
    ├── README.md
    └── set_features.sh
├── iisy_hw
    ├── README.md
    ├── iisy_decision_tree.p4
    ├── iisy_naive_bayes.p4
    ├── iisy_kmeans.p4
    ├── iisy_svm.p4
    └── commands.txt
└── README.md


/iisy_sw/simple_example/decision_tree/action.txt:
--------------------------------------------------------------------------------
1 | Drop : 0
2 | Forward to port 2: 2
3 | Forward to port 3: 3
4 | Forward to port 4: 4
5 | class 0: [3]
6 | class 1: [3]
7 | class 2: [3]
8 | class 3: [3]
9 | class 4: [2]


--------------------------------------------------------------------------------
/iisy_sw/framework/action.txt:
--------------------------------------------------------------------------------
 1 | Drop : 0
 2 | Forward to port 2: 2
 3 | Forward to port 3: 3
 4 | Forward to port 4: 4
 5 | class 0: [2]
 6 | class 1: [3]
 7 | class 2: [4]
 8 | class 3: [3]
 9 | class 4: [2]
10 | 
11 | 
12 | 


--------------------------------------------------------------------------------
/iisy_sw/simple_example/kmeans/topology.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "hosts": [
 3 |         "h1",
 4 |         "h2"
 5 |     ],
 6 |     "switches": {
 7 |         "s1": {  }
 8 |     },
 9 |     "links": [
10 |         ["h1", "s1"], ["s1", "h2"],["s1", "h3"],["s1", "h4"]
11 | 
12 |     ]
13 | }


--------------------------------------------------------------------------------
/iisy_sw/simple_example/naive_bayes/topology.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "hosts": [
 3 |         "h1",
 4 |         "h2"
 5 |     ],
 6 |     "switches": {
 7 |         "s1": {  }
 8 |     },
 9 |     "links": [
10 |         ["h1", "s1"], ["s1", "h2"],["s1", "h3"],["s1", "h4"]
11 | 
12 |     ]
13 | }


--------------------------------------------------------------------------------
/iisy_sw/simple_example/decision_tree/topology.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "hosts": [
 3 |         "h1",
 4 |         "h2"
 5 |     ],
 6 |     "switches": {
 7 |         "s1": {  }
 8 |     },
 9 |     "links": [
10 |         ["h1", "s1"], ["s1", "h2"],["s1", "h3"],["s1", "h4"]
11 | 
12 |     ]
13 | }


--------------------------------------------------------------------------------
/iisy_sw/simple_example/svm/topology.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "hosts": [
 3 |         "h1",
 4 |         "h2",
 5 |         "h3"
 6 |     ],
 7 |     "switches": {
 8 |         "s1": {  }
 9 |     },
10 |     "links": [
11 |         ["h1", "s1"], ["s1", "h2"],["s1", "h3"],["s1", "h4"]
12 | 
13 |     ]
14 | }


--------------------------------------------------------------------------------
/iisy_sw/IoT_ML/README.md:
--------------------------------------------------------------------------------
1 | # IoT Traces Analysis
2 | 
3 | This folder contains the scripts to run the IoT traces through the training of four different machine learning models, using scikit-learn.
4 | 
5 | To invoke the scripts, use:
6 | python3 <script name> -i <training dataset, csv format> -t <test dataset, csv format> -o <output file> 


--------------------------------------------------------------------------------
/trace_processing/replacement_numeric:
--------------------------------------------------------------------------------
 1 | ec:1a:59:7A:02:C5/0
 2 | ec:1a:59:83:28:11/0
 3 | ec:1a:59:79:f4:89/0
 4 | d0:73:d5:01:83:08/0
 5 | 70:88:6b:10:0f:c6/1
 6 | 70:ee:50:03:b8:ac/1
 7 | 00:24:e4:20:28:c6/1
 8 | 18:b4:30:25:be:e4/1
 9 | f4:f5:d8:d4:eb:12/2
10 | 44:65:0d:56:cc:d3/2
11 | 00:16:6c:ab:6b:88/3
12 | 88:4a:ea:31:66:9d/3
13 | 70:ee:50:18:34:43/3
14 | 7c:70:bc:5d:5e:dc/3
15 | 30:8c:fb:2f:e4:b2/3
16 | 18:b7:9e:02:20:44/2
17 | 28:c2:dd:ff:a5:2d/2
18 | 00:24:e4:44:68:44/0
19 | 74:6A:89:00:2E:25/0
20 | B4:75:0E:EC:E5:A9/3
21 | F4:F2:6D:93:51:F1/3
22 | 74:c6:3b:29:d7:1d/0
23 | e0:76:d0:3f:00:ae/3
24 | 84:F3:EB:52:42:DB/0
25 | F4:F5:D8:8F:0A:3C/3
26 | 


--------------------------------------------------------------------------------
/iisy_sw/simple_example/decision_tree/tree.txt:
--------------------------------------------------------------------------------
 1 | proto = [];
 2 | src = [11, 22157, 23505, 43174, 49930];
 3 | dst = [6039, 9144, 22157];
 4 |  when src<=11.0  then 2;
 5 |  when src>11.0 and dst<=6039.0 and src<=23505.5  then 0;
 6 |  when src>11.0 and dst<=6039.0 and src>23505.5 and src<=49930.0  then 4;
 7 |  when src>11.0 and dst<=6039.0 and src>23505.5 and src>49930.0  then 3;
 8 |  when src>11.0 and dst>6039.0 and src<=43174.5 and dst<=22157.5 and dst<=9144.0  then 4;
 9 |  when src>11.0 and dst>6039.0 and src<=43174.5 and dst<=22157.5 and dst>9144.0  then 1;
10 |  when src>11.0 and dst>6039.0 and src<=43174.5 and dst>22157.5 and src<=22157.5  then 1;
11 |  when src>11.0 and dst>6039.0 and src<=43174.5 and dst>22157.5 and src>22157.5  then 3;
12 |  when src>11.0 and dst>6039.0 and src>43174.5  then 4;
13 | 


--------------------------------------------------------------------------------
/trace_processing/README.md:
--------------------------------------------------------------------------------
 1 | # Trace Processing
 2 | 
 3 | This folder contains the script required to extract data from traces and assign labels. It is customized to the IoT packet classification use case, but can be easily adapted to other use cases.
 4 | Labels are assigned based on the MAC address of the devices, where each MAC address is substituted for the class number.
 5 | 
 6 | The classes are enumerated as follows:
 7 | 0 - Static smart
 8 | 1 - Sensors
 9 | 2 - Audio
10 | 3 - Video
11 | 4 - Others
12 | 
13 | pcap files are expected to be in a sub-folder called original_files, and the processed files are created in a sub-folder called csv_files. These paths can be changed within the script.
14 | 
15 | The file replacement numeric provides a mapping of a MAC address to a numeric class substitute.
16 | 
17 | To invoke the script, use ./set_features.sh replacement_numeric
18 | 
19 | Dependencies: python, tshark


--------------------------------------------------------------------------------
/iisy_sw/simple_example/svm/Makefile:
--------------------------------------------------------------------------------
 1 | #################################################################################
 2 | #
 3 | # Copyright (c) 2019 Zhaoqi Xiong
 4 | # All rights reserved.
 5 | #
 6 | #
 7 | # @NETFPGA_LICENSE_HEADER_START@
 8 | #
 9 | # Licensed to NetFPGA C.I.C. (NetFPGA) under one or more contributor
10 | # license agreements.  See the NOTICE file distributed with this work for
11 | # additional information regarding copyright ownership.  NetFPGA licenses this
12 | # file to you under the NetFPGA Hardware-Software License, Version 1.0 (the
13 | # "License"); you may not use this file except in compliance with the
14 | # License.  You may obtain a copy of the License at:
15 | #
16 | #   http://www.netfpga-cic.org
17 | #
18 | # Unless required by applicable law or agreed to in writing, Work distributed
19 | # under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
20 | # CONDITIONS OF ANY KIND, either express or implied.  See the License for the
21 | # specific language governing permissions and limitations under the License.
22 | #
23 | # @NETFPGA_LICENSE_HEADER_END@
24 | #
25 | #################################################################################  
26 | 
27 | BMV2_SWITCH_EXE = simple_switch_grpc
28 | NO_P4 = true
29 | P4C_ARGS = --p4runtime-file $(basename $@).p4info --p4runtime-format text
30 | 
31 | include ../../utils/Makefile
32 | 


--------------------------------------------------------------------------------
/iisy_sw/simple_example/kmeans/Makefile:
--------------------------------------------------------------------------------
 1 | #################################################################################
 2 | #
 3 | # Copyright (c) 2019 Zhaoqi Xiong
 4 | # All rights reserved.
 5 | #
 6 | #
 7 | # @NETFPGA_LICENSE_HEADER_START@
 8 | #
 9 | # Licensed to NetFPGA C.I.C. (NetFPGA) under one or more contributor
10 | # license agreements.  See the NOTICE file distributed with this work for
11 | # additional information regarding copyright ownership.  NetFPGA licenses this
12 | # file to you under the NetFPGA Hardware-Software License, Version 1.0 (the
13 | # "License"); you may not use this file except in compliance with the
14 | # License.  You may obtain a copy of the License at:
15 | #
16 | #   http://www.netfpga-cic.org
17 | #
18 | # Unless required by applicable law or agreed to in writing, Work distributed
19 | # under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
20 | # CONDITIONS OF ANY KIND, either express or implied.  See the License for the
21 | # specific language governing permissions and limitations under the License.
22 | #
23 | # @NETFPGA_LICENSE_HEADER_END@
24 | #
25 | #################################################################################  
26 | 
27 | BMV2_SWITCH_EXE = simple_switch_grpc
28 | NO_P4 = true
29 | P4C_ARGS = --p4runtime-file $(basename $@).p4info --p4runtime-format text
30 | 
31 | include ../../utils/Makefile
32 | 


--------------------------------------------------------------------------------
/iisy_sw/simple_example/decision_tree/Makefile:
--------------------------------------------------------------------------------
 1 | #################################################################################
 2 | #
 3 | # Copyright (c) 2019 Zhaoqi Xiong
 4 | # All rights reserved.
 5 | #
 6 | #
 7 | # @NETFPGA_LICENSE_HEADER_START@
 8 | #
 9 | # Licensed to NetFPGA C.I.C. (NetFPGA) under one or more contributor
10 | # license agreements.  See the NOTICE file distributed with this work for
11 | # additional information regarding copyright ownership.  NetFPGA licenses this
12 | # file to you under the NetFPGA Hardware-Software License, Version 1.0 (the
13 | # "License"); you may not use this file except in compliance with the
14 | # License.  You may obtain a copy of the License at:
15 | #
16 | #   http://www.netfpga-cic.org
17 | #
18 | # Unless required by applicable law or agreed to in writing, Work distributed
19 | # under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
20 | # CONDITIONS OF ANY KIND, either express or implied.  See the License for the
21 | # specific language governing permissions and limitations under the License.
22 | #
23 | # @NETFPGA_LICENSE_HEADER_END@
24 | #
25 | #################################################################################  
26 | 
27 | BMV2_SWITCH_EXE = simple_switch_grpc
28 | NO_P4 = true
29 | P4C_ARGS = --p4runtime-file $(basename $@).p4info --p4runtime-format text
30 | 
31 | include ../../utils/Makefile
32 | 


--------------------------------------------------------------------------------
/iisy_sw/simple_example/naive_bayes/Makefile:
--------------------------------------------------------------------------------
 1 | #################################################################################
 2 | #
 3 | # Copyright (c) 2019 Zhaoqi Xiong
 4 | # All rights reserved.
 5 | #
 6 | #
 7 | # @NETFPGA_LICENSE_HEADER_START@
 8 | #
 9 | # Licensed to NetFPGA C.I.C. (NetFPGA) under one or more contributor
10 | # license agreements.  See the NOTICE file distributed with this work for
11 | # additional information regarding copyright ownership.  NetFPGA licenses this
12 | # file to you under the NetFPGA Hardware-Software License, Version 1.0 (the
13 | # "License"); you may not use this file except in compliance with the
14 | # License.  You may obtain a copy of the License at:
15 | #
16 | #   http://www.netfpga-cic.org
17 | #
18 | # Unless required by applicable law or agreed to in writing, Work distributed
19 | # under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
20 | # CONDITIONS OF ANY KIND, either express or implied.  See the License for the
21 | # specific language governing permissions and limitations under the License.
22 | #
23 | # @NETFPGA_LICENSE_HEADER_END@
24 | #
25 | #################################################################################   
26 | 
27 | BMV2_SWITCH_EXE = simple_switch_grpc
28 | NO_P4 = true
29 | P4C_ARGS = --p4runtime-file $(basename $@).p4info --p4runtime-format text
30 | 
31 | include ../../utils/Makefile
32 | 


--------------------------------------------------------------------------------
/iisy_hw/README.md:
--------------------------------------------------------------------------------
 1 | This folder contains the source files for the implementation of IIsy in P4-NetFPGA on NetFPGA-SUME, for the IoT use case.
 2 | 
 3 | To use this code you will need the P4-NetFPGA repository: https://github.com/NetFPGA/P4-NetFPGA-live/ (open source, but requires registration through https://goo.gl/forms/h7RbYmKZL7H4EaUf1).
 4 | 
 5 | The P4-NetFPGA commit used in this work was 5bd666ec8dcff3c7bb182e3654851e275f2ddf52 (May 8, 2019).
 6 | 
 7 | The code should be placed under $P4_DESIGN_DIR/src.  
 8 | The easiest way to compile the code is to update $SUME_FOLDER/tools/settings.sh, setting P4_PROJECT_NAME to iisy and using the p4 file of your choice. We used switch_calc as the base design that was replicated (i.e. 'cp -r switch_calc iisy').
 9 | 
10 | The files in this folder are as follows:
11 | 
12 | 1. iisy_decision_tree.p4 - The P4 implementation of a decision tree for NetFPGA.
13 | 
14 | 2. iisy_svm.p4 - The P4 implementation of SVM for NetFPGA. 
15 | 
16 | 3. iisy_naive_bayes.p4 - The P4 implementation of Naive Bayes for NetFPGA.
17 | 
18 | 4. iisy_kmeans.p4 - The P4 implementation of K-means for NetFPGA.
19 | 
20 | 5. commands.txt - The control plane generation file, matching the decision tree use case.
21 | 
22 | The bitfiles (compiled files to the NetFPGA target) can be found under https://www.cl.cam.ac.uk/research/srg/netos/projects/iisy. 
23 | They can not be included here due to Xilinx license restrictions.
24 | 
25 | 
26 | 


--------------------------------------------------------------------------------
/iisy_sw/simple_example/readme.md:
--------------------------------------------------------------------------------
 1 | # Simple use case example
 2 | 
 3 | ## Introduction
 4 | This example uses two parts of project's code:
 5 | 
 6 | 1. ML training and model output: (../framwork)
 7 | 
 8 | 2. The data plane and control plane for each algorithm (naive bayes, kmeans, decision tree, svm) 
 9 | 
10 | ## Environment Configuration:
11 | 
12 | We use the P4 tutorial VM as a simple environment for this example 
13 | 
14 | 1. Install the P4 tutorial Virtual Machine:
15 | 
16 | * Download the virtual machine image
17 | 
18 | * Install VirtualBox
19 | 
20 | * Build the virtual machine from source
21 | 
22 | For the exact environment used in this example, follow the instructions on: https://p4.org/events/2018-06-06-p4-developer-day/
23 | 
24 | 2. Clone the p4 tutorial repo: 
25 | https://github.com/p4lang/tutorials
26 | 
27 | 3. Install required packages: panda, scapy, sklearn, json.
28 | 
29 | ## Framework
30 | 
31 | The framework folder has the scripts necessary for feature extraction, model training and control plane generation.
32 | 
33 | Detailed information can be found in the readme.md of the folder.
34 | 
35 | ## naive bayes/kmeans/decision tree/svm
36 | 
37 | These folders are include simple devices built for the algorithms in use.
38 | 
39 | All the folders contain a p4 file and a p4runtime file (mycontroller.py) to build the device.
40 | 
41 | ## Evaluation
42 | 
43 | 1. Build the program in virtual machine:
44 | 
45 | make build: 
46 | 
47 | 2. start the Mininet hosts:
48 | 
49 | xterm h1 h2..
50 | 
51 | 3. send packets and received packets using the code in evaluation folder (known low performance).
52 | 


--------------------------------------------------------------------------------
/iisy_sw/framework/README.md:
--------------------------------------------------------------------------------
 1 | # Intro
 2 | 
 3 | The framework provided under this folder implements a simple use case, where traffic from different applications is mapped to different ports.
 4 | 
 5 | # Framework 
 6 | 
 7 | There are three scripts in the framework:
 8 | 
 9 | ## Extractfeature.py
10 | 
11 | ### usage: ./Extractfeature.py -i [input pcap file] -o [output csv file]
12 | 
13 | Read the pcap file and convert to csv file. Extracts features: protocol, source port and destination port.
14 | 
15 | ## Machinelearning.py
16 | ### usage: ./Machinelearning.py -i [csv file with label] -t [test csv file] -o [output txt file] 
17 | 
18 | Read the csv file and print the rules of a decision tree model into a txt file.
19 | 
20 | kmeans.py, svm.py and naivebayes.py provide similar functionality but for different training algorithms. 
21 | Substitute the file to use.
22 | 
23 | ## Runtime.py
24 | ### usage:  ./Runtime.py -i [input txt file] -o [output json file]
25 | 
26 | Reads the text file describing the rules of a  decision tree and outputs the json file which defines the table entries.
27 | 
28 | # Makefile: 
29 | ## make clean: 
30 | remove the results file
31 | ## make build:
32 | build the results file
33 | ## make class -i M(input file) -c (classification)
34 | runs the Extract feature value
35 | ## make tree
36 | runs the Machine learning script
37 | ## make runtime
38 | runs the Runtime script
39 | # Other files
40 | ## action.txt:
41 | Used for changing actions of different classes.
42 | 
43 | ## basic.p4
44 | General p4 program for a switch data plane
45 | 
46 | ## mycontroller.py
47 | p4runtime program (control plane of the switch)
48 | 


--------------------------------------------------------------------------------
/iisy_sw/framework/Makefile:
--------------------------------------------------------------------------------
 1 | #################################################################################
 2 | #
 3 | # Copyright (c) 2019 Zhaoqi Xiong
 4 | # All rights reserved.
 5 | #
 6 | #
 7 | # @NETFPGA_LICENSE_HEADER_START@
 8 | #
 9 | # Licensed to NetFPGA C.I.C. (NetFPGA) under one or more contributor
10 | # license agreements.  See the NOTICE file distributed with this work for
11 | # additional information regarding copyright ownership.  NetFPGA licenses this
12 | # file to you under the NetFPGA Hardware-Software License, Version 1.0 (the
13 | # "License"); you may not use this file except in compliance with the
14 | # License.  You may obtain a copy of the License at:
15 | #
16 | #   http://www.netfpga-cic.org
17 | #
18 | # Unless required by applicable law or agreed to in writing, Work distributed
19 | # under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
20 | # CONDITIONS OF ANY KIND, either express or implied.  See the License for the
21 | # specific language governing permissions and limitations under the License.
22 | #
23 | # @NETFPGA_LICENSE_HEADER_END@
24 | #
25 | ################################################################################# 
26 | 
27 | BUILD_DIR = results
28 | 
29 | Extract_SCRIPT = ./Extractfeature.py
30 | Csv = ./results/feature.csv
31 | 
32 | 
33 | ML = ./Machinelearning.py
34 | Decision = ./results/tree.txt
35 | 
36 | Runtime =  ./Runtime.py
37 | Json = ./results/runtime.json
38 | Action = ./action.txt
39 | 
40 | build: 
41 | 	mkdir results
42 | 
43 | class:
44 | 	$(Extract_SCRIPT) -i $(M) -o $(Csv) -c $(C)
45 | 
46 | 	
47 | tree:
48 | 	$(ML) -i $(Csv) -o $(Decision)
49 | 
50 | runtime:
51 | 	$(Runtime) -i1 $(Decision) -i2 $(Action) -o $(Json)
52 | 	
53 | 
54 | clean: 
55 | 	rm -rf $(BUILD_DIR) 
56 | 
57 | 	
58 |       
59 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # IIsy - In Network Inference Made Easy
 2 | 
 3 | # Introduction
 4 | 
 5 | In-network classification refers to taking classification decision within network devices (e.g., switches, NICs), as the data goes through the network.
 6 | 
 7 | IIsy is a framework that maps the output of a machine learning training framework to a programmable network device. Currently IIsy supports scikit-learn as the training framework. Two network-device targets are currently supported by IIsy: bmv2 and NetFPGA SUME.
 8 | 
 9 | bmv2 is a behavioral model of a P4-based switch, and it is used with the v1model architecture. The switch is emulated using Mininet. P4Runtime is used for the control plane.
10 | 
11 | NetFPGA SUME is an open source platform for rapid prototyping of network devices. The board uses the Xilinx Virtex-7 690T FPGA and utilizes 4x10GE ports. Here, the board is used with the P4->NetFPGA workflow and the SimpleSumeSwitch architecture. The control plane is P4->NetFPGA proprietary.
12 | 
13 | # Installation
14 | 
15 | As each component under this repository is independent, installation instructions and dependencies are listed separately under each folder. This means that you can run the software environment without installing the NetFPGA environment and vice versa. 
16 | 
17 | # Structure
18 | 
19 | The repository is structured as follows:
20 | 
21 | 1. trace_processing - The trace_processing folder is used by the training stage. It is used to convert trace files (pcap format) to text files (csv format) that can be processed by the ML framework (scikit-learn), and adds labels. The labelling fits the classes we used in this work.
22 | 
23 | 2. iisy_sw - The software components of IIsy. This folder includes both the ML training scripts and the mapping from ML-training to the software switch.
24 | 
25 | 3. iisy_hw - The hardware implementation of IIsy over NetFPGA SUME, using P4-NetFPGA.
26 | 
27 | Refer to the README files under each folder for more information.
28 | 
29 | # License
30 | 
31 | This project is released under the NetFPGA C.I.C license (http://netfpga-cic.org/)
32 | 
33 | The NetFPGA C.I.C license is a modified version of Apache License Version 2.0 to support also hardware targets.
34 | 
35 | # Citation
36 | 
37 | When referencing this work, please use the following citation:
38 | 
39 | [1] Zhaoqi Xiong and Noa Zilberman, "Do Switches Dream of Machine Learning? Toward In-Network Classification", In the Proceedings of ACM Workshop on Hot Topics in Networks (HotNets), 2019.
40 | 
41 | An open access version of the paper is available at https://doi.org/10.17863/CAM.45171.
42 | 


--------------------------------------------------------------------------------
/trace_processing/set_features.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | #################################################################################
 3 | #
 4 | # Copyright (c) 2019 Noa Zilberman
 5 | # All rights reserved.
 6 | #
 7 | #
 8 | # @NETFPGA_LICENSE_HEADER_START@
 9 | #
10 | # Licensed to NetFPGA C.I.C. (NetFPGA) under one or more contributor
11 | # license agreements.  See the NOTICE file distributed with this work for
12 | # additional information regarding copyright ownership.  NetFPGA licenses this
13 | # file to you under the NetFPGA Hardware-Software License, Version 1.0 (the
14 | # "License"); you may not use this file except in compliance with the
15 | # License.  You may obtain a copy of the License at:
16 | #
17 | #   http://www.netfpga-cic.org
18 | #
19 | # Unless required by applicable law or agreed to in writing, Work distributed
20 | # under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
21 | # CONDITIONS OF ANY KIND, either express or implied.  See the License for the
22 | # specific language governing permissions and limitations under the License.
23 | #
24 | # @NETFPGA_LICENSE_HEADER_END@
25 | #
26 | #################################################################################
27 | #
28 | # Description: this file takes as input a folder with pcap files, and converts them
29 | # to CSV files. It extracts just specific features form the file, e.g., frame len,
30 | # Ether type, IP protocols etc.
31 | #
32 | # You will need python and tshark installed to run this code
33 | #
34 | 
35 | FILES=$(find original_files/ -type f)
36 | TARGET='csv_files'
37 | 
38 | echo "Usage: ./set_features.py <substitution file>"
39 | 
40 | for file in $FILES; do
41 |     echo "${file}"
42 |     rm tmp
43 |     ofile="$(cut -d'/' -f2 <<<"$file" |cut -d'.' -f1)"
44 |     tshark -r ${file} -Tfields -E occurrence=f -E separator=, -e frame.len -e eth.type -e ip.proto -e ip.flags -e ipv6.nxt -e ipv6.opt -e tcp.srcport -e tcp.dstport -e tcp.flags -e udp.srcport -e udp.dstport  -e eth.src > ${ofile}.csv
45 |     cp ${ofile}.csv  else.csv
46 |     while IFS= read -r line
47 |     do
48 |       MAC="$(echo $line |cut -d/ -f1)"
49 |       grep -i $MAC ${ofile}.csv |sed  "s/$line/gI" >>tmp
50 |       grep -v -i $MAC else.csv >else1.csv
51 |       mv else1.csv else.csv
52 |     done < "$1"
53 |     mv tmp ${TARGET}/${ofile}-labeled.csv
54 |     rm ${ofile}.csv
55 |     cat else.csv | sed 's/.\{17\}$/4/' >> ${TARGET}/${ofile}-labeled.csv
56 |     cat ${TARGET}/${ofile}-labeled.csv |sed 's/,,/,-1,/gI' | sed 's/,,/,-1,/gI' > ${TARGET}/${ofile}-labeled.csv1
57 |     mv ${TARGET}/${ofile}-labeled.csv1 ${TARGET}/${ofile}-labeled.csv 
58 | done
59 | 


--------------------------------------------------------------------------------
/iisy_sw/framework/Extractfeature.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | #################################################################################
 3 | #
 4 | # Copyright (c) 2019 Zhaoqi Xiong
 5 | # All rights reserved.
 6 | #
 7 | #
 8 | # @NETFPGA_LICENSE_HEADER_START@
 9 | #
10 | # Licensed to NetFPGA C.I.C. (NetFPGA) under one or more contributor
11 | # license agreements.  See the NOTICE file distributed with this work for
12 | # additional information regarding copyright ownership.  NetFPGA licenses this
13 | # file to you under the NetFPGA Hardware-Software License, Version 1.0 (the
14 | # "License"); you may not use this file except in compliance with the
15 | # License.  You may obtain a copy of the License at:
16 | #
17 | #   http://www.netfpga-cic.org
18 | #
19 | # Unless required by applicable law or agreed to in writing, Work distributed
20 | # under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
21 | # CONDITIONS OF ANY KIND, either express or implied.  See the License for the
22 | # specific language governing permissions and limitations under the License.
23 | #
24 | # @NETFPGA_LICENSE_HEADER_END@
25 | #
26 | ################################################################################# 
27 | 
28 | from scapy.all import *
29 | import numpy as np
30 | import pandas as pd
31 | import argparse
32 | import os
33 | 
34 | parser = argparse.ArgumentParser()
35 | 
36 | # Add argument
37 | parser.add_argument('-i', required=True, help='path to dataset')
38 | parser.add_argument('-o', required=True, help='output path')
39 | parser.add_argument('-c', required=True, help='classification')
40 | args = parser.parse_args()
41 | 
42 | # extract argument value
43 | inputfile = args.i
44 | outputfile = args.o
45 | classification =int(args.c)
46 | 
47 | 
48 | #read the pcap file and extract the features for each packet
49 | results = []
50 | all_packets = rdpcap(inputfile)
51 | for packet in all_packets:
52 |     size =  len(packet)
53 |     try:
54 |         proto = packet.proto
55 |     except AttributeError:
56 |         proto = 0
57 |     try:
58 |         sport = packet.sport
59 |         dport = packet.dport
60 |     except AttributeError:
61 |         sport = 0
62 |         dport = 0
63 | 
64 |     proto = int(proto)
65 |     sport = int(sport)
66 |     dport = int(dport)
67 | 
68 |     metric = [proto,sport,dport,classification]
69 |     results.append(metric)
70 | results = (np.array(results)).T
71 | 
72 | # store the features in the dataframe
73 | dataframe = pd.DataFrame({'protocl':results[0],'src':results[1],'dst':results[2],'classfication':results[3]})
74 | columns = ['protocl','src','dst','classfication']
75 | 
76 | # save the dataframe to the csv file, if not exsit, create one.
77 | if os.path.exists(outputfile):
78 |     dataframe.to_csv(outputfile,index=False,sep=',',mode='a',columns = columns, header=False)
79 | else:
80 |     dataframe.to_csv(outputfile,index=False,sep=',',columns = columns)
81 | 
82 | 
83 | 


--------------------------------------------------------------------------------
/iisy_sw/framework/svm.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python
  2 | #################################################################################
  3 | #
  4 | # Copyright (c) 2019 Zhaoqi Xiong
  5 | # All rights reserved.
  6 | #
  7 | #
  8 | # @NETFPGA_LICENSE_HEADER_START@
  9 | #
 10 | # Licensed to NetFPGA C.I.C. (NetFPGA) under one or more contributor
 11 | # license agreements.  See the NOTICE file distributed with this work for
 12 | # additional information regarding copyright ownership.  NetFPGA licenses this
 13 | # file to you under the NetFPGA Hardware-Software License, Version 1.0 (the
 14 | # "License"); you may not use this file except in compliance with the
 15 | # License.  You may obtain a copy of the License at:
 16 | #
 17 | #   http://www.netfpga-cic.org
 18 | #
 19 | # Unless required by applicable law or agreed to in writing, Work distributed
 20 | # under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
 21 | # CONDITIONS OF ANY KIND, either express or implied.  See the License for the
 22 | # specific language governing permissions and limitations under the License.
 23 | #
 24 | # @NETFPGA_LICENSE_HEADER_END@
 25 | #
 26 | ################################################################################# 
 27 | from sklearn.svm import SVC
 28 | from sklearn.svm import LinearSVC
 29 | from sklearn.naive_bayes import GaussianNB
 30 | import numpy as np
 31 | import pandas as pd
 32 | import argparse
 33 | 
 34 | from sklearn.metrics import accuracy_score
 35 | 
 36 | import pydotplus
 37 | 
 38 | 
 39 | from sklearn.metrics import accuracy_score
 40 | from sklearn.metrics import classification_report
 41 | from sklearn.tree import export_graphviz
 42 | import pydotplus
 43 | from sklearn.metrics import confusion_matrix
 44 | import matplotlib.pyplot as plt
 45 | from sklearn import linear_model 
 46 | 
 47 | 
 48 | 
 49 | parser = argparse.ArgumentParser()
 50 | 
 51 | # Add argument
 52 | parser.add_argument('-i', required=True, help='path to dataset')
 53 | parser.add_argument('-o', required=True, help='path to outputfile')
 54 | parser.add_argument('-t', required=True, help='path to testfile')
 55 | args = parser.parse_args()
 56 | 
 57 | # extract argument
 58 | input = args.i
 59 | outputfile = args.o
 60 | testfile = args.t
 61 | 
 62 | 
 63 | # Training set X and Y
 64 | Set1 = pd.read_csv(input)
 65 | Set = Set1.values.tolist()
 66 | X = [i[0:3] for i in Set]
 67 | Y =[i[3] for i in Set]
 68 | class_names=['iperf','memcached','ping','sparkglm','sparkkmeans']
 69 | feature_names=['proto','src','dst']
 70 | 
 71 | # Test set Xt and Yt
 72 | Set2 = pd.read_csv(input)
 73 | Sett = Set2.values.tolist()
 74 | Xt = [i[0:3] for i in Set]
 75 | Yt =[i[3] for i in Set]
 76 | 
 77 | # prepare training and testing set
 78 | X = np.array(X)
 79 | Y = np.array(Y)
 80 | Xt = np.array(Xt)
 81 | Yt = np.array(Yt)
 82 | 
 83 | # svm fit
 84 | clf = SVC(kernel = 'linear')
 85 | clf.fit(X, Y)
 86 | Predict_Y = clf.predict(X)
 87 | print(accuracy_score(Y, Predict_Y))
 88 | 
 89 | Predict_Yt = clf.predict(Xt)
 90 | print(accuracy_score(Yt, Predict_Yt))
 91 | 
 92 | # output the model in a text file, wirte it
 93 | coe = clf.coef_
 94 | int = clf.intercept_
 95 | 
 96 | model = open(outputfile,"w+")
 97 | for i in range(len(coe)):
 98 |     model.write("hyperplane = ")
 99 |     model.write(str(coe[i][0]) + "x1 + "+ str(coe[i][1]) + "x2 + "+ str(coe[i][2])+ "x3 + " + str(int[i]))
100 |     model.write(";\n")
101 | 
102 | model.close()
103 | 


--------------------------------------------------------------------------------
/iisy_sw/framework/kmeans.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python
  2 | #################################################################################
  3 | #
  4 | # Copyright (c) 2019 Zhaoqi Xiong
  5 | # All rights reserved.
  6 | #
  7 | #
  8 | # @NETFPGA_LICENSE_HEADER_START@
  9 | #
 10 | # Licensed to NetFPGA C.I.C. (NetFPGA) under one or more contributor
 11 | # license agreements.  See the NOTICE file distributed with this work for
 12 | # additional information regarding copyright ownership.  NetFPGA licenses this
 13 | # file to you under the NetFPGA Hardware-Software License, Version 1.0 (the
 14 | # "License"); you may not use this file except in compliance with the
 15 | # License.  You may obtain a copy of the License at:
 16 | #
 17 | #   http://www.netfpga-cic.org
 18 | #
 19 | # Unless required by applicable law or agreed to in writing, Work distributed
 20 | # under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
 21 | # CONDITIONS OF ANY KIND, either express or implied.  See the License for the
 22 | # specific language governing permissions and limitations under the License.
 23 | #
 24 | # @NETFPGA_LICENSE_HEADER_END@
 25 | #
 26 | ################################################################################# 
 27 | from sklearn.svm import SVC
 28 | from sklearn.svm import LinearSVC
 29 | from sklearn.naive_bayes import GaussianNB
 30 | import numpy as np
 31 | import pandas as pd
 32 | import argparse
 33 | from sklearn.metrics import accuracy_score
 34 | import pydotplus
 35 | from sklearn.cluster import KMeans
 36 | from sklearn.metrics import accuracy_score
 37 | from sklearn.metrics import classification_report
 38 | from sklearn.tree import export_graphviz
 39 | import pydotplus
 40 | from sklearn.metrics import confusion_matrix
 41 | import matplotlib.pyplot as plt
 42 | from sklearn import linear_model 
 43 | 
 44 | 
 45 | 
 46 | parser = argparse.ArgumentParser()
 47 | 
 48 | # Add argument
 49 | parser.add_argument('-i', required=True, help='path to dataset')
 50 | parser.add_argument('-o', required=True, help='path to outputfile')
 51 | parser.add_argument('-t', required=True, help='path to testfile')
 52 | args = parser.parse_args()
 53 | 
 54 | # extract argument
 55 | input = args.i
 56 | outputfile = args.o
 57 | testfile = args.t
 58 | 
 59 | # Training set X and Y
 60 | Set1 = pd.read_csv(input)
 61 | Set = Set1.values.tolist()
 62 | X = [i[0:3] for i in Set]
 63 | Y =[i[3] for i in Set]
 64 | 
 65 | # Test set Xt and Yt
 66 | Set2 = pd.read_csv(input)
 67 | Sett = Set2.values.tolist()
 68 | Xt = [i[0:3] for i in Set]
 69 | Yt =[i[3] for i in Set]
 70 | 
 71 | class_names=['iperf','memcached','ping','sparkglm','sparkkmeans']
 72 | feature_names=['proto','src','dst']
 73 | 
 74 | 
 75 | # prepare training and testing set
 76 | X = np.array(X)
 77 | Y = np.array(Y)
 78 | Xt = np.array(Xt)
 79 | Yt = np.array(Yt)
 80 | 
 81 | # kmeans fit
 82 | kmeans = KMeans(n_clusters=5, random_state= 9).fit(X)
 83 | 
 84 | Predict_Y = kmeans.predict(X)
 85 | print(accuracy_score(Y, Predict_Y))
 86 | 
 87 | Predict_Yt = kmeans.predict(Xt)
 88 | print(accuracy_score(Yt, Predict_Yt))
 89 | 
 90 | # output the model in a text file, write it
 91 | centre = kmeans.cluster_centers_
 92 | 
 93 | model = open(outputfile,"w+")
 94 | for i in range(len(centre)):
 95 |     model.write("centre point : ")
 96 |     model.write("(" + str(centre[i][0])+"," + str(centre[i][1])+"," + str(centre[i][2])+ ",)" )
 97 |     model.write(";\n")
 98 | 
 99 | model.close()
100 | 


--------------------------------------------------------------------------------
/iisy_sw/IoT_ML/iot_kmeans.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python
  2 | #################################################################################
  3 | #
  4 | # Copyright (c) 2019 Zhaoqi Xiong, Noa Zilberman
  5 | # All rights reserved.
  6 | #
  7 | #
  8 | # @NETFPGA_LICENSE_HEADER_START@
  9 | #
 10 | # Licensed to NetFPGA C.I.C. (NetFPGA) under one or more contributor
 11 | # license agreements.  See the NOTICE file distributed with this work for
 12 | # additional information regarding copyright ownership.  NetFPGA licenses this
 13 | # file to you under the NetFPGA Hardware-Software License, Version 1.0 (the
 14 | # "License"); you may not use this file except in compliance with the
 15 | # License.  You may obtain a copy of the License at:
 16 | #
 17 | #   http://www.netfpga-cic.org
 18 | #
 19 | # Unless required by applicable law or agreed to in writing, Work distributed
 20 | # under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
 21 | # CONDITIONS OF ANY KIND, either express or implied.  See the License for the
 22 | # specific language governing permissions and limitations under the License.
 23 | #
 24 | # @NETFPGA_LICENSE_HEADER_END@
 25 | #
 26 | ################################################################################# 
 27 | 
 28 | import numpy as np
 29 | import pandas as pd
 30 | import argparse
 31 | from sklearn.cluster import KMeans
 32 | from sklearn.metrics import *
 33 | #from sklearn.cluster import export_graphviz
 34 | from sklearn.preprocessing import StandardScaler
 35 | import pydotplus
 36 | 
 37 | 
 38 | 
 39 | parser = argparse.ArgumentParser()
 40 | 
 41 | # Add argument
 42 | parser.add_argument('-i', required=True, help='path to dataset')
 43 | parser.add_argument('-o', required=True, help='path to outputfile')
 44 | parser.add_argument('-t', required=True, help='path to testfile')
 45 | 
 46 | args = parser.parse_args()
 47 | 
 48 | input = args.i
 49 | outputfile = args.o
 50 | testfile = args.t
 51 | 
 52 | 
 53 | Set1 = pd.read_csv(input)
 54 | Set = Set1.values.tolist()
 55 | #print(Set1.describe())
 56 | 
 57 | X = [i[0:11] for i in Set]
 58 | Y = [i[11] for i in Set]
 59 | class_names=['smart-static','sensor','audio','video','else']
 60 | feature_names=['frame_len','eth_type','ip_proto','ip_flags','ipv6_nxt','ipv6_opt','tcp_srcport','tcp_dstport','tcp_flags','udp_srcport','udp_dstport']
 61 | 
 62 | 
 63 | # prepare training and testing set
 64 | X = np.array(X)
 65 | Y = np.array(Y)
 66 | 
 67 | # kmeans fit
 68 | kmeans = KMeans(n_clusters=5, random_state= 9).fit(X)
 69 | 
 70 | Predict_Y = kmeans.predict(X)
 71 | print(accuracy_score(Y, Predict_Y))
 72 | print("\tPrecision: %1.3f" % precision_score(Y, Predict_Y,average='weighted'))
 73 | print("\tRecall: %1.3f" % recall_score(Y, Predict_Y,average='weighted'))
 74 | print("\tF1: %1.3f\n" % f1_score(Y, Predict_Y,average='weighted'))
 75 | print("\tConfusion matrix:\n" )
 76 | print(confusion_matrix(Y, Predict_Y))
 77 | 
 78 | 
 79 | # Test set X and Y
 80 | Set2 = pd.read_csv(testfile)
 81 | Sett = Set2.values.tolist()
 82 | Xt = [i[0:11] for i in Sett]
 83 | Yt =[i[11] for i in Sett]
 84 | 
 85 | # prepare training and testing set
 86 | Xt = np.array(Xt)
 87 | Yt = np.array(Yt)
 88 | 
 89 | # fit
 90 | Predict_Yt = kmeans.predict(Xt)
 91 | print(accuracy_score(Yt, Predict_Yt))
 92 | print("\tPrecision: %1.3f" % precision_score(Yt, Predict_Yt,average='weighted'))
 93 | print("\tRecall: %1.3f" % recall_score(Yt, Predict_Yt,average='weighted'))
 94 | print("\tF1: %1.3f\n" % f1_score(Yt, Predict_Yt,average='weighted'))
 95 | 
 96 | 
 97 | print(confusion_matrix(Yt, Predict_Yt))
 98 | 
 99 | 
100 | # output the model in a text file, wirte it
101 | centre = kmeans.cluster_centers_
102 | 
103 | model = open(outputfile,"w+")
104 | for i in range(len(centre)):
105 |     model.write("centre point : ( ")
106 |     for j in range(11):
107 |       model.write(str(centre[i][j])+",")
108 |     model.write(");\n")
109 | 
110 | model.close()
111 | 
112 | 
113 | 


--------------------------------------------------------------------------------
/iisy_sw/IoT_ML/iot_svm.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python
  2 | #################################################################################
  3 | #
  4 | # Copyright (c) 2019 Zhaoqi Xiong, Noa Zilberman
  5 | # All rights reserved.
  6 | #
  7 | #
  8 | # @NETFPGA_LICENSE_HEADER_START@
  9 | #
 10 | # Licensed to NetFPGA C.I.C. (NetFPGA) under one or more contributor
 11 | # license agreements.  See the NOTICE file distributed with this work for
 12 | # additional information regarding copyright ownership.  NetFPGA licenses this
 13 | # file to you under the NetFPGA Hardware-Software License, Version 1.0 (the
 14 | # "License"); you may not use this file except in compliance with the
 15 | # License.  You may obtain a copy of the License at:
 16 | #
 17 | #   http://www.netfpga-cic.org
 18 | #
 19 | # Unless required by applicable law or agreed to in writing, Work distributed
 20 | # under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
 21 | # CONDITIONS OF ANY KIND, either express or implied.  See the License for the
 22 | # specific language governing permissions and limitations under the License.
 23 | #
 24 | # @NETFPGA_LICENSE_HEADER_END@
 25 | #
 26 | ################################################################################# 
 27 | 
 28 | import numpy as np
 29 | import pandas as pd
 30 | import argparse
 31 | from sklearn import svm
 32 | from sklearn.metrics import *
 33 | from sklearn.svm import SVC
 34 | from sklearn.svm import LinearSVC
 35 | from sklearn.naive_bayes import GaussianNB
 36 | import pydotplus
 37 | 
 38 | 
 39 | 
 40 | parser = argparse.ArgumentParser()
 41 | 
 42 | # Add argument
 43 | parser.add_argument('-i', required=True, help='path to training set')
 44 | parser.add_argument('-o', required=True, help='path to outputfile')
 45 | parser.add_argument('-t', required=True, help='path to test set')
 46 | args = parser.parse_args()
 47 | 
 48 | input = args.i
 49 | outputfile = args.o
 50 | test=args.t
 51 | 
 52 | 
 53 | Set1 = pd.read_csv(input)
 54 | Set1 = Set1.apply(pd.to_numeric, downcast='float', errors='coerce')
 55 | #print(Set1.dtypes)
 56 | 
 57 | Set = Set1.values.tolist()
 58 | X = [i[0:11] for i in Set]
 59 | Y = [i[11] for i in Set]
 60 | class_names=['smart-static','sensor','audio','video','else']
 61 | feature_names=['frame_len','eth_type','ip_proto','ip_flags','ipv6_nxt','ipv6_opt','tcp_srcport','tcp_dstport','tcp_flags','udp_srcport','udp_dstport']
 62 | 
 63 | 
 64 | 
 65 | #debug = open("debug.txt","w+")
 66 | #debug.write("Y = ")
 67 | #debug.write(str(Y))
 68 | #debug.write(";\n")
 69 | #debug.close()
 70 | 
 71 | 
 72 | #prepare training and testing set
 73 | X = np.array(X,dtype=float)
 74 | Y = np.array(Y,dtype=float)
 75 | 
 76 | 
 77 | # SVM fit
 78 | clf = svm.LinearSVC(random_state=8)
 79 | clf.fit(X,Y) 
 80 | 
 81 | 
 82 | Predict_Y = clf.predict(X)
 83 | print("Original dataset")
 84 | print(accuracy_score(Y, Predict_Y))
 85 | #print("\tBrier: %1.3f" % (clf_score))
 86 | print("\tPrecision: %1.3f" % precision_score(Y, Predict_Y,average='weighted'))
 87 | print("\tRecall: %1.3f" % recall_score(Y, Predict_Y,average='weighted'))
 88 | print("\tF1: %1.3f\n" % f1_score(Y, Predict_Y,average='weighted'))
 89 | 
 90 | 
 91 | Set2 = pd.read_csv(test)
 92 | Set2 = Set2.apply(pd.to_numeric, downcast='float', errors='coerce')
 93 | #print(Set1.dtypes)
 94 | 
 95 | Set_t = Set2.values.tolist()
 96 | X_t = [i[0:11] for i in Set_t]
 97 | Y_t = [i[11] for i in Set_t]
 98 | 
 99 | Predict_Yt = clf.predict(X_t)
100 | 
101 | print("test dataset")
102 | print(accuracy_score(Y_t, Predict_Yt))
103 | #print("\tBrier: %1.3f" % (clf_score))
104 | print("\tPrecision: %1.3f" % precision_score(Y_t, Predict_Yt,average='weighted'))
105 | print("\tRecall: %1.3f" % recall_score(Y_t, Predict_Yt,average='weighted'))
106 | print("\tF1: %1.3f\n" % f1_score(Y_t, Predict_Yt,average='weighted'))
107 | 
108 | # output
109 | 
110 | 
111 | SV=clf.coef_
112 | 
113 | print(SV)
114 | 
115 | print("printing items")
116 | for item in SV:
117 |    print(item)
118 | 
119 | # output the model in a text file, write
120 | coe = clf.coef_
121 | intr = clf.intercept_
122 | 
123 | model = open(outputfile,"w+")
124 | for i in range(len(coe)):
125 |     model.write("hyperplane = ")
126 |     for j in range(11):
127 |        model.write(str(coe[i][j-1]) + "x"+str(j)+ "+ ")
128 |     model.write(str(intr[i])+";\n")
129 | 
130 | model.close()
131 | 


--------------------------------------------------------------------------------
/iisy_sw/framework/Machinelearning.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python
  2 | #################################################################################
  3 | #
  4 | # Copyright (c) 2019 Zhaoqi Xiong
  5 | # All rights reserved.
  6 | #
  7 | #
  8 | # @NETFPGA_LICENSE_HEADER_START@
  9 | #
 10 | # Licensed to NetFPGA C.I.C. (NetFPGA) under one or more contributor
 11 | # license agreements.  See the NOTICE file distributed with this work for
 12 | # additional information regarding copyright ownership.  NetFPGA licenses this
 13 | # file to you under the NetFPGA Hardware-Software License, Version 1.0 (the
 14 | # "License"); you may not use this file except in compliance with the
 15 | # License.  You may obtain a copy of the License at:
 16 | #
 17 | #   http://www.netfpga-cic.org
 18 | #
 19 | # Unless required by applicable law or agreed to in writing, Work distributed
 20 | # under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
 21 | # CONDITIONS OF ANY KIND, either express or implied.  See the License for the
 22 | # specific language governing permissions and limitations under the License.
 23 | #
 24 | # @NETFPGA_LICENSE_HEADER_END@
 25 | #
 26 | ################################################################################# 
 27 | 
 28 | import numpy as np
 29 | import pandas as pd
 30 | import argparse
 31 | from sklearn.tree import DecisionTreeClassifier
 32 | from sklearn.metrics import accuracy_score
 33 | from sklearn.tree import export_graphviz
 34 | import pydotplus
 35 | 
 36 | 
 37 | 
 38 | parser = argparse.ArgumentParser()
 39 | 
 40 | # Add argument
 41 | parser.add_argument('-i', required=True, help='path to dataset')
 42 | parser.add_argument('-o', required=True, help='path to outputfile')
 43 | parser.add_argument('-t', required=True, help='path to testfile')
 44 | args = parser.parse_args()
 45 | 
 46 | # extract argument
 47 | input = args.i
 48 | outputfile = args.o
 49 | testfile = args.t
 50 | 
 51 | # output the tree
 52 | def get_lineage(tree, feature_names, file):
 53 |     proto = []
 54 |     src = []
 55 |     dst = []
 56 |     left = tree.tree_.children_left
 57 |     right = tree.tree_.children_right
 58 |     threshold = tree.tree_.threshold
 59 |     features = [feature_names[i] for i in tree.tree_.feature]
 60 |     value = tree.tree_.value
 61 |     le = '<='
 62 |     g = '>'
 63 |     # get ids of child nodes
 64 |     idx = np.argwhere(left == -1)[:, 0]
 65 |     
 66 |     # traverse the tree and get the node information
 67 |     def recurse(left, right, child, lineage=None):
 68 |         if lineage is None:
 69 |             lineage = [child]
 70 |         if child in left:
 71 |             parent = np.where(left == child)[0].item()
 72 |             split = 'l'
 73 |         else:
 74 |             parent = np.where(right == child)[0].item()
 75 |             split = 'r'
 76 |         
 77 |         lineage.append((parent, split, threshold[parent], features[parent]))
 78 |         if parent == 0:
 79 |             lineage.reverse()
 80 |             return lineage
 81 |         else:
 82 |             return recurse(left, right, parent, lineage)
 83 | 
 84 |     for j, child in enumerate(idx):
 85 |         clause = ' when '
 86 |         for node in recurse(left, right, child):
 87 |                 if len(str(node)) < 3:
 88 |                     continue
 89 |                 i = node
 90 |                 
 91 |                 if i[1] == 'l':
 92 |                     sign = le
 93 |                 else:
 94 |                     sign = g
 95 |                 clause = clause + i[3] + sign + str(i[2]) + ' and '
 96 |     
 97 |     # wirte the node information into text file
 98 |         a = list(value[node][0])
 99 |         ind = a.index(max(a))
100 |         clause = clause[:-4] + ' then ' + str(ind)
101 |         file.write(clause)
102 |         file.write(";\n")
103 | 
104 | 
105 | # Training set X and Y
106 | Set1 = pd.read_csv(input)
107 | Set = Set1.values.tolist()
108 | X = [i[0:3] for i in Set]
109 | Y =[i[3] for i in Set]
110 | 
111 | # Test set Xt and Yt
112 | Set2 = pd.read_csv(input)
113 | Sett = Set2.values.tolist()
114 | Xt = [i[0:3] for i in Set]
115 | Yt =[i[3] for i in Set]
116 | 
117 | class_names=['iperf','memcached','ping','sparkglm','sparkkmeans']
118 | feature_names=['proto','src','dst']
119 | 
120 | 
121 | # prepare training and testing set
122 | X = np.array(X)
123 | Y = np.array(Y)
124 | Xt = np.array(Xt)
125 | Yt = np.array(Yt)
126 | 
127 | # decision tree fit
128 | dt = DecisionTreeClassifier(max_depth = 5)
129 | dt.fit(X, Y)
130 | Predict_Y = dt.predict(X)
131 | print(accuracy_score(Y, Predict_Y))
132 | 
133 | Predict_Yt = dt.predict(Xt)
134 | print(accuracy_score(Yt, Predict_Yt))
135 | 
136 | # output the tree in a text file, write it
137 | threshold = dt.tree_.threshold
138 | features  = [feature_names[i] for i in dt.tree_.feature]
139 | proto = []
140 | src = []
141 | dst = []
142 | for i, fe in enumerate(features):
143 |     
144 |     if fe == 'proto':
145 |         proto.append(threshold[i])
146 |     elif fe == 'src':
147 |         if threshold[i] != -2.0:
148 |             src.append(threshold[i])
149 |     else:
150 |         dst.append(threshold[i])
151 | proto = [int(i) for i in proto]
152 | src = [int(i) for i in src]
153 | dst = [int(i) for i in dst]
154 | proto.sort()
155 | src.sort()
156 | dst.sort()
157 | tree = open(outputfile,"w+")
158 | tree.write("proto = ")
159 | tree.write(str(proto))
160 | tree.write(";\n")
161 | tree.write("src = ")
162 | tree.write(str(src))
163 | tree.write(";\n")
164 | tree.write("dst = ")
165 | tree.write(str(dst))
166 | tree.write(";\n")
167 | get_lineage(dt,feature_names,tree)
168 | tree.close()
169 | 


--------------------------------------------------------------------------------
/iisy_sw/simple_example/svm/mycontroller.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python2
  2 | #################################################################################
  3 | #
  4 | # Copyright (c) 2019 Zhaoqi Xiong
  5 | # All rights reserved.
  6 | #
  7 | #
  8 | # @NETFPGA_LICENSE_HEADER_START@
  9 | #
 10 | # Licensed to NetFPGA C.I.C. (NetFPGA) under one or more contributor
 11 | # license agreements.  See the NOTICE file distributed with this work for
 12 | # additional information regarding copyright ownership.  NetFPGA licenses this
 13 | # file to you under the NetFPGA Hardware-Software License, Version 1.0 (the
 14 | # "License"); you may not use this file except in compliance with the
 15 | # License.  You may obtain a copy of the License at:
 16 | #
 17 | #   http://www.netfpga-cic.org
 18 | #
 19 | # Unless required by applicable law or agreed to in writing, Work distributed
 20 | # under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
 21 | # CONDITIONS OF ANY KIND, either express or implied.  See the License for the
 22 | # specific language governing permissions and limitations under the License.
 23 | #
 24 | # @NETFPGA_LICENSE_HEADER_END@
 25 | #
 26 | ################################################################################# 
 27 | 
 28 | import argparse
 29 | import os
 30 | import sys
 31 | import grpc
 32 | import numpy as np
 33 | import time
 34 | 
 35 | # Import P4Runtime lib from parent utils dir
 36 | # Probably there's a better way of doing this.
 37 | sys.path.append(
 38 |     os.path.join(os.path.dirname(os.path.abspath(__file__)),
 39 |                  '../../utils/'))
 40 | import p4runtime_lib.bmv2
 41 | from p4runtime_lib.switch import ShutdownAllSwitchConnections
 42 | import p4runtime_lib.helper
 43 | 
 44 | 
 45 | def get_actionpara(action):
 46 |     para = {}
 47 |     if action == 0:
 48 |         para = {}
 49 |     elif action == 2:
 50 |         para = {"dstAddr": "00:00:00:02:02:00", "port": 2}
 51 |     elif action == 3:
 52 |         para = {"dstAddr": "00:00:00:03:03:00", "port": 3}
 53 |     elif action == 4:
 54 |         para = {"dstAddr": "00:00:00:04:04:00", "port": 4}
 55 | 
 56 |     return para
 57 | 
 58 | 
 59 | def writeclass1x(p4info_helper, switch, a,b, a_square):
 60 |     table_entry = p4info_helper.buildTableEntry(
 61 |         table_name="MyIngress.classification",
 62 |         match_fields={"hdr.tcp.srcPort": a,
 63 |                       "hdr.tcp.dstPort": b
 64 | 
 65 |                       },
 66 |         action_name="MyIngress.set_p",
 67 |         action_params={"distance": a_square,
 68 |                        })
 69 |     switch.WriteTableEntry(table_entry)
 70 |     print("Installed action rule")
 71 | 
 72 | 
 73 | 
 74 | def writeaction(p4info_helper, switch, value, port):
 75 |     para = get_actionpara(port)
 76 |     table_entry = p4info_helper.buildTableEntry(
 77 |         table_name="MyIngress.ipv4_exact",
 78 |         match_fields={
 79 |             "meta.classification": value},
 80 |         action_name="MyIngress.ipv4_forward",
 81 |         action_params=para
 82 |     )
 83 | 
 84 |     switch.WriteTableEntry(table_entry)
 85 |     print("Installed select rule on %s" % switch.name)
 86 | 
 87 | 
 88 | def printGrpcError(e):
 89 |     print("gRPC Error:", e.details(), )
 90 |     status_code = e.code()
 91 |     print("(%s)" % status_code.name, )
 92 |     traceback = sys.exc_info()[2]
 93 |     print("[%s:%d]" % (traceback.tb_frame.f_code.co_filename, traceback.tb_lineno))
 94 | 
 95 | 
 96 | def main(p4info_file_path, bmv2_file_path):
 97 |     p4info_helper = p4runtime_lib.helper.P4InfoHelper(p4info_file_path)
 98 | 
 99 |     try:
100 | 
101 |         s1 = p4runtime_lib.bmv2.Bmv2SwitchConnection(
102 |             name='s1',
103 |             address='127.0.0.1:50051',
104 |             device_id=0,
105 |             proto_dump_file='logs/s1-p4runtime-requests.txt')
106 | 
107 |         s1.MasterArbitrationUpdate()
108 | 
109 |         s1.SetForwardingPipelineConfig(p4info=p4info_helper.p4info,
110 |                                        bmv2_json_file_path=bmv2_file_path)
111 |         print("Installed P4 Program using SetForwardingPipelineConfig on s1")
112 |         
113 | 
114 | 	a = [5001, 11211]
115 | 	b = [5001, 38094]
116 |         for i in range(5000,65536,1000):
117 |             for j in range(5001,65536):
118 |                 p1 = 5 * i + 5 * j - 150558
119 |                 if (p1 >= 0):
120 |                     p1 = 1
121 |                 else:
122 |                     p1 = 2
123 |                 writeclass1x(p4info_helper, s1, i, j, p1)
124 | 
125 | 
126 |         writeaction(p4info_helper, s1, 1, 2)
127 |         writeaction(p4info_helper, s1, 2, 3)
128 | 
129 | 
130 |     except KeyboardInterrupt:
131 |         print("Shutting down.")
132 | 
133 |     except grpc.RpcError as e:
134 |         printGrpcError(e)
135 | 
136 |     ShutdownAllSwitchConnections()
137 | 
138 | 
139 | if __name__ == '__main__':
140 |     parser = argparse.ArgumentParser(description='P4Runtime Controller')
141 |     parser.add_argument('--p4info', help='p4info proto in text format from p4c',
142 |                         type=str, action="store", required=False,
143 |                         default='./build/svm.p4info')
144 | 
145 |     parser.add_argument('--bmv2-json', help='BMv2 JSON file from p4c',
146 |                         type=str, action="store", required=False,
147 |                         default='./build/svm.json')
148 | 
149 |     args = parser.parse_args()
150 | 
151 |     if not os.path.exists(args.p4info):
152 |         parser.print_help()
153 |         print("\np4info file not found: %s\nHave you run 'make'?" % args.p4info)
154 |         parser.exit(1)
155 | 
156 |     if not os.path.exists(args.bmv2_json):
157 |         parser.print_help()
158 |         print("\nBMv2 JSON file not found: %s\nHave you run 'make'?" % args.bmv2_json)
159 |         parser.exit(1)
160 |     start = time.time()
161 |     main(args.p4info, args.bmv2_json)
162 |     end = time.time()
163 |     print("loading time is :" ,(end -start))
164 | 


--------------------------------------------------------------------------------
/iisy_sw/IoT_ML/iot_naivebayes.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python
  2 | #################################################################################
  3 | #
  4 | # Copyright (c) 2019 Zhaoqi Xiong, Noa Zilberman
  5 | # All rights reserved.
  6 | #
  7 | #
  8 | # @NETFPGA_LICENSE_HEADER_START@
  9 | #
 10 | # Licensed to NetFPGA C.I.C. (NetFPGA) under one or more contributor
 11 | # license agreements.  See the NOTICE file distributed with this work for
 12 | # additional information regarding copyright ownership.  NetFPGA licenses this
 13 | # file to you under the NetFPGA Hardware-Software License, Version 1.0 (the
 14 | # "License"); you may not use this file except in compliance with the
 15 | # License.  You may obtain a copy of the License at:
 16 | #
 17 | #   http://www.netfpga-cic.org
 18 | #
 19 | # Unless required by applicable law or agreed to in writing, Work distributed
 20 | # under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
 21 | # CONDITIONS OF ANY KIND, either express or implied.  See the License for the
 22 | # specific language governing permissions and limitations under the License.
 23 | #
 24 | # @NETFPGA_LICENSE_HEADER_END@
 25 | #
 26 | ################################################################################# 
 27 | 
 28 | from sklearn.naive_bayes import GaussianNB
 29 | import numpy as np
 30 | import pandas as pd
 31 | import argparse
 32 | 
 33 | from sklearn.metrics import *
 34 | from sklearn.naive_bayes import GaussianNB
 35 | import pydotplus
 36 | 
 37 | 
 38 | from sklearn.metrics import accuracy_score
 39 | from sklearn.metrics import classification_report
 40 | from sklearn.tree import export_graphviz
 41 | import pydotplus
 42 | from sklearn.metrics import confusion_matrix
 43 | import matplotlib.pyplot as plt
 44 | from sklearn import linear_model 
 45 | 
 46 | 
 47 | 
 48 | parser = argparse.ArgumentParser()
 49 | 
 50 | # Add argument
 51 | parser.add_argument('-i', required=True, help='path to dataset')
 52 | parser.add_argument('-o', required=True, help='path to outputfile')
 53 | parser.add_argument('-t', required=True, help='path to testfile')
 54 | args = parser.parse_args()
 55 | 
 56 | # extract argument
 57 | input = args.i
 58 | outputfile = args.o
 59 | testfile = args.t
 60 | 
 61 | 
 62 | # Training set X and Y
 63 | Set1 = pd.read_csv(input)
 64 | Set = Set1.values.tolist()
 65 | X = [i[0:11] for i in Set]
 66 | Y =[i[11] for i in Set]
 67 | class_names=['smart-static','sensor','audio','video','else']
 68 | feature_names=['frame_len','eth_type','ip_proto','ip_flags','ipv6_nxt','ipv6_opt','tcp_srcport','tcp_dstport','tcp_flags','udp_srcport','udp_dstport']
 69 | 
 70 | 
 71 | # prepare training and testing set
 72 | X = np.array(X)
 73 | Y = np.array(Y)
 74 | 
 75 | # fit
 76 | clf = GaussianNB()
 77 | clf.fit(X, Y)
 78 | Predict_Y = clf.predict(X)
 79 | print(accuracy_score(Y, Predict_Y))
 80 | print("\tPrecision: %1.3f" % precision_score(Y, Predict_Y,average='weighted'))
 81 | print("\tRecall: %1.3f" % recall_score(Y, Predict_Y,average='weighted'))
 82 | print("\tF1: %1.3f\n" % f1_score(Y, Predict_Y,average='weighted'))
 83 | print("\tConfusion matrix:\n" )
 84 | print(confusion_matrix(Y, Predict_Y))
 85 | 
 86 | # Test set X and Y
 87 | Set2 = pd.read_csv(testfile)
 88 | Sett = Set2.values.tolist()
 89 | Xt = [i[0:11] for i in Sett]
 90 | Yt =[i[11] for i in Sett]
 91 | 
 92 | # prepare training and testing set
 93 | Xt = np.array(Xt)
 94 | Yt = np.array(Yt)
 95 | 
 96 | # fit
 97 | Predict_Yt = clf.predict(Xt)
 98 | print(accuracy_score(Yt, Predict_Yt))
 99 | print("\tPrecision: %1.3f" % precision_score(Yt, Predict_Yt,average='weighted'))
100 | print("\tRecall: %1.3f" % recall_score(Yt, Predict_Yt,average='weighted'))
101 | print("\tF1: %1.3f\n" % f1_score(Yt, Predict_Yt,average='weighted'))
102 | 
103 | 
104 | # output the model in a text file
105 | 
106 | model = open(outputfile,"w+")
107 | 
108 | Training_0 =[]
109 | Training_1 =[]
110 | Training_2 =[]
111 | Training_3 =[]
112 | Training_4 =[]
113 | for i,cate in enumerate(Y):
114 |     if  cate ==0:
115 |         Training_0.append(X[i])
116 |     elif  cate ==1:
117 |         Training_1.append(X[i])
118 |     elif  cate ==2:
119 |         Training_2.append(X[i])
120 |     elif  cate ==3:
121 |         Training_3.append(X[i])
122 |     else:
123 |         Training_4.append(X[i])
124 | 
125 | 
126 | Training_0 = np.array(Training_0)
127 | Training_1 = np.array(Training_1)
128 | Training_2 = np.array(Training_2)
129 | Training_3 = np.array(Training_3)
130 | Training_4 = np.array(Training_4)
131 | 
132 | 
133 | 
134 | 
135 | model.write("class 0: \n")
136 | for j in range(11):
137 |    aver_feature = np.array(Training_0[:,j]).mean()
138 |    var_feature  = np.array(Training_0[:,j]).var()
139 |    model.write("feature "+str(j)+", average value: " + str(aver_feature)  + ", standard error: " + str(var_feature)+ ";\n")
140 | 
141 | model.write("class 1: \n")
142 | for j in range(11):
143 |    aver_feature = np.array(Training_1[:,j]).mean()
144 |    var_feature  = np.array(Training_1[:,j]).var()
145 |    model.write("feature "+str(j)+", average value: " + str(aver_feature)  + ", standard error: " + str(var_feature)+ ";\n")
146 | 
147 | model.write("class 2: \n")
148 | for j in range(11):
149 |    aver_feature = np.array(Training_2[:,j]).mean()
150 |    var_feature  = np.array(Training_2[:,j]).var()
151 |    model.write("feature "+str(j)+", average value: " + str(aver_feature)  + ", standard error: " + str(var_feature)+ ";\n")
152 | 
153 | model.write("class 3: \n")
154 | for j in range(11):
155 |    aver_feature = np.array(Training_3[:,j]).mean()
156 |    var_feature  = np.array(Training_3[:,j]).var()
157 |    model.write("feature "+str(j)+", average value: " + str(aver_feature)  + ", standard error: " + str(var_feature)+ ";\n")
158 | 
159 | model.write("class 4: \n")
160 | for j in range(11):
161 |    aver_feature = np.array(Training_4[:,j]).mean()
162 |    var_feature  = np.array(Training_4[:,j]).var()
163 |    model.write("feature "+str(j)+", average value: " + str(aver_feature)  + ", standard error: " + str(var_feature)+ ";\n")
164 | 
165 | model.close()
166 | 


--------------------------------------------------------------------------------
/iisy_sw/framework/naivebayes.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python
  2 | #################################################################################
  3 | #
  4 | # Copyright (c) 2019 Zhaoqi Xiong
  5 | # All rights reserved.
  6 | #
  7 | #
  8 | # @NETFPGA_LICENSE_HEADER_START@
  9 | #
 10 | # Licensed to NetFPGA C.I.C. (NetFPGA) under one or more contributor
 11 | # license agreements.  See the NOTICE file distributed with this work for
 12 | # additional information regarding copyright ownership.  NetFPGA licenses this
 13 | # file to you under the NetFPGA Hardware-Software License, Version 1.0 (the
 14 | # "License"); you may not use this file except in compliance with the
 15 | # License.  You may obtain a copy of the License at:
 16 | #
 17 | #   http://www.netfpga-cic.org
 18 | #
 19 | # Unless required by applicable law or agreed to in writing, Work distributed
 20 | # under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
 21 | # CONDITIONS OF ANY KIND, either express or implied.  See the License for the
 22 | # specific language governing permissions and limitations under the License.
 23 | #
 24 | # @NETFPGA_LICENSE_HEADER_END@
 25 | #
 26 | ################################################################################# 
 27 | 
 28 | from sklearn.svm import SVC
 29 | from sklearn.svm import LinearSVC
 30 | from sklearn.naive_bayes import GaussianNB
 31 | import numpy as np
 32 | import pandas as pd
 33 | import argparse
 34 | 
 35 | from sklearn.metrics import accuracy_score
 36 | from sklearn.naive_bayes import GaussianNB
 37 | import pydotplus
 38 | 
 39 | 
 40 | from sklearn.metrics import accuracy_score
 41 | from sklearn.metrics import classification_report
 42 | from sklearn.tree import export_graphviz
 43 | import pydotplus
 44 | from sklearn.metrics import confusion_matrix
 45 | import matplotlib.pyplot as plt
 46 | from sklearn import linear_model 
 47 | 
 48 | 
 49 | 
 50 | parser = argparse.ArgumentParser()
 51 | 
 52 | # Add argument
 53 | parser.add_argument('-i', required=True, help='path to dataset')
 54 | parser.add_argument('-o', required=True, help='path to outputfile')
 55 | parser.add_argument('-t', required=True, help='path to testfile')
 56 | args = parser.parse_args()
 57 | 
 58 | # extract argument
 59 | input = args.i
 60 | outputfile = args.o
 61 | testfile = args.t
 62 | 
 63 | 
 64 | # Training set X and Y
 65 | Set1 = pd.read_csv(input)
 66 | Set = Set1.values.tolist()
 67 | X = [i[0:3] for i in Set]
 68 | Y =[i[3] for i in Set]
 69 | class_names=['iperf','memcached','ping','sparkglm','sparkkmeans']
 70 | feature_names=['proto','src','dst']
 71 | 
 72 | # Test set Xt and Yt
 73 | Set2 = pd.read_csv(input)
 74 | Sett = Set2.values.tolist()
 75 | Xt = [i[0:3] for i in Set]
 76 | Yt =[i[3] for i in Set]
 77 | 
 78 | # prepare training and testing set
 79 | X = np.array(X)
 80 | Y = np.array(Y)
 81 | Xt = np.array(Xt)
 82 | Yt = np.array(Yt)
 83 | 
 84 | # naive base fit
 85 | clf = GaussianNB()
 86 | clf.fit(X, Y)
 87 | Predict_Y = clf.predict(X)
 88 | print(accuracy_score(Y, Predict_Y))
 89 | 
 90 | Predict_Yt = clf.predict(Xt)
 91 | print(accuracy_score(Yt, Predict_Yt))
 92 | 
 93 | # output the model in a text file, wirte it
 94 | Training_0 =[]
 95 | Training_1 =[]
 96 | Training_2 =[]
 97 | Training_3 =[]
 98 | Training_4 =[]
 99 | for i,cate in enumerate(Y):
100 |     if  cate ==0:
101 |         Training_0.append(X[i])
102 |     elif  cate ==1:
103 |         Training_1.append(X[i])
104 |     elif  cate ==2:
105 |         Training_2.append(X[i])
106 |     elif  cate ==3:
107 |         Training_3.append(X[i])
108 |     else:
109 |         Training_4.append(X[i])
110 | 
111 | Training_0 = np.array(Training_0)
112 | Training_1 = np.array(Training_1)
113 | Training_2 = np.array(Training_2)
114 | Training_3 = np.array(Training_3)
115 | Training_4 = np.array(Training_4)
116 | 
117 | model = open(outputfile,"w+")
118 | 
119 | aver_feature1_0 = np.array(Training_0[:,0]).mean()
120 | var_feature1_0 = np.array(Training_0[:,0]).var()+0.001
121 | aver_feature2_0 = np.array(Training_0[:,1]).mean()
122 | var_feature2_0 = np.array(Training_0[:,1]).var()+0.001
123 | aver_feature3_0 = np.array(Training_0[:,2]).mean()+0.001
124 | var_feature3_0 = np.array(Training_0[:,2]).var()
125 | 
126 | 
127 | 
128 | model.write("class 0: \n")
129 | model.write("feature 1, average value: " + str(aver_feature1_0)  + ", standard error: " + str(var_feature1_0)+ ";\n")
130 | model.write("feature 2, average value: " + str(aver_feature2_0)  + ", standard error: " + str(var_feature2_0)+ ";\n")
131 | model.write("feature 2, average value: " + str(aver_feature3_0)  + ", standard error: " + str(var_feature3_0)+ ";\n")
132 | 
133 | 
134 | 
135 | aver_feature1_1 = np.array(Training_1[:,0]).mean()
136 | var_feature1_1 = np.array(Training_1[:,0]).var()+0.001
137 | aver_feature2_1 = np.array(Training_1[:,1]).mean()
138 | var_feature2_1 = np.array(Training_1[:,1]).var()+0.001
139 | aver_feature3_1 = np.array(Training_1[:,2]).mean()
140 | var_feature3_1 = np.array(Training_1[:,2]).var()
141 | 
142 | model.write("class 1: \n")
143 | model.write("feature 1, average value: " + str(aver_feature1_1)  + ", standard error: " + str(var_feature1_1)+ ";\n")
144 | model.write("feature 2, average value: " + str(aver_feature2_1)  + ", standard error: " + str(var_feature2_1)+ ";\n")
145 | model.write("feature 2, average value: " + str(aver_feature3_1)  + ", standard error: " + str(var_feature3_1)+ ";\n")
146 | 
147 | 
148 | aver_feature1_2 = np.array(Training_2[:,0]).mean()
149 | var_feature1_2 = np.array(Training_2[:,0]).var()+0.001
150 | aver_feature2_2 = np.array(Training_2[:,1]).mean()
151 | var_feature2_2 = np.array(Training_2[:,1]).var()+0.001
152 | aver_feature3_2 = np.array(Training_2[:,2]).mean()
153 | var_feature3_2 = np.array(Training_2[:,2]).var()+0.001
154 | 
155 | model.write("class 2: \n")
156 | model.write("feature 1, average value: " + str(aver_feature1_2)  + ", standard error: " + str(var_feature1_2)+ ";\n")
157 | model.write("feature 2, average value: " + str(aver_feature2_2)  + ", standard error: " + str(var_feature2_2)+ ";\n")
158 | model.write("feature 2, average value: " + str(aver_feature3_2)  + ", standard error: " + str(var_feature3_2)+ ";\n")
159 | 
160 | 
161 | 
162 | 
163 | aver_feature1_3 = np.array(Training_3[:,0]).mean()
164 | var_feature1_3 = np.array(Training_3[:,0]).var()+0.001
165 | aver_feature2_3 = np.array(Training_3[:,1]).mean()
166 | var_feature2_3 = np.array(Training_3[:,1]).var()+0.001
167 | aver_feature3_3 = np.array(Training_3[:,2]).mean()
168 | var_feature3_3 = np.array(Training_3[:,2]).var()+0.001
169 | 
170 | model.write("class 3: \n")
171 | model.write("feature 1, average value: " + str(aver_feature1_3)  + ", standard error: " + str(var_feature1_3)+ ";\n")
172 | model.write("feature 2, average value: " + str(aver_feature2_3)  + ", standard error: " + str(var_feature2_3)+ ";\n")
173 | model.write("feature 2, average value: " + str(aver_feature3_3)  + ", standard error: " + str(var_feature3_3)+ ";\n")
174 | 
175 | 
176 | 
177 | aver_feature1_4 = np.array(Training_4[:,0]).mean()
178 | var_feature1_4 = np.array(Training_4[:,0]).var()+0.001
179 | aver_feature2_4 = np.array(Training_4[:,1]).mean()
180 | var_feature2_4 = np.array(Training_4[:,1]).var()+0.001
181 | aver_feature3_4= np.array(Training_4[:,2]).mean()
182 | var_feature3_4= np.array(Training_4[:,2]).var()+0.001
183 | 
184 | model.write("class 4: \n")
185 | model.write("feature 1, average value: " + str(aver_feature1_4)  + ", standard error: " + str(var_feature1_4)+ ";\n")
186 | model.write("feature 2, average value: " + str(aver_feature2_4)  + ", standard error: " + str(var_feature2_4)+ ";\n")
187 | model.write("feature 2, average value: " + str(aver_feature3_4)  + ", standard error: " + str(var_feature3_4)+ ";\n")
188 | 
189 | 
190 | 
191 | model.close()
192 | 


--------------------------------------------------------------------------------
/iisy_sw/IoT_ML/iot_decisiontree.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python
  2 | #################################################################################
  3 | #
  4 | # Copyright (c) 2019 Zhaoqi Xiong, Noa Zilberman
  5 | # All rights reserved.
  6 | #
  7 | #
  8 | # @NETFPGA_LICENSE_HEADER_START@
  9 | #
 10 | # Licensed to NetFPGA C.I.C. (NetFPGA) under one or more contributor
 11 | # license agreements.  See the NOTICE file distributed with this work for
 12 | # additional information regarding copyright ownership.  NetFPGA licenses this
 13 | # file to you under the NetFPGA Hardware-Software License, Version 1.0 (the
 14 | # "License"); you may not use this file except in compliance with the
 15 | # License.  You may obtain a copy of the License at:
 16 | #
 17 | #   http://www.netfpga-cic.org
 18 | #
 19 | # Unless required by applicable law or agreed to in writing, Work distributed
 20 | # under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
 21 | # CONDITIONS OF ANY KIND, either express or implied.  See the License for the
 22 | # specific language governing permissions and limitations under the License.
 23 | #
 24 | # @NETFPGA_LICENSE_HEADER_END@
 25 | #
 26 | ################################################################################# 
 27 | 
 28 | import numpy as np
 29 | import pandas as pd
 30 | import argparse
 31 | from sklearn.tree import DecisionTreeClassifier
 32 | from sklearn.metrics import *
 33 | from sklearn.tree import export_graphviz
 34 | import pydotplus
 35 | 
 36 | 
 37 | 
 38 | parser = argparse.ArgumentParser()
 39 | 
 40 | # Add argument
 41 | parser.add_argument('-i', required=True, help='path to training dataset')
 42 | parser.add_argument('-o', required=True, help='path to outputfile')
 43 | parser.add_argument('-t', required=True, help='path to test dataset')
 44 | args = parser.parse_args()
 45 | 
 46 | input = args.i
 47 | test = args.t
 48 | outputfile = args.o
 49 | 
 50 | 
 51 | def get_lineage(tree, feature_names, file):
 52 | 
 53 |     frame_len=[]  
 54 |     eth_type=[]
 55 |     ip_proto=[]
 56 |     ip_flags=[]
 57 |     ipv6_nxt=[]
 58 |     ipv6_opt=[]
 59 |     tcp_srcport=[]
 60 |     tcp_dstport=[]
 61 |     tcp_flags=[]
 62 |     udp_srcport=[]
 63 |     udp_dstport=[]
 64 |     left = tree.tree_.children_left
 65 |     right = tree.tree_.children_right
 66 |     threshold = tree.tree_.threshold
 67 |     features = [feature_names[i] for i in tree.tree_.feature]
 68 |     value = tree.tree_.value
 69 |     le = '<='
 70 |     g = '>'
 71 |     # get ids of child nodes
 72 |     idx = np.argwhere(left == -1)[:, 0]
 73 |     
 74 |     def recurse(left, right, child, lineage=None):
 75 |         if lineage is None:
 76 |             lineage = [child]
 77 |         if child in left:
 78 |             parent = np.where(left == child)[0].item()
 79 |             split = 'l'
 80 |         else:
 81 |             parent = np.where(right == child)[0].item()
 82 |             split = 'r'
 83 |         
 84 |         lineage.append((parent, split, threshold[parent], features[parent]))
 85 |         if parent == 0:
 86 |             lineage.reverse()
 87 |             return lineage
 88 |         else:
 89 |             return recurse(left, right, parent, lineage)
 90 | 
 91 |     for j, child in enumerate(idx):
 92 |         clause = ' when '
 93 |         for node in recurse(left, right, child):
 94 |                 if len(str(node)) < 3:
 95 |                     continue
 96 |                 i = node
 97 |                 
 98 |                 if i[1] == 'l':
 99 |                     sign = le
100 |                 else:
101 |                     sign = g
102 |                 clause = clause + i[3] + sign + str(i[2]) + ' and '
103 | 
104 |         a = list(value[node][0])
105 |         ind = a.index(max(a))
106 |         clause = clause[:-4] + ' then ' + str(ind)
107 |         file.write(clause)
108 |         file.write(";\n")
109 | 
110 | 
111 | Set1 = pd.read_csv(input)
112 | Set = Set1.values.tolist()
113 | X = [i[0:10] for i in Set]
114 | Y = [i[11] for i in Set]
115 | class_names=['smart-static','sensor','audio','video','else']
116 | feature_names=['frame_len','eth_type','ip_proto','ip_flags','ipv6_nxt','ipv6_opt','tcp_srcport','tcp_dstport','tcp_flags','udp_srcport','udp_dstport']
117 | 
118 | 
119 | 
120 | #debug = open("debug.txt","w+")
121 | #debug.write("Y = ")
122 | #debug.write(str(Y))
123 | #debug.write(";\n")
124 | #debug.close()
125 | 
126 | 
127 | #prepare training and testing set
128 | X = np.array(X)
129 | Y = np.array(Y)
130 | 
131 | # decision tree fit
132 | 
133 | dt = DecisionTreeClassifier(max_depth = 5)
134 | dt.fit(X, Y)
135 | Predict_Y = dt.predict(X)
136 | print(accuracy_score(Y, Predict_Y))
137 | #print("\tBrier: %1.3f" % (clf_score))
138 | print("\tPrecision: %1.3f" % precision_score(Y, Predict_Y,average='weighted'))
139 | print("\tRecall: %1.3f" % recall_score(Y, Predict_Y,average='weighted'))
140 | print("\tF1: %1.3f\n" % f1_score(Y, Predict_Y,average='weighted'))
141 | 
142 | #Test set 
143 | Set2 = pd.read_csv(test)
144 | Set_t = Set2.values.tolist()
145 | Xt = [i[0:10] for i in Set_t]
146 | Yt = [i[11] for i in Set_t]
147 | 
148 | Predict_Yt = dt.predict(Xt)
149 | print(accuracy_score(Yt, Predict_Yt))
150 | #print("\tBrier: %1.3f" % (clf_score))
151 | print("\tPrecision: %1.3f" % precision_score(Yt, Predict_Yt,average='weighted'))
152 | print("\tRecall: %1.3f" % recall_score(Yt, Predict_Yt,average='weighted'))
153 | print("\tF1: %1.3f\n" % f1_score(Yt, Predict_Yt,average='weighted'))
154 | 
155 | print(confusion_matrix(Yt, Predict_Yt))
156 | 
157 | # output
158 | threshold = dt.tree_.threshold
159 | features  = [feature_names[i] for i in dt.tree_.feature]
160 | frame_len=[]
161 | eth_type=[]
162 | ip_proto=[]
163 | ip_flags=[]
164 | ipv6_nxt=[]
165 | ipv6_opt=[]
166 | tcp_srcport=[]
167 | tcp_dstport=[]
168 | tcp_flags=[]
169 | udp_srcport=[]
170 | udp_dstport=[]
171 | 
172 | for i, fe in enumerate(features):
173 | 
174 |     if fe == 'frame_len' and threshold[i]>-2:
175 |         frame_len.append(threshold[i])
176 |     elif fe == 'eth_type' and threshold[i]>-2:
177 |         eth_type.append(threshold[i])
178 |     elif fe == 'ip_proto' and threshold[i]>-2:
179 |         ip_proto.append(threshold[i])
180 |     elif fe == 'ip_flags' and threshold[i]>-2:
181 |         ip_flags.append(threshold[i])
182 |     elif fe == 'ipv6_nxt' and threshold[i]>-2:
183 |         ipv6_nxt.append(threshold[i])
184 |     elif fe == 'ipv6_opt' and threshold[i]>-2:
185 |          ipv6_opt.append(threshold[i])
186 |     elif fe == 'tcp_srcport' and threshold[i]>-2:
187 |         tcp_srcport.append(threshold[i])
188 |     elif fe == 'tcp_dstport' and threshold[i]>-2:
189 |         tcp_dstport.append(threshold[i])
190 |     elif fe == 'tcp_flags' and threshold[i]>-2:
191 |         tcp_flags.append(threshold[i])
192 |     elif fe == 'udp_srcport' and threshold[i]>-2:
193 |         udp_srcport.append(threshold[i])
194 |     else:
195 |         if threshold[i]>-2:
196 | 	        udp_dstport.append(threshold[i])
197 | #proto = [int(i) for i in proto]
198 | #src = [int(i) for i in src]
199 | #dst = [int(i) for i in dst]
200 | #proto.sort()
201 | #src.sort()
202 | #dst.sort()
203 | 
204 | tree = open(outputfile,"w+")
205 | tree.write("frame_len = ")
206 | tree.write(str(frame_len))
207 | tree.write(";\n")
208 | tree.write("eth_type = ")
209 | tree.write(str(eth_type))
210 | tree.write(";\n")
211 | tree.write("ip_proto = ")
212 | tree.write(str(ip_proto))
213 | tree.write(";\n")
214 | tree.write("ip_flags = ")
215 | tree.write(str(ip_flags))
216 | tree.write(";\n")
217 | tree.write("ipv6_nxt = ")
218 | tree.write(str(ipv6_nxt))
219 | tree.write(";\n")
220 | tree.write("ipv6_opt = ")
221 | tree.write(str(ipv6_opt))
222 | tree.write(";\n")
223 | tree.write("tcp_srcport = ")
224 | tree.write(str(tcp_srcport))
225 | tree.write(";\n")
226 | tree.write("tcp_dstport = ")
227 | tree.write(str(tcp_dstport))
228 | tree.write(";\n")
229 | tree.write("tcp_flags = ")
230 | tree.write(str(tcp_flags))
231 | tree.write(";\n")
232 | tree.write("udp_srcport = ")
233 | tree.write(str(udp_srcport))
234 | tree.write(";\n")
235 | tree.write("udp_dstport = ")
236 | tree.write(str(udp_dstport))
237 | tree.write(";\n")
238 | get_lineage(dt,feature_names,tree)
239 | 
240 | tree.close()
241 | 


--------------------------------------------------------------------------------
/iisy_sw/simple_example/svm/svm.p4:
--------------------------------------------------------------------------------
  1 | 
  2 | /* -*- P4_16 -*- */
  3 | /********************************************************************************
  4 | *
  5 | * Copyright (c) 2019 Zhaoqi Xiong
  6 | * All rights reserved.
  7 | *
  8 | *
  9 | * @NETFPGA_LICENSE_HEADER_START@
 10 | *
 11 | * Licensed to NetFPGA C.I.C. (NetFPGA) under one or more contributor
 12 | * license agreements.  See the NOTICE file distributed with this work for
 13 | * additional information regarding copyright ownership.  NetFPGA licenses this
 14 | * file to you under the NetFPGA Hardware-Software License, Version 1.0 (the
 15 | * "License"); you may not use this file except in compliance with the
 16 | * License.  You may obtain a copy of the License at:
 17 | *
 18 | *   http://www.netfpga-cic.org
 19 | *
 20 | * Unless required by applicable law or agreed to in writing, Work distributed
 21 | * under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
 22 | * CONDITIONS OF ANY KIND, either express or implied.  See the License for the
 23 | * specific language governing permissions and limitations under the License.
 24 | *
 25 | * @NETFPGA_LICENSE_HEADER_END@
 26 | *
 27 | ********************************************************************************/
 28 | 
 29 | #include <core.p4>
 30 | #include <v1model.p4>
 31 | 
 32 | const bit<16> TYPE_IPV4 = 0x800;
 33 | 
 34 | /*************************************************************************
 35 | *********************** H E A D E R S  ***********************************
 36 | *************************************************************************/
 37 | 
 38 | typedef bit<9>  egressSpec_t;
 39 | typedef bit<48> macAddr_t;
 40 | typedef bit<32> ip4Addr_t;
 41 | 
 42 | header ethernet_t {
 43 |     macAddr_t dstAddr;
 44 |     macAddr_t srcAddr;
 45 |     bit<16>   etherType;
 46 | }
 47 | 
 48 | header ipv4_t {
 49 |     bit<4>    version;
 50 |     bit<4>    ihl;
 51 |     bit<8>    diffserv;
 52 |     bit<16>   totalLen;
 53 |     bit<16>   identification;
 54 |     bit<3>    flags;
 55 |     bit<13>   fragOffset;
 56 |     bit<8>    ttl;
 57 |     bit<8>    protocol;
 58 |     bit<16>   hdrChecksum;
 59 |     ip4Addr_t srcAddr;
 60 |     ip4Addr_t dstAddr;
 61 | }
 62 | 
 63 | header tcp_t {
 64 |     bit<16> srcPort;
 65 |     bit<16> dstPort;
 66 |     bit<32> seqNo;
 67 |     bit<32> ackNo;
 68 |     bit<4>  dataOffset;
 69 |     bit<3>  res;
 70 |     bit<3>  ecn;
 71 |     bit<6>  ctrl;
 72 |     bit<16> window;
 73 |     bit<16> checksum;
 74 |     bit<16> urgentPtr;
 75 | }
 76 | 
 77 | struct metadata {
 78 |     bit<32> action_select;
 79 |     bit<32> classification;
 80 | }
 81 | 
 82 | struct headers {
 83 |     ethernet_t  ethernet;
 84 |     ipv4_t     ipv4;
 85 |     tcp_t      tcp;
 86 | }
 87 | 
 88 | /*************************************************************************
 89 | *********************** P A R S E R  ***********************************
 90 | *************************************************************************/
 91 | 
 92 | parser MyParser(packet_in packet,
 93 |                 out headers hdr,
 94 |                 inout metadata meta,
 95 |                 inout standard_metadata_t standard_metadata) {
 96 |     
 97 |     state start {
 98 |         transition parse_ethernet;
 99 |     }
100 |     
101 |     state parse_ethernet {
102 |         packet.extract(hdr.ethernet);
103 |         transition select(hdr.ethernet.etherType) {
104 |             TYPE_IPV4: parse_ipv4;
105 |             default: accept;
106 | }
107 | }
108 |     
109 |     state parse_ipv4 {
110 |         packet.extract(hdr.ipv4);
111 |         transition select(hdr.ipv4.protocol) {
112 |             6: parse_tcp;
113 |             default: accept;
114 |     }
115 |     }
116 |     state parse_tcp {
117 |         packet.extract(hdr.tcp);
118 |         transition accept;
119 | }
120 | }
121 | 
122 | /*************************************************************************
123 | ************   C H E C K S U M    V E R I F I C A T I O N   *************
124 | *************************************************************************/
125 | 
126 | control MyVerifyChecksum(inout headers hdr, inout metadata meta) {
127 |     apply {  }
128 | }
129 | 
130 | 
131 | /*************************************************************************
132 | **************  I N G R E S S   P R O C E S S I N G   *******************
133 | *************************************************************************/
134 | 
135 | control MyIngress(inout headers hdr,
136 |                   inout metadata meta,
137 |                   inout standard_metadata_t standard_metadata) {
138 |     action drop() {
139 |         mark_to_drop();
140 |     }
141 | 
142 |     action ipv4_forward(macAddr_t dstAddr, egressSpec_t port) {
143 |         standard_metadata.egress_spec = port;
144 |         hdr.ethernet.srcAddr = hdr.ethernet.dstAddr;
145 |         hdr.ethernet.dstAddr = dstAddr;
146 |         }
147 | 
148 | 
149 | action set_p( bit<32> distance){
150 |     meta.action_select =  distance;
151 | }
152 | 
153 | 
154 | table classification {
155 |     key = {
156 |         hdr.tcp.srcPort: exact;
157 |         hdr.tcp.dstPort: exact;
158 |         }
159 |         actions = {
160 |             NoAction;
161 |             set_p;
162 |             }
163 |         size = 70000;
164 | }
165 | 
166 | 
167 | 
168 | 
169 | 
170 | table ipv4_exact {
171 |     key = {
172 |         meta.classification: exact;
173 | }
174 |     
175 |     actions = {
176 |         ipv4_forward;
177 |         drop;
178 |         NoAction;
179 | }
180 |     size = 1024;
181 |         default_action = drop();
182 |     }
183 |     
184 |     apply {
185 |         if (hdr.ipv4.isValid() ) {
186 |             if(hdr.ipv4.protocol ==6) {
187 |                 classification.apply();
188 | 
189 | if ( meta.action_select == 1)
190 |     {  meta.classification = 1; }
191 |         else { meta.classification = 2;}
192 | }
193 | 
194 | }
195 | 
196 | ipv4_exact.apply();
197 | 
198 | }
199 | }
200 | 
201 | /*************************************************************************
202 | ****************  E G R E S S   P R O C E S S I N G   *******************
203 | *************************************************************************/
204 | 
205 | control MyEgress(inout headers hdr,
206 |                  inout metadata meta,
207 |                  inout standard_metadata_t standard_metadata) {
208 |     apply {  }
209 | }
210 | 
211 | /*************************************************************************
212 | *************   C H E C K S U M    C O M P U T A T I O N   **************
213 | *************************************************************************/
214 | 
215 | control MyComputeChecksum(inout headers  hdr, inout metadata meta) {
216 |     apply {
217 |     update_checksum(
218 |                     hdr.ipv4.isValid(),
219 |                     { hdr.ipv4.version,
220 |                     hdr.ipv4.ihl,
221 |                     hdr.ipv4.diffserv,
222 |                     hdr.ipv4.totalLen,
223 |                     hdr.ipv4.identification,
224 |                     hdr.ipv4.flags,
225 |                     hdr.ipv4.fragOffset,
226 |                     hdr.ipv4.ttl,
227 |                     hdr.ipv4.protocol,
228 |                     hdr.ipv4.srcAddr,
229 |                     hdr.ipv4.dstAddr },
230 |                     hdr.ipv4.hdrChecksum,
231 |                     HashAlgorithm.csum16);
232 | }
233 | }
234 | 
235 | /*************************************************************************
236 | ***********************  D E P A R S E R  *******************************
237 | *************************************************************************/
238 | 
239 | control MyDeparser(packet_out packet, in headers hdr) {
240 |     apply {
241 |         packet.emit(hdr.ethernet);
242 |         packet.emit(hdr.ipv4);
243 |         packet.emit(hdr.tcp);
244 | }
245 | }
246 | 
247 | /*************************************************************************
248 | ***********************  S W I T C H  *******************************
249 | *************************************************************************/
250 | 
251 | V1Switch(
252 |          MyParser(),
253 |          MyVerifyChecksum(),
254 |          MyIngress(),
255 |          MyEgress(),
256 |          MyComputeChecksum(),
257 |          MyDeparser()
258 |          ) main;
259 | 


--------------------------------------------------------------------------------
/iisy_hw/iisy_decision_tree.p4:
--------------------------------------------------------------------------------
  1 | //
  2 | // Copyright (c) 2019 Noa Zilberman
  3 | // All rights reserved.
  4 | //
  5 | //
  6 | // @NETFPGA_LICENSE_HEADER_START@
  7 | //
  8 | // Licensed to NetFPGA C.I.C. (NetFPGA) under one or more contributor
  9 | // license agreements.  See the NOTICE file distributed with this work for
 10 | // additional information regarding copyright ownership.  NetFPGA licenses this
 11 | // file to you under the NetFPGA Hardware-Software License, Version 1.0 (the
 12 | // "License"); you may not use this file except in compliance with the
 13 | // License.  You may obtain a copy of the License at:
 14 | //
 15 | //   http://www.netfpga-cic.org
 16 | //
 17 | // Unless required by applicable law or agreed to in writing, Work distributed
 18 | // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
 19 | // CONDITIONS OF ANY KIND, either express or implied.  See the License for the
 20 | // specific language governing permissions and limitations under the License.
 21 | //
 22 | // @NETFPGA_LICENSE_HEADER_END@
 23 | //
 24 | 
 25 | 
 26 | #include <core.p4>
 27 | #include <sume_switch.p4>
 28 | 
 29 | 
 30 | typedef bit<48> EthAddr_t; 
 31 | typedef bit<32> IPv4Addr_t;
 32 | typedef bit<16> TCPAddr_t;
 33 | 
 34 | #define IPV4_TYPE 0x0800
 35 | #define IPV6_TYPE 0x86DD
 36 | #define TCP_TYPE 6
 37 | 
 38 | //Standard Ethernet Header
 39 | header Ethernet_h {
 40 |     EthAddr_t dstAddr;
 41 |     EthAddr_t srcAddr;
 42 |     bit<16> etherType;
 43 | }
 44 | 
 45 | //IPv4 header without options
 46 | header IPv4_h {
 47 |     bit<4> version;
 48 |     bit<4> ihl;
 49 |     bit<8> tos;
 50 |     bit<16> totalLen;
 51 |     bit<16> identification;
 52 |     bit<3> flags;
 53 |     bit<13> fragOffset;
 54 |     bit<8> ttl;
 55 |     bit<8> protocol;
 56 |     bit<16> hdrChecksum;
 57 |     IPv4Addr_t srcAddr;
 58 |     IPv4Addr_t dstAddr;
 59 | }
 60 | 
 61 | //IPv6 header
 62 | header IPv6_h{
 63 |   bit<4> version;
 64 |   bit<8> trafficClass;
 65 |   bit<20> flowLabel;
 66 |   bit<16> payloadLen;
 67 |   bit<8> nxt;
 68 |   bit<8> hopLimit;
 69 |   bit<128> srcAddr;
 70 |   bit<128> dstAddr;
 71 | }
 72 | 
 73 | //TCP header without options
 74 | header TCP_h {
 75 |     bit<16> srcPort;
 76 |     bit<16> dstPort;
 77 |     bit<32> seqNo;
 78 |     bit<32> ackNo;
 79 |     bit<4> dataOffset;
 80 |     bit<4> res;
 81 |     bit<8> flags;
 82 |     bit<16> window;
 83 |     bit<16> checksum;
 84 |     bit<16> urgentPtr;
 85 | }
 86 | 
 87 | 
 88 | // List of all recognized headers
 89 | struct Parsed_packet {
 90 |     Ethernet_h ethernet;
 91 |     IPv4_h ip;
 92 |     IPv6_h ip6;
 93 |     TCP_h tcp;
 94 | }
 95 | 
 96 | 
 97 | // user defined metadata
 98 | // used for coding the decision word
 99 | //each code is a result of a lookup
100 | struct user_metadata_t {
101 |     bit<5> pkt_len_code;
102 |     bit<5> ip_proto_code;
103 |     bit<5> ip_flags_code;
104 |     bit<5> tcp_srcport_code;
105 |     bit<5> tcp_dstport_code;
106 |     bit<7> unused; 
107 | }
108 | 
109 | // digest_data, MUST be 256 bits
110 | struct digest_data_t {
111 |     bit<256> unused;
112 | }
113 | 
114 | // Parser Implementation
115 | 
116 | @Xilinx_MaxPacketRegion(8192)
117 | parser TopParser(packet_in b,
118 |                  out Parsed_packet p,
119 |                  out user_metadata_t user_metadata,
120 |                  out digest_data_t digest_data,
121 |                  inout sume_metadata_t sume_metadata) {
122 |     state start {
123 |         b.extract(p.ethernet);
124 |         user_metadata.unused = 0;
125 |         digest_data.unused = 0;
126 |         transition select(p.ethernet.etherType) {
127 |             IPV4_TYPE: parse_ipv4;
128 |             IPV6_TYPE: parse_ipv6;
129 |             default: accept;
130 |         }
131 |     }
132 | 
133 |     state parse_ipv4 {
134 |         b.extract(p.ip);
135 |         transition select(p.ip.protocol) {
136 |             TCP_TYPE: parse_tcp;
137 |             default: accept;
138 |         }
139 |     }
140 | 
141 |     state parse_ipv6 {
142 |         b.extract(p.ip6);
143 |         transition select(p.ip6.nxt) {
144 |             TCP_TYPE: parse_tcp;
145 |             default: accept;
146 |         }
147 |     }
148 | 
149 |     state parse_tcp {
150 |         b.extract(p.tcp);
151 |         transition accept;
152 |     }
153 | }
154 | 
155 | 
156 | // match-action pipeline
157 | control TopPipe(inout Parsed_packet p,
158 |                 inout user_metadata_t user_metadata, 
159 |                 inout digest_data_t digest_data,
160 |                 inout sume_metadata_t sume_metadata) {
161 | 
162 | 
163 |     action set_output_port(port_t port) {
164 |         sume_metadata.dst_port = port;
165 |     }
166 | 
167 |     
168 |     action set_default_port (){
169 |         sume_metadata.dst_port = 0x1;
170 |     }
171 | 
172 |  
173 |     action set_len_code(bit<5> code){
174 |         user_metadata.pkt_len_code = code;
175 |     }
176 |     
177 |     action set_ip_proto_code(bit<5> code){
178 |         user_metadata.ip_proto_code = code;
179 |     }
180 | 
181 |     action set_ip_flags_code(bit<5> code){
182 |         user_metadata.ip_flags_code = code;
183 |     }
184 |     
185 |     action set_tcp_srcport_code(bit<5> code){
186 |         user_metadata.tcp_srcport_code = code;
187 |     }
188 | 
189 |     action set_tcp_dstport_code(bit<5> code){
190 |         user_metadata.tcp_dstport_code = code;
191 |     }
192 | 
193 | 
194 | //Lookup table - packet length
195 | 
196 |     table lookup_len {
197 |         key = { sume_metadata.pkt_len:ternary; }
198 | 
199 |         actions = {
200 |             set_len_code;
201 |             NoAction;
202 |         }
203 |         size = 63;
204 |         default_action = NoAction;
205 |     }
206 | 
207 | 
208 | //Lookup table - IPv4 protocol
209 | 
210 |     table lookup_ip_proto {
211 |         key = { p.ip.protocol:ternary; }
212 | 
213 |         actions = {
214 |             set_ip_proto_code;
215 |             NoAction;
216 |         }
217 |         size = 63;
218 |         default_action = NoAction;
219 |     }
220 | 
221 | //Lookup table - IPv4 flags
222 |     table lookup_ip_flags {
223 |         key = { p.ip.flags:ternary; }
224 | 
225 |         actions = {
226 |             set_ip_flags_code;
227 |             NoAction;
228 |         }
229 |         size = 63;
230 |         default_action = NoAction;
231 |     }
232 | 
233 | 
234 | //Lookup table - TCP source port
235 |      table lookup_tcp_srcport {
236 |         key = { p.tcp.srcPort:ternary; }
237 | 
238 |         actions = {
239 |             set_tcp_srcport_code;
240 |             NoAction;
241 |         }
242 |         size = 63;
243 |         default_action = NoAction;
244 |     }
245 | 
246 | //Lookup table - TCP dest port
247 |      table lookup_tcp_dstport {
248 |         key = { p.tcp.dstPort:ternary; }
249 | 
250 |         actions = {
251 |             set_tcp_dstport_code;
252 | 	    NoAction;
253 |         }
254 |         size = 63;
255 |         default_action = NoAction;
256 |     }
257 | 
258 | //Decision table - lookup code
259 |      table lookup_code {
260 |         key = { user_metadata.pkt_len_code++user_metadata.ip_proto_code++user_metadata.ip_flags_code++user_metadata.tcp_srcport_code++user_metadata.tcp_dstport_code:exact @name("code"); }
261 | 
262 |         actions = {
263 |             set_output_port;
264 |             set_default_port;
265 |         }
266 |         size = 64;
267 |         default_action = set_default_port;
268 |     }
269 | 
270 | 
271 | 
272 | 
273 |     apply {
274 | 
275 |         user_metadata.pkt_len_code=0;
276 |         user_metadata.ip_proto_code=0;
277 |         user_metadata.ip_flags_code=0;
278 |         user_metadata.tcp_srcport_code=0;
279 |         user_metadata.tcp_dstport_code=0;
280 |        
281 |         lookup_len.apply();
282 |         
283 | 
284 |         if (p.ip.isValid()) {
285 | 
286 |             lookup_ip_proto.apply();
287 |             lookup_ip_flags.apply();
288 |         }
289 | 
290 |         if (p.tcp.isValid()){
291 |             lookup_tcp_srcport.apply();
292 |             lookup_tcp_dstport.apply();
293 |         }
294 |   
295 |         if (!lookup_code.apply().hit) {
296 |             sume_metadata.drop = 1;
297 |         }
298 |       }
299 | }
300 | 
301 | // Deparser Implementation
302 | @Xilinx_MaxPacketRegion(1024)
303 | control TopDeparser(packet_out b,
304 |                     in Parsed_packet p,
305 |                     in user_metadata_t user_metadata,
306 |                     inout digest_data_t digest_data,
307 |                     inout sume_metadata_t sume_metadata) { 
308 |     apply {
309 |         b.emit(p.ethernet); 
310 |         b.emit(p.ip);
311 |         b.emit(p.ip6);
312 | 	b.emit(p.tcp);
313 |     }
314 | }
315 | 
316 | 
317 | // Instantiate the switch
318 | SimpleSumeSwitch(TopParser(), TopPipe(), TopDeparser()) main;
319 | 
320 | 


--------------------------------------------------------------------------------
/iisy_sw/simple_example/decision_tree/decision_tree.p4:
--------------------------------------------------------------------------------
  1 | /* -*- P4_16 -*- */
  2 | /********************************************************************************
  3 | *
  4 | * Copyright (c) 2019 Zhaoqi Xiong
  5 | * All rights reserved.
  6 | *
  7 | *
  8 | * @NETFPGA_LICENSE_HEADER_START@
  9 | *
 10 | * Licensed to NetFPGA C.I.C. (NetFPGA) under one or more contributor
 11 | * license agreements.  See the NOTICE file distributed with this work for
 12 | * additional information regarding copyright ownership.  NetFPGA licenses this
 13 | * file to you under the NetFPGA Hardware-Software License, Version 1.0 (the
 14 | * "License"); you may not use this file except in compliance with the
 15 | * License.  You may obtain a copy of the License at:
 16 | *
 17 | *   http://www.netfpga-cic.org
 18 | *
 19 | * Unless required by applicable law or agreed to in writing, Work distributed
 20 | * under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
 21 | * CONDITIONS OF ANY KIND, either express or implied.  See the License for the
 22 | * specific language governing permissions and limitations under the License.
 23 | *
 24 | * @NETFPGA_LICENSE_HEADER_END@
 25 | *
 26 | ********************************************************************************/
 27 | 
 28 | 
 29 | #include <core.p4>
 30 | #include <v1model.p4>
 31 | 
 32 | const bit<16> TYPE_IPV4 = 0x800;
 33 | 
 34 | /*************************************************************************
 35 | *********************** H E A D E R S  ***********************************
 36 | *************************************************************************/
 37 | 
 38 | typedef bit<9>  egressSpec_t;
 39 | typedef bit<48> macAddr_t;
 40 | typedef bit<32> ip4Addr_t;
 41 | 
 42 | header ethernet_t {
 43 |     macAddr_t dstAddr;
 44 |     macAddr_t srcAddr;
 45 |     bit<16>   etherType;
 46 | }
 47 | 
 48 | header ipv4_t {
 49 |     bit<4>    version;
 50 |     bit<4>    ihl;
 51 |     bit<8>    diffserv;
 52 |     bit<16>   totalLen;
 53 |     bit<16>   identification;
 54 |     bit<3>    flags;
 55 |     bit<13>   fragOffset;
 56 |     bit<8>    ttl;
 57 |     bit<8>    protocol;
 58 |     bit<16>   hdrChecksum;
 59 |     ip4Addr_t srcAddr;
 60 |     ip4Addr_t dstAddr;
 61 | }
 62 | 
 63 | header tcp_t {
 64 |     bit<16> srcPort;
 65 |     bit<16> dstPort;
 66 |     bit<32> seqNo;
 67 |     bit<32> ackNo;
 68 |     bit<4>  dataOffset;
 69 |     bit<3>  res;
 70 |     bit<3>  ecn;
 71 |     bit<6>  ctrl;
 72 |     bit<16> window;
 73 |     bit<16> checksum;
 74 |     bit<16> urgentPtr;
 75 | }
 76 | 
 77 | struct metadata {
 78 |      bit<14> action_select1;
 79 |      bit<14> action_select2;
 80 |      bit<14> action_select3;
 81 | }
 82 | 
 83 | struct headers {
 84 |     ethernet_t   ethernet;
 85 |     ipv4_t       ipv4;
 86 |     tcp_t      tcp;
 87 | }
 88 | 
 89 | /*************************************************************************
 90 | *********************** P A R S E R  ***********************************
 91 | *************************************************************************/
 92 | 
 93 | parser MyParser(packet_in packet,
 94 |                 out headers hdr,
 95 |                 inout metadata meta,
 96 |                 inout standard_metadata_t standard_metadata) {
 97 | 
 98 |     state start {
 99 |         transition parse_ethernet;
100 |     }
101 | 
102 |     state parse_ethernet {
103 |         packet.extract(hdr.ethernet);
104 |         transition select(hdr.ethernet.etherType) {
105 |             TYPE_IPV4: parse_ipv4;
106 |             default: accept;
107 |         }
108 |     }
109 | 
110 |    state parse_ipv4 {
111 |         packet.extract(hdr.ipv4);
112 |         transition select(hdr.ipv4.protocol) {
113 |             6: parse_tcp;
114 |             default: accept;
115 |     }
116 |     }
117 |     state parse_tcp {
118 |         packet.extract(hdr.tcp);
119 |         transition accept;
120 | }
121 | }
122 | 
123 | /*************************************************************************
124 | ************   C H E C K S U M    V E R I F I C A T I O N   *************
125 | *************************************************************************/
126 | 
127 | control MyVerifyChecksum(inout headers hdr, inout metadata meta) {   
128 |     apply {  }
129 | }
130 | 
131 | 
132 | /*************************************************************************
133 | **************  I N G R E S S   P R O C E S S I N G   *******************
134 | *************************************************************************/
135 | 
136 | control MyIngress(inout headers hdr,
137 |                   inout metadata meta,
138 |                   inout standard_metadata_t standard_metadata) {
139 |     action drop() {
140 |         mark_to_drop();
141 |     }
142 |     
143 |     action ipv4_forward(macAddr_t dstAddr, egressSpec_t port) {
144 |         standard_metadata.egress_spec = port;
145 |         hdr.ethernet.srcAddr = hdr.ethernet.dstAddr;
146 |         hdr.ethernet.dstAddr = dstAddr;
147 |     }
148 | 
149 |    action set_actionselect1(bit<14> featurevalue1){
150 |         meta.action_select1 = featurevalue1 ;
151 | 
152 |    }
153 | 
154 | action set_actionselect2(bit<14> featurevalue2){
155 |         meta.action_select2 = featurevalue2 ;
156 | 
157 |    }
158 | 
159 | action set_actionselect3(bit<14> featurevalue3){
160 |         meta.action_select3 = featurevalue3;
161 | 
162 |    }
163 |  
164 |    table feature1_exact{
165 |         key = {
166 |             hdr.ipv4.protocol : range ;
167 |         }
168 |         actions = {
169 | 	   NoAction;
170 |             set_actionselect1;
171 |         }
172 |         size = 1024;
173 | } 
174 | 
175 | table feature2_exact{
176 |         key = {
177 |             hdr.tcp.srcPort : range ;
178 |         }
179 |         actions = {
180 | 	   NoAction;
181 |             set_actionselect2;
182 |         }
183 |        size = 1024;
184 | }
185 | 
186 | table feature3_exact{
187 |         key = {
188 |             hdr.tcp.dstPort : range ;
189 |         }
190 |         actions = {
191 | 	   NoAction;
192 |             set_actionselect3;
193 |         }
194 |         size = 1024;
195 | }
196 | 
197 |     
198 |     
199 |     table ipv4_exact {
200 |         key = {
201 |             meta.action_select1: range;
202 |             meta.action_select2: range;
203 |             meta.action_select3: range;
204 |   }
205 |         actions = {
206 |             ipv4_forward;
207 |             drop;
208 |             NoAction;
209 |         }
210 |         size = 1024;
211 |         default_action = drop();
212 |     }
213 |     
214 |     apply {
215 |         if (hdr.ipv4.isValid() ) {
216 |             feature1_exact.apply();
217 |            if(hdr.ipv4.protocol ==6) {
218 |             feature2_exact.apply();
219 |              feature3_exact.apply();
220 | }
221 |      else {meta.action_select2 =1;
222 |                 meta.action_select3 = 1;}
223 | }
224 |             ipv4_exact.apply();
225 |      
226 |     }
227 | }
228 | 
229 | /*************************************************************************
230 | ****************  E G R E S S   P R O C E S S I N G   *******************
231 | *************************************************************************/
232 | 
233 | control MyEgress(inout headers hdr,
234 |                  inout metadata meta,
235 |                  inout standard_metadata_t standard_metadata) {
236 |     apply {  }
237 | }
238 | 
239 | /*************************************************************************
240 | *************   C H E C K S U M    C O M P U T A T I O N   **************
241 | *************************************************************************/
242 | 
243 | control MyComputeChecksum(inout headers  hdr, inout metadata meta) {
244 |      apply {
245 | 	update_checksum(
246 | 	    hdr.ipv4.isValid(),
247 |             { hdr.ipv4.version,
248 | 	      hdr.ipv4.ihl,
249 |               hdr.ipv4.diffserv,
250 |               hdr.ipv4.totalLen,
251 |               hdr.ipv4.identification,
252 |               hdr.ipv4.flags,
253 |               hdr.ipv4.fragOffset,
254 |               hdr.ipv4.ttl,
255 |               hdr.ipv4.protocol,
256 |               hdr.ipv4.srcAddr,
257 |               hdr.ipv4.dstAddr },
258 |             hdr.ipv4.hdrChecksum,
259 |             HashAlgorithm.csum16);
260 |     }
261 | }
262 | 
263 | /*************************************************************************
264 | ***********************  D E P A R S E R  *******************************
265 | *************************************************************************/
266 | 
267 | control MyDeparser(packet_out packet, in headers hdr) {
268 |     apply {
269 |         packet.emit(hdr.ethernet);
270 |         packet.emit(hdr.ipv4);
271 |         packet.emit(hdr.tcp);
272 |     }
273 | }
274 | 
275 | /*************************************************************************
276 | ***********************  S W I T C H  *******************************
277 | *************************************************************************/
278 | 
279 | V1Switch(
280 | MyParser(),
281 | MyVerifyChecksum(),
282 | MyIngress(),
283 | MyEgress(),
284 | MyComputeChecksum(),
285 | MyDeparser()
286 | ) main;
287 | 


--------------------------------------------------------------------------------
/iisy_hw/iisy_naive_bayes.p4:
--------------------------------------------------------------------------------
  1 | //
  2 | // Copyright (c) 2019 Noa Zilberman
  3 | // All rights reserved.
  4 | //
  5 | // @NETFPGA_LICENSE_HEADER_START@
  6 | //
  7 | // Licensed to NetFPGA C.I.C. (NetFPGA) under one or more contributor
  8 | // license agreements.  See the NOTICE file distributed with this work for
  9 | // additional information regarding copyright ownership.  NetFPGA licenses this
 10 | // file to you under the NetFPGA Hardware-Software License, Version 1.0 (the
 11 | // "License"); you may not use this file except in compliance with the
 12 | // License.  You may obtain a copy of the License at:
 13 | //
 14 | //   http://www.netfpga-cic.org
 15 | //
 16 | // Unless required by applicable law or agreed to in writing, Work distributed
 17 | // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
 18 | // CONDITIONS OF ANY KIND, either express or implied.  See the License for the
 19 | // specific language governing permissions and limitations under the License.
 20 | //
 21 | // @NETFPGA_LICENSE_HEADER_END@
 22 | //
 23 | 
 24 | 
 25 | #include <core.p4>
 26 | #include <sume_switch.p4>
 27 | 
 28 | typedef bit<48> EthAddr_t; 
 29 | typedef bit<32> IPv4Addr_t;
 30 | typedef bit<16> TCPAddr_t;
 31 | 
 32 | #define IPV4_TYPE 0x0800
 33 | #define IPV6_TYPE 0x86DD
 34 | #define TCP_TYPE 6
 35 | 
 36 | 
 37 | //Standard Ethernet Header
 38 | header Ethernet_h {
 39 |     EthAddr_t dstAddr;
 40 |     EthAddr_t srcAddr;
 41 |     bit<16> etherType;
 42 | }
 43 | 
 44 | //IPv4 header without options
 45 | header IPv4_h {
 46 |     bit<4> version;
 47 |     bit<4> ihl;
 48 |     bit<8> tos;
 49 |     bit<16> totalLen;
 50 |     bit<16> identification;
 51 |     bit<3> flags;
 52 |     bit<13> fragOffset;
 53 |     bit<8> ttl;
 54 |     bit<8> protocol;
 55 |     bit<16> hdrChecksum;
 56 |     IPv4Addr_t srcAddr;
 57 |     IPv4Addr_t dstAddr;
 58 | }
 59 | 
 60 | //IPv6 header
 61 | header IPv6_h{
 62 |   bit<4> version;
 63 |   bit<8> trafficClass;
 64 |   bit<20> flowLabel;
 65 |   bit<16> payloadLen;
 66 |   bit<8> nxt;
 67 |   bit<8> hopLimit;
 68 |   bit<128> srcAddr;
 69 |   bit<128> dstAddr;
 70 | }
 71 | 
 72 | //TCP header without options
 73 | header TCP_h {
 74 |     bit<16> srcPort;
 75 |     bit<16> dstPort;
 76 |     bit<32> seqNo;
 77 |     bit<32> ackNo;
 78 |     bit<4> dataOffset;
 79 |     bit<4> res;
 80 |     bit<8> flags;
 81 |     bit<16> window;
 82 |     bit<16> checksum;
 83 |     bit<16> urgentPtr;
 84 | }
 85 | 
 86 | 
 87 | // List of all recognized headers
 88 | struct Parsed_packet {
 89 |     Ethernet_h ethernet;
 90 |     IPv4_h ip;
 91 |     IPv6_h ip6;
 92 |     TCP_h tcp;
 93 | }
 94 | 
 95 | 
 96 | // user defined metadata
 97 | // used for coding the decision 
 98 | struct user_metadata_t {
 99 |     bit<7> prob0;
100 |     bit<7> prob1;
101 |     bit<7> prob2;
102 |     bit<7> prob3;
103 |     bit<7> prob4;
104 | }
105 | 
106 | // digest_data, MUST be 256 bits
107 | struct digest_data_t {
108 |     bit<256> unused;
109 | }
110 | 
111 | // Parser Implementation
112 | 
113 | 
114 | @Xilinx_MaxPacketRegion(8192)
115 | parser TopParser(packet_in b,
116 |                  out Parsed_packet p,
117 |                  out user_metadata_t user_metadata,
118 |                  out digest_data_t digest_data,
119 |                  inout sume_metadata_t sume_metadata) {
120 |     state start {
121 |         b.extract(p.ethernet);
122 |         transition select(p.ethernet.etherType) {
123 |             IPV4_TYPE: parse_ipv4;
124 |             IPV6_TYPE: parse_ipv6;
125 |             default: accept;
126 |         }
127 |     }
128 | 
129 |     state parse_ipv4 {
130 |         b.extract(p.ip);
131 |         transition select(p.ip.protocol) {
132 |             TCP_TYPE: parse_tcp;
133 |             default: accept;
134 |         }
135 |     }
136 | 
137 |     state parse_ipv6 {
138 |         b.extract(p.ip6);
139 |         transition select(p.ip6.nxt) {
140 |             TCP_TYPE: parse_tcp;
141 |             default: accept;
142 |         }
143 |     }
144 | 
145 |     state parse_tcp {
146 |         b.extract(p.tcp);
147 |         transition accept;
148 |     }
149 | }
150 | 
151 | 
152 | // match-action pipeline
153 | control TopPipe(inout Parsed_packet p,
154 |                 inout user_metadata_t user_metadata, 
155 |                 inout digest_data_t digest_data,
156 |                 inout sume_metadata_t sume_metadata) {
157 | 
158 | 
159 |  
160 |     action set_prob0(bit<7> code){
161 |         user_metadata.prob0 = code;
162 |     }
163 |     
164 |     action set_prob1(bit<7> code){
165 |         user_metadata.prob1 = code;
166 |     }
167 |     action set_prob2(bit<7> code){
168 |         user_metadata.prob2 = code;
169 |     }
170 |     action set_prob3(bit<7> code){
171 |         user_metadata.prob3 = code;
172 |     }
173 |     action set_prob4(bit<7> code){
174 |         user_metadata.prob4 = code;
175 |     }
176 | 
177 | 
178 | 
179 | // Calculate probability 0
180 |     table tprob0{
181 |         key = {  sume_metadata.pkt_len++p.ip.protocol++p.ip.flags++p.tcp.srcPort++p.tcp.dstPort:ternary @name("features"); }
182 | 
183 |          actions = {
184 |             set_prob0;
185 |             NoAction;
186 |         }
187 |         size = 63;
188 |         default_action = NoAction;
189 |     }
190 | 
191 | // Calculate probability 1
192 |     table tprob1{
193 |         key = {  sume_metadata.pkt_len++p.ip.protocol++p.ip.flags++p.tcp.srcPort++p.tcp.dstPort:ternary @name("features"); }
194 | 
195 |          actions = {
196 |             set_prob1;
197 |             NoAction;
198 |         }
199 |         size = 63;
200 |         default_action = NoAction;
201 |     }
202 | 
203 | // Calculate probability 2
204 |   table tprob2 {
205 |          key = {  sume_metadata.pkt_len++p.ip.protocol++p.ip.flags++p.tcp.srcPort++p.tcp.dstPort:ternary @name("features"); }
206 |         
207 |          actions = {
208 |             set_prob2;
209 |             NoAction;
210 |         }
211 |         size = 63;
212 |         default_action = NoAction;
213 |     }
214 | 
215 | // Calculate probability 3
216 |   table tprob3 {
217 |          key = {  sume_metadata.pkt_len++p.ip.protocol++p.ip.flags++p.tcp.srcPort++p.tcp.dstPort:ternary @name("features"); }
218 | 
219 |          actions = {
220 |             set_prob3;
221 |             NoAction;
222 |         }
223 |         size = 63;
224 |         default_action = NoAction;
225 |     }
226 | 
227 | // Calculate probability 4
228 |   table tprob4{
229 |          key = {  sume_metadata.pkt_len++p.ip.protocol++p.ip.flags++p.tcp.srcPort++p.tcp.dstPort:ternary @name("features"); }
230 | 
231 |          actions = {
232 |             set_prob4;
233 |             NoAction;
234 |         }
235 |         size = 63;
236 |         default_action = NoAction;
237 |     }
238 | 
239 | 
240 |     apply {
241 | 
242 |         user_metadata.prob0=0;
243 |         user_metadata.prob1=0;
244 |         user_metadata.prob2=0;
245 |         user_metadata.prob3=0;
246 |         user_metadata.prob4=0;
247 |        
248 |         tprob0.apply();
249 |         tprob1.apply(); 
250 |         tprob2.apply();
251 |         tprob3.apply();
252 |         tprob4.apply();
253 | 
254 | //Select the destination port based on the classification - highest probability
255 |         if ((user_metadata.prob0>user_metadata.prob1) && (user_metadata.prob0>user_metadata.prob2) && (user_metadata.prob0>user_metadata.prob3) && (user_metadata.prob0>user_metadata.prob4)) {
256 |             sume_metadata.dst_port = 8w0b00000001;
257 |         }
258 |         else{
259 |           if ((user_metadata.prob1>=user_metadata.prob0) && (user_metadata.prob1>user_metadata.prob2) && (user_metadata.prob1>user_metadata.prob3) && (user_metadata.prob1>user_metadata.prob4)) {
260 |               sume_metadata.dst_port = 8w0b00000100;
261 |           }
262 |           else{
263 |             if ((user_metadata.prob2>=user_metadata.prob0) && (user_metadata.prob2>=user_metadata.prob1) && (user_metadata.prob2>user_metadata.prob3) && (user_metadata.prob2>user_metadata.prob4)) {
264 |                 sume_metadata.dst_port = 8w0b00010000;
265 |             }
266 |             else{
267 |               if ((user_metadata.prob3>=user_metadata.prob0) && (user_metadata.prob3>=user_metadata.prob1) && (user_metadata.prob3>=user_metadata.prob2) && (user_metadata.prob3>user_metadata.prob4)) {
268 |                   sume_metadata.dst_port = 8w0b01000000;
269 |               }
270 |               else
271 |               {
272 |                     sume_metadata.dst_port = 8w0b00000010; //send to host
273 |               }  
274 |             } 
275 |             } 
276 |          }
277 |       }
278 | }
279 | 
280 | // Deparser Implementation
281 | @Xilinx_MaxPacketRegion(1024)
282 | control TopDeparser(packet_out b,
283 |                     in Parsed_packet p,
284 |                     in user_metadata_t user_metadata,
285 |                     inout digest_data_t digest_data,
286 |                     inout sume_metadata_t sume_metadata) { 
287 |     apply {
288 |         b.emit(p.ethernet); 
289 |         b.emit(p.ip);
290 |         b.emit(p.ip6);
291 | 	b.emit(p.tcp);
292 |     }
293 | }
294 | 
295 | 
296 | // Instantiate the switch
297 | SimpleSumeSwitch(TopParser(), TopPipe(), TopDeparser()) main;
298 | 
299 | 


--------------------------------------------------------------------------------
/iisy_hw/iisy_kmeans.p4:
--------------------------------------------------------------------------------
  1 | //
  2 | // Copyright (c) 2019 Noa Zilberman
  3 | // All rights reserved.
  4 | //
  5 | // @NETFPGA_LICENSE_HEADER_START@
  6 | //
  7 | // Licensed to NetFPGA C.I.C. (NetFPGA) under one or more contributor
  8 | // license agreements.  See the NOTICE file distributed with this work for
  9 | // additional information regarding copyright ownership.  NetFPGA licenses this
 10 | // file to you under the NetFPGA Hardware-Software License, Version 1.0 (the
 11 | // "License"); you may not use this file except in compliance with the
 12 | // License.  You may obtain a copy of the License at:
 13 | //
 14 | //   http://www.netfpga-cic.org
 15 | //
 16 | // Unless required by applicable law or agreed to in writing, Work distributed
 17 | // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
 18 | // CONDITIONS OF ANY KIND, either express or implied.  See the License for the
 19 | // specific language governing permissions and limitations under the License.
 20 | //
 21 | // @NETFPGA_LICENSE_HEADER_END@
 22 | //
 23 | 
 24 | 
 25 | #include <core.p4>
 26 | #include <sume_switch.p4>
 27 | 
 28 | 
 29 | typedef bit<48> EthAddr_t; 
 30 | typedef bit<32> IPv4Addr_t;
 31 | typedef bit<16> TCPAddr_t;
 32 | 
 33 | #define IPV4_TYPE 0x0800
 34 | #define IPV6_TYPE 0x86DD
 35 | #define TCP_TYPE 6
 36 | 
 37 | 
 38 | //Standard Ethernet Header
 39 | header Ethernet_h {
 40 |     EthAddr_t dstAddr;
 41 |     EthAddr_t srcAddr;
 42 |     bit<16> etherType;
 43 | }
 44 | 
 45 | //IPv4 header without options
 46 | header IPv4_h {
 47 |     bit<4> version;
 48 |     bit<4> ihl;
 49 |     bit<8> tos;
 50 |     bit<16> totalLen;
 51 |     bit<16> identification;
 52 |     bit<3> flags;
 53 |     bit<13> fragOffset;
 54 |     bit<8> ttl;
 55 |     bit<8> protocol;
 56 |     bit<16> hdrChecksum;
 57 |     IPv4Addr_t srcAddr;
 58 |     IPv4Addr_t dstAddr;
 59 | }
 60 | 
 61 | //IPv6 header
 62 | header IPv6_h{
 63 |   bit<4> version;
 64 |   bit<8> trafficClass;
 65 |   bit<20> flowLabel;
 66 |   bit<16> payloadLen;
 67 |   bit<8> nxt;
 68 |   bit<8> hopLimit;
 69 |   bit<128> srcAddr;
 70 |   bit<128> dstAddr;
 71 | }
 72 | 
 73 | //TCP header without options
 74 | header TCP_h {
 75 |     bit<16> srcPort;
 76 |     bit<16> dstPort;
 77 |     bit<32> seqNo;
 78 |     bit<32> ackNo;
 79 |     bit<4> dataOffset;
 80 |     bit<4> res;
 81 |     bit<8> flags;
 82 |     bit<16> window;
 83 |     bit<16> checksum;
 84 |     bit<16> urgentPtr;
 85 | }
 86 | 
 87 | 
 88 | // List of all recognized headers
 89 | struct Parsed_packet {
 90 |     Ethernet_h ethernet;
 91 |     IPv4_h ip;
 92 |     IPv6_h ip6;
 93 |     TCP_h tcp;
 94 | }
 95 | 
 96 | 
 97 | // user defined metadata
 98 | // used for coding the decision 
 99 | struct user_metadata_t {
100 |     bit<7> dist0;
101 |     bit<7> dist1;
102 |     bit<7> dist2;
103 |     bit<7> dist3;
104 |     bit<7> dist4;
105 | }
106 | 
107 | // digest_data, MUST be 256 bits
108 | struct digest_data_t {
109 |     bit<256> unused;
110 | }
111 | 
112 | // Parser Implementation
113 | 
114 | 
115 | @Xilinx_MaxPacketRegion(8192)
116 | parser TopParser(packet_in b,
117 |                  out Parsed_packet p,
118 |                  out user_metadata_t user_metadata,
119 |                  out digest_data_t digest_data,
120 |                  inout sume_metadata_t sume_metadata) {
121 |     state start {
122 |         b.extract(p.ethernet);
123 |         transition select(p.ethernet.etherType) {
124 |             IPV4_TYPE: parse_ipv4;
125 |             IPV6_TYPE: parse_ipv6;
126 |             default: accept;
127 |         }
128 |     }
129 | 
130 |     state parse_ipv4 {
131 |         b.extract(p.ip);
132 |         transition select(p.ip.protocol) {
133 |             TCP_TYPE: parse_tcp;
134 |             default: accept;
135 |         }
136 |     }
137 | 
138 |     state parse_ipv6 {
139 |         b.extract(p.ip6);
140 |         transition select(p.ip6.nxt) {
141 |             TCP_TYPE: parse_tcp;
142 |             default: accept;
143 |         }
144 |     }
145 | 
146 |     state parse_tcp {
147 |         b.extract(p.tcp);
148 |         transition accept;
149 |     }
150 | }
151 | 
152 | 
153 | // match-action pipeline
154 | control TopPipe(inout Parsed_packet p,
155 |                 inout user_metadata_t user_metadata, 
156 |                 inout digest_data_t digest_data,
157 |                 inout sume_metadata_t sume_metadata) {
158 | 
159 | 
160 |  
161 |     action set_dist0(bit<7> code){
162 |         user_metadata.dist0 = code;
163 |     }
164 |     
165 |     action set_dist1(bit<7> code){
166 |         user_metadata.dist1 = code;
167 |     }
168 |     action set_dist2(bit<7> code){
169 |         user_metadata.dist2 = code;
170 |     }
171 |     action set_dist3(bit<7> code){
172 |         user_metadata.dist3 = code;
173 |     }
174 |     action set_dist4(bit<7> code){
175 |         user_metadata.dist4 = code;
176 |     }
177 | 
178 | 
179 | 
180 | // Calculate distance vector 0
181 |     table tdist0{
182 |         key = {  sume_metadata.pkt_len++p.ip.protocol++p.ip.flags++p.tcp.srcPort++p.tcp.dstPort:ternary @name("features"); }
183 | 
184 |          actions = {
185 |             set_dist0;
186 |             NoAction;
187 |         }
188 |         size = 64;
189 |         default_action = NoAction;
190 |     }
191 | 
192 | // Calculate distance vector 1
193 |     table tdist1{
194 |         key = {  sume_metadata.pkt_len++p.ip.protocol++p.ip.flags++p.tcp.srcPort++p.tcp.dstPort:ternary @name("features"); }
195 | 
196 |          actions = {
197 |             set_dist1;
198 |             NoAction;
199 |         }
200 |         size = 64;
201 |         default_action = NoAction;
202 |     }
203 | 
204 | // Calculate distance vector 2
205 |   table tdist2 {
206 |          key = {  sume_metadata.pkt_len++p.ip.protocol++p.ip.flags++p.tcp.srcPort++p.tcp.dstPort:ternary @name("features"); }
207 |         
208 |          actions = {
209 |             set_dist2;
210 |             NoAction;
211 |         }
212 |         size = 64;
213 |         default_action = NoAction;
214 |     }
215 | 
216 | // Calculate distance vector 3
217 |   table tdist3 {
218 | 
219 |          key = {  sume_metadata.pkt_len++p.ip.protocol++p.ip.flags++p.tcp.srcPort++p.tcp.dstPort:ternary @name("features"); }
220 | 
221 |          actions = {
222 |             set_dist3;
223 |             NoAction;
224 |         }
225 |         size =64;
226 |         default_action = NoAction;
227 |     }
228 | 
229 | // Calculate distance vector 4
230 |   table tdist4{
231 |          key = {  sume_metadata.pkt_len++p.ip.protocol++p.ip.flags++p.tcp.srcPort++p.tcp.dstPort:ternary @name("features"); }
232 | 
233 |          actions = {
234 |             set_dist4;
235 |             NoAction;
236 |         }
237 |         size = 64;
238 |         default_action = NoAction;
239 |     }
240 | 
241 | 
242 |     apply {
243 | 
244 |         user_metadata.dist0=0;
245 |         user_metadata.dist1=0;
246 |         user_metadata.dist2=0;
247 |         user_metadata.dist3=0;
248 |         user_metadata.dist4=0;
249 |        
250 |         tdist0.apply();
251 |         tdist1.apply(); 
252 |         tdist2.apply();
253 |         tdist3.apply();
254 |         tdist4.apply();
255 | 
256 | //Select the destination port based on the classification - shortest distance
257 | 
258 |         if ((user_metadata.dist0<user_metadata.dist1) && (user_metadata.dist0<user_metadata.dist2) && (user_metadata.dist0<user_metadata.dist3) && (user_metadata.dist0<user_metadata.dist4)) {
259 |             sume_metadata.dst_port = 8w0b00000001;
260 |         }
261 |         else{
262 |           if ((user_metadata.dist1<=user_metadata.dist0) && (user_metadata.dist1<user_metadata.dist2) && (user_metadata.dist1<user_metadata.dist3) && (user_metadata.dist1<user_metadata.dist4)) {
263 |               sume_metadata.dst_port = 8w0b00000100;
264 |           }
265 |           else{
266 |             if ((user_metadata.dist2<=user_metadata.dist0) && (user_metadata.dist2<=user_metadata.dist1) && (user_metadata.dist2<user_metadata.dist3) && (user_metadata.dist2<user_metadata.dist4)) {
267 |                 sume_metadata.dst_port = 8w0b00010000;
268 |             }
269 |             else{
270 |               if ((user_metadata.dist3<=user_metadata.dist0) && (user_metadata.dist3<=user_metadata.dist1) && (user_metadata.dist3<=user_metadata.dist2) && (user_metadata.dist3<user_metadata.dist4)) {
271 |                   sume_metadata.dst_port = 8w0b01000000;
272 |               }
273 |               else
274 |               {
275 |                     sume_metadata.dst_port = 8w0b00000010; //send to host
276 |               }  
277 |             } 
278 |             } 
279 |          }
280 |       }
281 | }
282 | 
283 | // Deparser Implementation
284 | @Xilinx_MaxPacketRegion(1024)
285 | control TopDeparser(packet_out b,
286 |                     in Parsed_packet p,
287 |                     in user_metadata_t user_metadata,
288 |                     inout digest_data_t digest_data,
289 |                     inout sume_metadata_t sume_metadata) { 
290 |     apply {
291 |         b.emit(p.ethernet); 
292 |         b.emit(p.ip);
293 |         b.emit(p.ip6);
294 | 	b.emit(p.tcp);
295 |     }
296 | }
297 | 
298 | 
299 | // Instantiate the switch
300 | SimpleSumeSwitch(TopParser(), TopPipe(), TopDeparser()) main;
301 | 
302 | 


--------------------------------------------------------------------------------
/iisy_sw/simple_example/kmeans/mycontroller.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python2
  2 | #################################################################################
  3 | #
  4 | # Copyright (c) 2019 Zhaoqi Xiong
  5 | # All rights reserved.
  6 | #
  7 | #
  8 | # @NETFPGA_LICENSE_HEADER_START@
  9 | #
 10 | # Licensed to NetFPGA C.I.C. (NetFPGA) under one or more contributor
 11 | # license agreements.  See the NOTICE file distributed with this work for
 12 | # additional information regarding copyright ownership.  NetFPGA licenses this
 13 | # file to you under the NetFPGA Hardware-Software License, Version 1.0 (the
 14 | # "License"); you may not use this file except in compliance with the
 15 | # License.  You may obtain a copy of the License at:
 16 | #
 17 | #   http://www.netfpga-cic.org
 18 | #
 19 | # Unless required by applicable law or agreed to in writing, Work distributed
 20 | # under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
 21 | # CONDITIONS OF ANY KIND, either express or implied.  See the License for the
 22 | # specific language governing permissions and limitations under the License.
 23 | #
 24 | # @NETFPGA_LICENSE_HEADER_END@
 25 | #
 26 | #################################################################################  
 27 | 
 28 | import argparse
 29 | import os
 30 | import sys
 31 | import grpc
 32 | 
 33 | 
 34 | # Import P4Runtime lib from parent utils dir
 35 | # Probably there's a better way of doing this.
 36 | sys.path.append(
 37 |                 os.path.join(os.path.dirname(os.path.abspath(__file__)),
 38 |                              '../../utils/'))
 39 | import p4runtime_lib.bmv2
 40 | from p4runtime_lib.switch import ShutdownAllSwitchConnections
 41 | import p4runtime_lib.helper
 42 | 
 43 | 
 44 | 
 45 | 
 46 | def get_actionpara(action):
 47 |     para = {}
 48 |     if action == 0:
 49 |         para = {}
 50 |     elif action == 2:
 51 |         para = {"dstAddr": "00:00:00:02:02:00", "port": 2}
 52 |     elif action == 3:
 53 |         para = {"dstAddr": "00:00:00:03:03:00", "port": 3}
 54 |     elif action == 4:
 55 |         para = {"dstAddr": "00:00:00:04:04:00", "port": 4}
 56 |     
 57 |     return para
 58 | 
 59 | 
 60 | def writeclass1x(p4info_helper, switch, a, a_square):
 61 |     table_entry = p4info_helper.buildTableEntry(
 62 |                                                 table_name="MyIngress.class1_exactx",
 63 |                                                 match_fields={ "meta.distancex": a
 64 |                                                 
 65 |                                                 },
 66 |                                                 action_name= "MyIngress.set_distancex",
 67 |                                                 action_params= {"square": a_square,
 68 |                                                })
 69 |     switch.WriteTableEntry(table_entry)
 70 |     print("Installed action rule on %s" % switch.name)
 71 | 
 72 | 
 73 | def writeclass1y(p4info_helper, switch, a, a_square):
 74 |     table_entry = p4info_helper.buildTableEntry(
 75 |                                                 table_name="MyIngress.class1_exacty",
 76 |                                                 match_fields={"meta.distancey": a
 77 |                                                 
 78 |                                                 },
 79 |                                                 action_name="MyIngress.set_distancey",
 80 |                                                 action_params={"square": a_square,}
 81 |                                                 )
 82 |     switch.WriteTableEntry(table_entry)
 83 |     print("Installed action rule on %s" % switch.name)
 84 | 
 85 | 
 86 | def writeclass2x(p4info_helper, switch,  a, a_square):
 87 |     table_entry = p4info_helper.buildTableEntry(
 88 |                                                 table_name="MyIngress.class2_exactx",
 89 |                                                 match_fields={"meta.distancex": a
 90 |                                                 
 91 |                                                 },
 92 |                                                 action_name= "MyIngress.set_distancex",
 93 |                                                 action_params = {"square": a_square,}
 94 |                                                 )
 95 |     switch.WriteTableEntry(table_entry)
 96 |     print("Installed action rule on %s" % switch.name)
 97 | 
 98 | 
 99 | def writeclass2y(p4info_helper, switch, a, a_square):
100 |     table_entry = p4info_helper.buildTableEntry(
101 |                                                 table_name="MyIngress.class2_exacty",
102 |                                                 match_fields={"meta.distancey": a
103 |                                                 
104 |                                                 },
105 |                                                 action_name="MyIngress.set_distancey",
106 |                                                 action_params = {"square": a_square,}
107 |                                                 )
108 |     switch.WriteTableEntry(table_entry)
109 |     print("Installed action rule on %s" % switch.name)
110 |                   
111 | 
112 | 
113 | def writeaction(p4info_helper, switch,value,port):
114 |     para = get_actionpara(port)
115 |     table_entry = p4info_helper.buildTableEntry(
116 |                                               table_name="MyIngress.ipv4_exact",
117 |                                               match_fields={
118 |                                               "meta.classification": value },
119 |                                               action_name= "MyIngress.ipv4_forward",
120 |                                               action_params = para
121 |                                               )
122 | 
123 |     switch.WriteTableEntry(table_entry)
124 |     print("Installed select rule on %s" % switch.name)
125 |                   
126 | 
127 | 
128 |                   
129 |                   
130 | 
131 | def printGrpcError(e):
132 |     print("gRPC Error:", e.details(), )
133 |     status_code = e.code()
134 |     print("(%s)" % status_code.name, )
135 |     traceback = sys.exc_info()[2]
136 |     print("[%s:%d]" % (traceback.tb_frame.f_code.co_filename, traceback.tb_lineno))
137 | 
138 | 
139 | 
140 | 
141 | def main(p4info_file_path, bmv2_file_path):
142 |     p4info_helper = p4runtime_lib.helper.P4InfoHelper(p4info_file_path)
143 |                   
144 |     try:
145 |                   
146 |         s1 = p4runtime_lib.bmv2.Bmv2SwitchConnection(
147 |                                                    name='s1',
148 |                                                    address='127.0.0.1:50051',
149 |                                                    device_id=0,
150 |                                                    proto_dump_file='logs/s1-p4runtime-requests.txt')
151 | 
152 |         s1.MasterArbitrationUpdate()
153 |                   
154 |         s1.SetForwardingPipelineConfig(p4info=p4info_helper.p4info,
155 |                                      bmv2_json_file_path=bmv2_file_path)
156 |         print("Installed P4 Program using SetForwardingPipelineConfig on s1")
157 | 
158 |         a = [256,65535]
159 |         for i in range(0,65535):
160 |             writeclass1x(p4info_helper, s1, i, i**2)
161 |             writeclass1y(p4info_helper, s1, i, i**2)
162 |             writeclass2x(p4info_helper, s1, i, i**2)
163 |             writeclass2y(p4info_helper, s1, i, i**2)
164 |         # writeclass1x(p4info_helper,s1, a, 65535)
165 |         # writeclass1y(p4info_helper,s1, a, 65535)
166 |         # writeclass2x(p4info_helper,s1, a, 65535)
167 |         # writeclass2y(p4info_helper,s1,a, 65535)
168 |         # writeclass2y(p4info_helper,s1, a, 65535)
169 |         writeaction(p4info_helper,s1,1,2)
170 |         writeaction(p4info_helper,s1,2,3)
171 |        #writedropaction(p4info_helper,s1,0)
172 | 
173 |                   
174 |                   
175 |     except KeyboardInterrupt:
176 |         print("Shutting down.")
177 | 
178 |     except grpc.RpcError as e:
179 |         printGrpcError(e)
180 |                   
181 |     ShutdownAllSwitchConnections()
182 |                   
183 |                   
184 | if __name__ == '__main__':
185 |     parser = argparse.ArgumentParser(description='P4Runtime Controller')
186 |     parser.add_argument('--p4info', help='p4info proto in text format from p4c',
187 |                         type=str, action="store", required=False,
188 |                         default='./build/kmeans.p4info')
189 | 
190 |     parser.add_argument('--bmv2-json', help='BMv2 JSON file from p4c',
191 |                         type=str, action="store", required=False,
192 |                         default='./build/kmeans.json')
193 | 
194 |     args = parser.parse_args()
195 | 
196 |     if not os.path.exists(args.p4info):
197 |         parser.print_help()
198 |         print("\np4info file not found: %s\nHave you run 'make'?" % args.p4info)
199 |         parser.exit(1)
200 | 
201 |     if not os.path.exists(args.bmv2_json):
202 |         parser.print_help()
203 |         print("\nBMv2 JSON file not found: %s\nHave you run 'make'?" % args.bmv2_json)
204 |         parser.exit(1)
205 | 
206 |     main(args.p4info, args.bmv2_json)


--------------------------------------------------------------------------------
/iisy_sw/framework/basic.p4:
--------------------------------------------------------------------------------
  1 | /* -*- P4_16 -*- */
  2 | /********************************************************************************
  3 | *
  4 | * Copyright (c) 2019 Zhaoqi Xiong
  5 | * All rights reserved.
  6 | *
  7 | *
  8 | * @NETFPGA_LICENSE_HEADER_START@
  9 | *
 10 | * Licensed to NetFPGA C.I.C. (NetFPGA) under one or more contributor
 11 | * license agreements.  See the NOTICE file distributed with this work for
 12 | * additional information regarding copyright ownership.  NetFPGA licenses this
 13 | * file to you under the NetFPGA Hardware-Software License, Version 1.0 (the
 14 | * "License"); you may not use this file except in compliance with the
 15 | * License.  You may obtain a copy of the License at:
 16 | *
 17 | *   http://www.netfpga-cic.org
 18 | *
 19 | * Unless required by applicable law or agreed to in writing, Work distributed
 20 | * under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
 21 | * CONDITIONS OF ANY KIND, either express or implied.  See the License for the
 22 | * specific language governing permissions and limitations under the License.
 23 | *
 24 | * @NETFPGA_LICENSE_HEADER_END@
 25 | *
 26 | ********************************************************************************/
 27 |   
 28 | #include <core.p4>
 29 | #include <v1model.p4>
 30 | 
 31 | const bit<16> TYPE_IPV4 = 0x800;
 32 | 
 33 | /*************************************************************************
 34 | *********************** H E A D E R S  ***********************************
 35 | *************************************************************************/
 36 | 
 37 | typedef bit<9>  egressSpec_t;
 38 | typedef bit<48> macAddr_t;
 39 | typedef bit<32> ip4Addr_t;
 40 | 
 41 | // ethernet header
 42 | header ethernet_t {
 43 |     macAddr_t dstAddr;
 44 |     macAddr_t srcAddr;
 45 |     bit<16>   etherType;
 46 | }
 47 | 
 48 | // ipv4 header
 49 | header ipv4_t {
 50 |     bit<4>    version;
 51 |     bit<4>    ihl;
 52 |     bit<8>    diffserv;
 53 |     bit<16>   totalLen;
 54 |     bit<16>   identification;
 55 |     bit<3>    flags;
 56 |     bit<13>   fragOffset;
 57 |     bit<8>    ttl;
 58 |     bit<8>    protocol;
 59 |     bit<16>   hdrChecksum;
 60 |     ip4Addr_t srcAddr;
 61 |     ip4Addr_t dstAddr;
 62 | }
 63 | 
 64 | // tcp header
 65 | header tcp_t {
 66 |     bit<16> srcPort;
 67 |     bit<16> dstPort;
 68 |     bit<32> seqNo;
 69 |     bit<32> ackNo;
 70 |     bit<4>  dataOffset;
 71 |     bit<3>  res;
 72 |     bit<3>  ecn;
 73 |     bit<6>  ctrl;
 74 |     bit<16> window;
 75 |     bit<16> checksum;
 76 |     bit<16> urgentPtr;
 77 | }
 78 | 
 79 | // metadata used for recording the ranges
 80 | struct metadata {
 81 |     bit<14> action_select1;
 82 |         bit<14> action_select2;
 83 |             bit<14> action_select3;
 84 | }
 85 | 
 86 | struct headers {
 87 |     ethernet_t   ethernet;
 88 |     ipv4_t       ipv4;
 89 |     tcp_t      tcp;
 90 | }
 91 | 
 92 | /*************************************************************************
 93 | *********************** P A R S E R  ***********************************
 94 | *************************************************************************/
 95 | 
 96 | parser MyParser(packet_in packet,
 97 |                 out headers hdr,
 98 |                 inout metadata meta,
 99 |                 inout standard_metadata_t standard_metadata) {
100 |     
101 |     // state machine for  parser
102 |     state start {
103 |         transition parse_ethernet;
104 |     }
105 | 
106 |     state parse_ethernet {
107 |         packet.extract(hdr.ethernet);
108 |         transition select(hdr.ethernet.etherType) {
109 |             TYPE_IPV4: parse_ipv4;
110 |             default: accept;
111 |     }
112 | }
113 |     
114 |     state parse_ipv4 {
115 |         packet.extract(hdr.ipv4);
116 |         transition select(hdr.ipv4.protocol) {
117 |             6: parse_tcp;
118 |             default: accept;
119 |                 }
120 |             }
121 | state parse_tcp {
122 |     packet.extract(hdr.tcp);
123 |     transition accept;
124 | }
125 | }
126 | 
127 | /*************************************************************************
128 | ************   C H E C K S U M    V E R I F I C A T I O N   *************
129 | *************************************************************************/
130 | 
131 | control MyVerifyChecksum(inout headers hdr, inout metadata meta) {
132 |     apply {  }
133 | }
134 | 
135 | 
136 | /*************************************************************************
137 | **************  I N G R E S S   P R O C E S S I N G   *******************
138 | *************************************************************************/
139 | 
140 | control MyIngress(inout headers hdr,
141 |                   inout metadata meta,
142 |                   inout standard_metadata_t standard_metadata) {
143 |     action drop() {
144 |         mark_to_drop();
145 |     }
146 |     
147 |     action ipv4_forward(macAddr_t dstAddr, egressSpec_t port) {
148 |         standard_metadata.egress_spec = port;
149 |         hdr.ethernet.srcAddr = hdr.ethernet.dstAddr;
150 |         hdr.ethernet.dstAddr = dstAddr;
151 |                   }
152 |                       
153 | action set_actionselect1(bit<14> featurevalue1){
154 |     meta.action_select1 = featurevalue1 ;
155 | }
156 | 
157 | action set_actionselect2(bit<14> featurevalue2){
158 |     meta.action_select2 = featurevalue2 ;
159 | }
160 | 
161 | action set_actionselect3(bit<14> featurevalue3){
162 |     meta.action_select3 = featurevalue3;
163 |         
164 | }
165 | 
166 | // feature table match protocol
167 | table feature1_exact{
168 | 
169 | key = {
170 |     hdr.ipv4.protocol : range ;
171 |         }
172 |         actions = {
173 |             NoAction;
174 |             set_actionselect1;
175 |                 }
176 |                     size = 1024;
177 | }
178 | 
179 | // feature table match srcPort
180 | table feature2_exact{
181 |     key = {
182 |         hdr.tcp.srcPort : range ;
183 |         }
184 |         actions = {
185 |             NoAction;
186 |             set_actionselect2;
187 |             }
188 |                 size = 1024;
189 | }
190 | 
191 | // feature table match dstPort
192 | table feature3_exact{
193 |     key = {
194 |         hdr.tcp.dstPort : range ;
195 |         }
196 |         actions = {
197 |             NoAction;
198 |             set_actionselect3;
199 |                 }
200 |                     size = 1024;
201 | }
202 |     
203 |     
204 | // decision table match metadata
205 |     table ipv4_exact {
206 |         key = {
207 |             meta.action_select1: range;
208 |             meta.action_select2: range;
209 |             meta.action_select3: range;
210 |                 }
211 |  actions = {
212 |     ipv4_forward;
213 |     drop;
214 |     NoAction;
215 |         }
216 |         size = 1024;
217 |         default_action = drop();
218 |     }
219 | 
220 | 
221 | apply {
222 |     if (hdr.ipv4.isValid() ) {
223 |         feature1_exact.apply();
224 |             if(hdr.ipv4.protocol ==6) {
225 |                 feature2_exact.apply();
226 |                     feature3_exact.apply();
227 | }
228 |     else {meta.action_select2 =1;
229 |         meta.action_select3 = 1;}
230 | }
231 |     ipv4_exact.apply();
232 | 
233 | }
234 | }
235 | 
236 | /*************************************************************************
237 | ****************  E G R E S S   P R O C E S S I N G   *******************
238 | *************************************************************************/
239 | 
240 | control MyEgress(inout headers hdr,
241 |                  inout metadata meta,
242 |                  inout standard_metadata_t standard_metadata) {
243 |     apply {  }
244 | }
245 | 
246 | /*************************************************************************
247 | *************   C H E C K S U M    C O M P U T A T I O N   **************
248 | *************************************************************************/
249 | 
250 | control MyComputeChecksum(inout headers  hdr, inout metadata meta) {
251 |     apply {
252 |     update_checksum(
253 |                     hdr.ipv4.isValid(),
254 |                     { hdr.ipv4.version,
255 |                     hdr.ipv4.ihl,
256 |                     hdr.ipv4.diffserv,
257 |                     hdr.ipv4.totalLen,
258 |                     hdr.ipv4.identification,
259 |                     hdr.ipv4.flags,
260 |                     hdr.ipv4.fragOffset,
261 |                     hdr.ipv4.ttl,
262 |                     hdr.ipv4.protocol,
263 |                     hdr.ipv4.srcAddr,
264 |                     hdr.ipv4.dstAddr },
265 |                     hdr.ipv4.hdrChecksum,
266 |                     HashAlgorithm.csum16);
267 | }
268 | }
269 | 
270 | /*************************************************************************
271 | ***********************  D E P A R S E R  *******************************
272 | *************************************************************************/
273 | 
274 | control MyDeparser(packet_out packet, in headers hdr) {
275 |     apply {
276 |         packet.emit(hdr.ethernet);
277 |         packet.emit(hdr.ipv4);
278 |         packet.emit(hdr.tcp);
279 | }
280 | }
281 | 
282 | /*************************************************************************
283 | ***********************  S W I T C H  *******************************
284 | *************************************************************************/
285 | 
286 | V1Switch(
287 |          MyParser(),
288 |          MyVerifyChecksum(),
289 |          MyIngress(),
290 |          MyEgress(),
291 |          MyComputeChecksum(),
292 |          MyDeparser()
293 |          ) main;
294 | 


--------------------------------------------------------------------------------
/iisy_sw/simple_example/naive_bayes/mycontroller.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python2
  2 | #################################################################################
  3 | #
  4 | # Copyright (c) 2019 Zhaoqi Xiong
  5 | # All rights reserved.
  6 | #
  7 | #
  8 | # @NETFPGA_LICENSE_HEADER_START@
  9 | #
 10 | # Licensed to NetFPGA C.I.C. (NetFPGA) under one or more contributor
 11 | # license agreements.  See the NOTICE file distributed with this work for
 12 | # additional information regarding copyright ownership.  NetFPGA licenses this
 13 | # file to you under the NetFPGA Hardware-Software License, Version 1.0 (the
 14 | # "License"); you may not use this file except in compliance with the
 15 | # License.  You may obtain a copy of the License at:
 16 | #
 17 | #   http://www.netfpga-cic.org
 18 | #
 19 | # Unless required by applicable law or agreed to in writing, Work distributed
 20 | # under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
 21 | # CONDITIONS OF ANY KIND, either express or implied.  See the License for the
 22 | # specific language governing permissions and limitations under the License.
 23 | #
 24 | # @NETFPGA_LICENSE_HEADER_END@
 25 | #
 26 | #################################################################################   
 27 | 
 28 | import argparse
 29 | import os
 30 | import sys
 31 | import grpc
 32 | import numpy as np
 33 | 
 34 | # Import P4Runtime lib from parent utils dir
 35 | # Probably there's a better way of doing this.
 36 | sys.path.append(
 37 |     os.path.join(os.path.dirname(os.path.abspath(__file__)),
 38 |                  '../../utils/'))
 39 | import p4runtime_lib.bmv2
 40 | from p4runtime_lib.switch import ShutdownAllSwitchConnections
 41 | import p4runtime_lib.helper
 42 | 
 43 | 
 44 | def get_actionpara(action):
 45 |     para = {}
 46 |     if action == 0:
 47 |         para = {}
 48 |     elif action == 2:
 49 |         para = {"dstAddr": "00:00:00:02:02:00", "port": 2}
 50 |     elif action == 3:
 51 |         para = {"dstAddr": "00:00:00:03:03:00", "port": 3}
 52 |     elif action == 4:
 53 |         para = {"dstAddr": "00:00:00:04:04:00", "port": 4}
 54 | 
 55 |     return para
 56 | 
 57 | 
 58 | def writeclass1x(p4info_helper, switch, a, a_square):
 59 |     table_entry = p4info_helper.buildTableEntry(
 60 |         table_name="MyIngress.class1_p1",
 61 |         match_fields={"hdr.tcp.srcPort": a
 62 | 
 63 |                       },
 64 |         action_name="MyIngress.set_p1",
 65 |         action_params={"square": a_square,
 66 |                        })
 67 |     switch.WriteTableEntry(table_entry)
 68 |     print("Installed action rule about class1 p1")
 69 | 
 70 | 
 71 | def writeclass1y(p4info_helper, switch, a, a_square):
 72 |     table_entry = p4info_helper.buildTableEntry(
 73 |         table_name="MyIngress.class1_p2",
 74 |         match_fields={"hdr.tcp.dstPort": a
 75 | 
 76 |                       },
 77 |         action_name="MyIngress.set_p2",
 78 |         action_params={"square": a_square, }
 79 |     )
 80 |     switch.WriteTableEntry(table_entry)
 81 |     print("Installed action rule about class1 p2")
 82 | 
 83 | 
 84 | def writeclass2x(p4info_helper, switch, a, a_square):
 85 |     table_entry = p4info_helper.buildTableEntry(
 86 |         table_name="MyIngress.class2_p1",
 87 |         match_fields={"hdr.tcp.srcPort": a
 88 | 
 89 |                       },
 90 |         action_name="MyIngress.set_p1",
 91 |         action_params={"square": a_square, }
 92 |     )
 93 |     switch.WriteTableEntry(table_entry)
 94 |     print("Installed action rule about class2 p1")
 95 | 
 96 | 
 97 | def writeclass2y(p4info_helper, switch, a, a_square):
 98 |     table_entry = p4info_helper.buildTableEntry(
 99 |         table_name="MyIngress.class2_p2",
100 |         match_fields={"hdr.tcp.dstPort": a
101 | 
102 |                       },
103 |         action_name="MyIngress.set_p2",
104 |         action_params={"square": a_square, }
105 |     )
106 |     switch.WriteTableEntry(table_entry)
107 |     print("Installed action rule about class2 p2")
108 | 
109 | 
110 | def writepro1(p4info_helper, switch, a, b, probility):
111 |     table_entry = p4info_helper.buildTableEntry(
112 |         table_name="MyIngress.class1_pro",
113 |         match_fields={"meta.x": a,
114 |                       "meta.y": b
115 | 
116 |                       },
117 |         action_name="MyIngress.set_select1",
118 |         action_params={"probility": probility, }
119 |     )
120 |     switch.WriteTableEntry(table_entry)
121 |     print("Installed action rule about class1 pro")
122 | 
123 | 
124 | def writepro2(p4info_helper, switch, a, b, probility):
125 |     table_entry = p4info_helper.buildTableEntry(
126 |         table_name="MyIngress.class2_pro",
127 |         match_fields={"meta.x": a,
128 |                       "meta.y": b
129 | 
130 |                       },
131 |         action_name="MyIngress.set_select2",
132 |         action_params={"probility": probility, }
133 |     )
134 |     switch.WriteTableEntry(table_entry)
135 |     print("Installed action rule about class2 pro")
136 | 
137 | 
138 | def writeaction(p4info_helper, switch, value, port):
139 |     para = get_actionpara(port)
140 |     table_entry = p4info_helper.buildTableEntry(
141 |         table_name="MyIngress.ipv4_exact",
142 |         match_fields={
143 |             "meta.classification": value},
144 |         action_name="MyIngress.ipv4_forward",
145 |         action_params=para
146 |     )
147 | 
148 |     switch.WriteTableEntry(table_entry)
149 |     print("Installed select rule on %s" % switch.name)
150 | 
151 | 
152 | def printGrpcError(e):
153 |     print("gRPC Error:", e.details(), )
154 |     status_code = e.code()
155 |     print("(%s)" % status_code.name, )
156 |     traceback = sys.exc_info()[2]
157 |     print("[%s:%d]" % (traceback.tb_frame.f_code.co_filename, traceback.tb_lineno))
158 | 
159 | 
160 | def main(p4info_file_path, bmv2_file_path):
161 |     p4info_helper = p4runtime_lib.helper.P4InfoHelper(p4info_file_path)
162 | 
163 |     try:
164 | 
165 |         s1 = p4runtime_lib.bmv2.Bmv2SwitchConnection(
166 |             name='s1',
167 |             address='127.0.0.1:50051',
168 |             device_id=0,
169 |             proto_dump_file='logs/s1-p4runtime-requests.txt')
170 | 
171 |         s1.MasterArbitrationUpdate()
172 | 
173 |         s1.SetForwardingPipelineConfig(p4info=p4info_helper.p4info,
174 |                                        bmv2_json_file_path=bmv2_file_path)
175 |         print("Installed P4 Program using SetForwardingPipelineConfig on s1")
176 | 
177 |         for i in range(5000,39000):
178 |             p11 = int(1 / np.sqrt(2 * np.pi * 0.001 ** 2) * np.exp(-((i - 5001) ** 2) / (2 * 0.001 ** 2)) * 10 ** 5)
179 |             p12 = int(1 / np.sqrt(2 * np.pi * 0.001 ** 2) * np.exp(-((i - 5001) ** 2) / (2 * 0.001 ** 2)) * 10 ** 5)
180 |             p21 = int(
181 |                 1 / np.sqrt(2 * np.pi * 0.001 ** 2) * np.exp(-((i - 11211) ** 2) / (2 * 0.001 ** 2)) * 10 ** 5)
182 |             p22 = int(
183 |                 1 / np.sqrt(2 * np.pi * 0.001 ** 2) * np.exp(-((i - 38094) ** 2) / (2 * 0.001 ** 2)) * 10 ** 5)
184 |             if (p11 > 65535):
185 |                 p11 = 65535
186 |             if (p12 > 65535):
187 |                 p12 = 65535
188 |             if (p21 > 65535):
189 |                 p21 = 65535
190 |             if (p22 > 65535):
191 |                 p22 = 65535
192 |             writeclass1x(p4info_helper, s1, i, p11)
193 |             writeclass1y(p4info_helper, s1, i, p12)
194 |             writeclass2x(p4info_helper, s1, i, p21)
195 |             writeclass2y(p4info_helper, s1, i, p22)
196 | 
197 |         writeaction(p4info_helper, s1, 1, 2)
198 |         writeaction(p4info_helper, s1, 2, 3)
199 | 
200 |         for i in range(0, 65530, 255):
201 |             for j in range(0, 65530, 255):
202 |                 a = [i, i + 255]
203 |                 b = [j, j + 255]
204 |                 probility = i * j
205 |                 writepro1(p4info_helper, s1, a, b, probility)
206 |                 writepro2(p4info_helper, s1, a, b, probility)
207 | 
208 |         # writepro1(p4info_helper, s1, [0, 0],[0,0], 0)
209 |         # writepro1(p4info_helper, s1, [65535,65535], [65535,65535], 1)
210 |         # writepro2(p4info_helper, s1, [0, 0],[0,0], 0)
211 |         # writepro2(p4info_helper, s1, [65535,65535], [65535,65535], 1)
212 | 
213 |     except KeyboardInterrupt:
214 |         print("Shutting down.")
215 | 
216 |     except grpc.RpcError as e:
217 |         printGrpcError(e)
218 | 
219 |     ShutdownAllSwitchConnections()
220 | 
221 | 
222 | if __name__ == '__main__':
223 |     parser = argparse.ArgumentParser(description='P4Runtime Controller')
224 |     parser.add_argument('--p4info', help='p4info proto in text format from p4c',
225 |                         type=str, action="store", required=False,
226 |                         default='./build/bayes.p4info')
227 | 
228 |     parser.add_argument('--bmv2-json', help='BMv2 JSON file from p4c',
229 |                         type=str, action="store", required=False,
230 |                         default='./build/bayes.json')
231 | 
232 |     args = parser.parse_args()
233 | 
234 |     if not os.path.exists(args.p4info):
235 |         parser.print_help()
236 |         print("\np4info file not found: %s\nHave you run 'make'?" % args.p4info)
237 |         parser.exit(1)
238 | 
239 |     if not os.path.exists(args.bmv2_json):
240 |         parser.print_help()
241 |         print("\nBMv2 JSON file not found: %s\nHave you run 'make'?" % args.bmv2_json)
242 |         parser.exit(1)
243 | 
244 |     main(args.p4info, args.bmv2_json)
245 | 


--------------------------------------------------------------------------------
/iisy_sw/simple_example/naive_bayes/bayes.p4:
--------------------------------------------------------------------------------
  1 | /* -*- P4_16 -*- */
  2 | /********************************************************************************
  3 | *
  4 | * Copyright (c) 2019 Zhaoqi Xiong
  5 | * All rights reserved.
  6 | *
  7 | *
  8 | * @NETFPGA_LICENSE_HEADER_START@
  9 | *
 10 | * Licensed to NetFPGA C.I.C. (NetFPGA) under one or more contributor
 11 | * license agreements.  See the NOTICE file distributed with this work for
 12 | * additional information regarding copyright ownership.  NetFPGA licenses this
 13 | * file to you under the NetFPGA Hardware-Software License, Version 1.0 (the
 14 | * "License"); you may not use this file except in compliance with the
 15 | * License.  You may obtain a copy of the License at:
 16 | *
 17 | *   http://www.netfpga-cic.org
 18 | *
 19 | * Unless required by applicable law or agreed to in writing, Work distributed
 20 | * under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
 21 | * CONDITIONS OF ANY KIND, either express or implied.  See the License for the
 22 | * specific language governing permissions and limitations under the License.
 23 | *
 24 | * @NETFPGA_LICENSE_HEADER_END@
 25 | *
 26 | ********************************************************************************/ 
 27 | 
 28 | #include <core.p4>
 29 | #include <v1model.p4>
 30 | 
 31 | const bit<16> TYPE_IPV4 = 0x800;
 32 | 
 33 | /*************************************************************************
 34 | *********************** H E A D E R S  ***********************************
 35 | *************************************************************************/
 36 | 
 37 | typedef bit<9>  egressSpec_t;
 38 | typedef bit<48> macAddr_t;
 39 | typedef bit<32> ip4Addr_t;
 40 | 
 41 | header ethernet_t {
 42 |     macAddr_t dstAddr;
 43 |     macAddr_t srcAddr;
 44 |     bit<16>   etherType;
 45 | }
 46 | 
 47 | header ipv4_t {
 48 |     bit<4>    version;
 49 |     bit<4>    ihl;
 50 |     bit<8>    diffserv;
 51 |     bit<16>   totalLen;
 52 |     bit<16>   identification;
 53 |     bit<3>    flags;
 54 |     bit<13>   fragOffset;
 55 |     bit<8>    ttl;
 56 |     bit<8>    protocol;
 57 |     bit<16>   hdrChecksum;
 58 |     ip4Addr_t srcAddr;
 59 |     ip4Addr_t dstAddr;
 60 | }
 61 | 
 62 | header tcp_t {
 63 |     bit<16> srcPort;
 64 |     bit<16> dstPort;
 65 |     bit<32> seqNo;
 66 |     bit<32> ackNo;
 67 |     bit<4>  dataOffset;
 68 |     bit<3>  res;
 69 |     bit<3>  ecn;
 70 |     bit<6>  ctrl;
 71 |     bit<16> window;
 72 |     bit<16> checksum;
 73 |     bit<16> urgentPtr;
 74 | }
 75 | 
 76 | struct metadata {
 77 |     bit<32> action_select1;
 78 |     bit<32> action_select2;
 79 |     bit<32> classification;
 80 |     bit<32> x;
 81 |     bit<32> y;
 82 | }
 83 | 
 84 | struct headers {
 85 |     ethernet_t   ethernet;
 86 |     ipv4_t     ipv4;
 87 |     tcp_t      tcp;
 88 | }
 89 | 
 90 | /*************************************************************************
 91 | *********************** P A R S E R  ***********************************
 92 | *************************************************************************/
 93 | 
 94 | parser MyParser(packet_in packet,
 95 |                 out headers hdr,
 96 |                 inout metadata meta,
 97 |                 inout standard_metadata_t standard_metadata) {
 98 |     
 99 |     state start {
100 |         transition parse_ethernet;
101 |     }
102 |     
103 |     state parse_ethernet {
104 |         packet.extract(hdr.ethernet);
105 |         transition select(hdr.ethernet.etherType) {
106 |             TYPE_IPV4: parse_ipv4;
107 |             default: accept;
108 | }
109 | }
110 |     
111 |     state parse_ipv4 {
112 |         packet.extract(hdr.ipv4);
113 |         transition select(hdr.ipv4.protocol) {
114 |             6: parse_tcp;
115 |             default: accept;
116 |     }
117 |     }
118 |     state parse_tcp {
119 |         packet.extract(hdr.tcp);
120 |         transition accept;
121 | }
122 | }
123 | 
124 | /*************************************************************************
125 | ************   C H E C K S U M    V E R I F I C A T I O N   *************
126 | *************************************************************************/
127 | 
128 | control MyVerifyChecksum(inout headers hdr, inout metadata meta) {
129 |     apply {  }
130 | }
131 | 
132 | 
133 | /*************************************************************************
134 | **************  I N G R E S S   P R O C E S S I N G   *******************
135 | *************************************************************************/
136 | 
137 | control MyIngress(inout headers hdr,
138 |                   inout metadata meta,
139 |                   inout standard_metadata_t standard_metadata) {
140 |     action drop() {
141 |         mark_to_drop();
142 |     }
143 |     
144 |     action ipv4_forward(macAddr_t dstAddr, egressSpec_t port) {
145 |         standard_metadata.egress_spec = port;
146 |         hdr.ethernet.srcAddr = hdr.ethernet.dstAddr;
147 |         hdr.ethernet.dstAddr = dstAddr;
148 |                   }
149 | 
150 | 
151 | action set_p1(bit<32> square){
152 |     meta.x =  square;
153 | }
154 | action set_p2(bit<32> square ){
155 |     meta.y =  square;
156 | }
157 | 
158 | action set_select1(bit<32> probility){
159 |     meta.action_select1 = probility;
160 | }
161 | 
162 | action set_select2(bit<32> probility){
163 |     meta.action_select2 = probility;
164 | }
165 | 
166 | table class1_p1 {
167 |     key = {
168 |         hdr.tcp.srcPort: exact;
169 |         }
170 |         actions = {
171 |             NoAction;
172 |             set_p1;
173 |                 }
174 |                     size = 65535;
175 | }
176 | 
177 | table class1_p2 {
178 |     key = {
179 |     hdr.tcp.dstPort: exact;
180 |         }
181 |         actions = {
182 |             NoAction;
183 |             set_p2;
184 |             }
185 |                 size = 65535;
186 | }
187 | 
188 | table class2_p1 {
189 |     key = {
190 |         hdr.tcp.srcPort: exact;
191 |         }
192 |         actions = {
193 |             NoAction;
194 |             set_p1;
195 |                 }
196 |                     size = 65535;
197 | }
198 | 
199 | table class2_p2 {
200 |     key = {
201 |     hdr.tcp.dstPort: exact;
202 |         }
203 |         actions = {
204 |             NoAction;
205 |             set_p2;
206 |             }
207 |                 size = 65535;
208 | }
209 | 
210 | table class1_pro {
211 |     key = {
212 |     meta.x: range;
213 |     meta.y: range;
214 |         }
215 |         actions = {
216 |             NoAction;
217 |             set_select1;
218 |             }
219 |                 size = 70000;
220 | }
221 | 
222 | table class2_pro {
223 |     key = {
224 |     meta.x: range;
225 |     meta.y: range;
226 |         }
227 |         actions = {
228 |             NoAction;
229 |             set_select2;
230 |         }
231 |             size = 700000;
232 | }
233 | 
234 | 
235 | 
236 | table ipv4_exact {
237 |     key = {
238 |         meta.classification: exact;
239 | }
240 |     
241 |     actions = {
242 |         ipv4_forward;
243 |         drop;
244 |         NoAction;
245 | }
246 |     size = 1024;
247 |         default_action = drop();
248 |     }
249 | 
250 |     apply {
251 |         if (hdr.ipv4.isValid() ) {
252 |             if(hdr.ipv4.protocol ==6) {
253 |                 class1_p1.apply();
254 |                 class1_p2.apply();
255 |                 class1_pro.apply();
256 |                     
257 |                     class2_p1.apply();
258 |                     class2_p2.apply();
259 |                     class2_pro.apply();
260 | 
261 | if ( meta.action_select1 >= meta.action_select2 )
262 |     {  meta.classification = 1; }
263 |         else { meta.classification = 2;}
264 | }
265 | 
266 | }
267 | 
268 | ipv4_exact.apply();
269 | 
270 | }
271 | }
272 | 
273 | /*************************************************************************
274 | ****************  E G R E S S   P R O C E S S I N G   *******************
275 | *************************************************************************/
276 | 
277 | control MyEgress(inout headers hdr,
278 |                  inout metadata meta,
279 |                  inout standard_metadata_t standard_metadata) {
280 |     apply {  }
281 | }
282 | 
283 | /*************************************************************************
284 | *************   C H E C K S U M    C O M P U T A T I O N   **************
285 | *************************************************************************/
286 | 
287 | control MyComputeChecksum(inout headers  hdr, inout metadata meta) {
288 |     apply {
289 |     update_checksum(
290 |                     hdr.ipv4.isValid(),
291 |                     { hdr.ipv4.version,
292 |                     hdr.ipv4.ihl,
293 |                     hdr.ipv4.diffserv,
294 |                     hdr.ipv4.totalLen,
295 |                     hdr.ipv4.identification,
296 |                     hdr.ipv4.flags,
297 |                     hdr.ipv4.fragOffset,
298 |                     hdr.ipv4.ttl,
299 |                     hdr.ipv4.protocol,
300 |                     hdr.ipv4.srcAddr,
301 |                     hdr.ipv4.dstAddr },
302 |                     hdr.ipv4.hdrChecksum,
303 |                     HashAlgorithm.csum16);
304 | }
305 | }
306 | 
307 | /*************************************************************************
308 | ***********************  D E P A R S E R  *******************************
309 | *************************************************************************/
310 | 
311 | control MyDeparser(packet_out packet, in headers hdr) {
312 |     apply {
313 |         packet.emit(hdr.ethernet);
314 |         packet.emit(hdr.ipv4);
315 |         packet.emit(hdr.tcp);
316 | }
317 | }
318 | 
319 | /*************************************************************************
320 | ***********************  S W I T C H  *******************************
321 | *************************************************************************/
322 | 
323 | V1Switch(
324 |          MyParser(),
325 |          MyVerifyChecksum(),
326 |          MyIngress(),
327 |          MyEgress(),
328 |          MyComputeChecksum(),
329 |          MyDeparser()
330 |          ) main;
331 | 


--------------------------------------------------------------------------------
/iisy_sw/simple_example/kmeans/kmeans.p4:
--------------------------------------------------------------------------------
  1 | /* -*- P4_16 -*- */
  2 | /********************************************************************************
  3 | *
  4 | * Copyright (c) 2019 Zhaoqi Xiong
  5 | * All rights reserved.
  6 | *
  7 | *
  8 | * @NETFPGA_LICENSE_HEADER_START@
  9 | *
 10 | * Licensed to NetFPGA C.I.C. (NetFPGA) under one or more contributor
 11 | * license agreements.  See the NOTICE file distributed with this work for
 12 | * additional information regarding copyright ownership.  NetFPGA licenses this
 13 | * file to you under the NetFPGA Hardware-Software License, Version 1.0 (the
 14 | * "License"); you may not use this file except in compliance with the
 15 | * License.  You may obtain a copy of the License at:
 16 | *
 17 | *   http://www.netfpga-cic.org
 18 | *
 19 | * Unless required by applicable law or agreed to in writing, Work distributed
 20 | * under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
 21 | * CONDITIONS OF ANY KIND, either express or implied.  See the License for the
 22 | * specific language governing permissions and limitations under the License.
 23 | *
 24 | * @NETFPGA_LICENSE_HEADER_END@
 25 | *
 26 | ********************************************************************************/
 27 | 
 28 | #include <core.p4>
 29 | #include <v1model.p4>
 30 | 
 31 | const bit<16> TYPE_IPV4 = 0x800;
 32 | 
 33 | /*************************************************************************
 34 | *********************** H E A D E R S  ***********************************
 35 | *************************************************************************/
 36 | 
 37 | typedef bit<9>  egressSpec_t;
 38 | typedef bit<48> macAddr_t;
 39 | typedef bit<32> ip4Addr_t;
 40 | 
 41 | header ethernet_t {
 42 |     macAddr_t dstAddr;
 43 |     macAddr_t srcAddr;
 44 |     bit<16>   etherType;
 45 | }
 46 | 
 47 | header ipv4_t {
 48 |     bit<4>    version;
 49 |     bit<4>    ihl;
 50 |     bit<8>    diffserv;
 51 |     bit<16>   totalLen;
 52 |     bit<16>   identification;
 53 |     bit<3>    flags;
 54 |     bit<13>   fragOffset;
 55 |     bit<8>    ttl;
 56 |     bit<8>    protocol;
 57 |     bit<16>   hdrChecksum;
 58 |     ip4Addr_t srcAddr;
 59 |     ip4Addr_t dstAddr;
 60 | }
 61 | 
 62 | header tcp_t {
 63 |     bit<16> srcPort;
 64 |     bit<16> dstPort;
 65 |     bit<32> seqNo;
 66 |     bit<32> ackNo;
 67 |     bit<4>  dataOffset;
 68 |     bit<3>  res;
 69 |     bit<3>  ecn;
 70 |     bit<6>  ctrl;
 71 |     bit<16> window;
 72 |     bit<16> checksum;
 73 |     bit<16> urgentPtr;
 74 | }
 75 | 
 76 | struct metadata {
 77 |     bit<32>  action_select1;
 78 |     bit<32> action_select2;
 79 |     bit<32> classification;
 80 |     bit<16> distancex;
 81 |     bit<16> distancey;
 82 |     bit<32> x;
 83 |     bit<32> y;
 84 | }
 85 | 
 86 | struct headers {
 87 |     ethernet_t   ethernet;
 88 |     ipv4_t     ipv4;
 89 |     tcp_t      tcp;
 90 | }
 91 | 
 92 | /*************************************************************************
 93 | *********************** P A R S E R  ***********************************
 94 | *************************************************************************/
 95 | 
 96 | parser MyParser(packet_in packet,
 97 |                 out headers hdr,
 98 |                 inout metadata meta,
 99 |                 inout standard_metadata_t standard_metadata) {
100 |     
101 |     state start {
102 |         transition parse_ethernet;
103 |     }
104 |     
105 |     state parse_ethernet {
106 |         packet.extract(hdr.ethernet);
107 |         transition select(hdr.ethernet.etherType) {
108 |             TYPE_IPV4: parse_ipv4;
109 |             default: accept;
110 | }
111 | }
112 |     
113 |     state parse_ipv4 {
114 |         packet.extract(hdr.ipv4);
115 |         transition select(hdr.ipv4.protocol) {
116 |             6: parse_tcp;
117 |             default: accept;
118 |         }
119 |     }
120 |     state parse_tcp {
121 |         packet.extract(hdr.tcp);
122 |         transition accept;
123 | }
124 | }
125 | 
126 | /*************************************************************************
127 | ************   C H E C K S U M    V E R I F I C A T I O N   *************
128 | *************************************************************************/
129 | 
130 | control MyVerifyChecksum(inout headers hdr, inout metadata meta) {
131 |     apply {  }
132 | }
133 | 
134 | 
135 | /*************************************************************************
136 | **************  I N G R E S S   P R O C E S S I N G   *******************
137 | *************************************************************************/
138 | 
139 | control MyIngress(inout headers hdr,
140 |                   inout metadata meta,
141 |                   inout standard_metadata_t standard_metadata) {
142 |     action drop() {
143 |         mark_to_drop();
144 |     }
145 | 
146 |     action ipv4_forward(macAddr_t dstAddr, egressSpec_t port) {
147 |         standard_metadata.egress_spec = port;
148 |         hdr.ethernet.srcAddr = hdr.ethernet.dstAddr;
149 |         hdr.ethernet.dstAddr = dstAddr;
150 |     }
151 | 
152 | 
153 | action set_distancex(bit<32> square){
154 |     meta.x =  square;
155 | }
156 | action set_distancey(bit<32> square ){
157 |     meta.y =  square;
158 | }
159 | 
160 | 
161 | 
162 | table class1_exactx {
163 |     key = {
164 |         meta.distancex: exact;
165 |         }
166 |         actions = {
167 |             NoAction;
168 |             set_distancex;
169 |                 }
170 |                     size = 65535;
171 | }
172 | 
173 | table class1_exacty {
174 |     key = {
175 |     meta.distancey: exact;
176 |         }
177 |         actions = {
178 |             NoAction;
179 |             set_distancey;
180 |             }
181 |                 size = 65535;
182 | }
183 | 
184 | table class2_exactx {
185 |     key = {
186 |     meta.distancex: exact;
187 |         }
188 |         actions = {
189 |             NoAction;
190 |             set_distancex;
191 |                 }
192 |                     size = 65535;
193 | }
194 | 
195 | table class2_exacty {
196 |     key = {
197 |     meta.distancey: exact;
198 |         }
199 |         actions = {
200 |             NoAction;
201 |             set_distancey;
202 |             }
203 |                 size = 65535;
204 | }
205 |     
206 |     
207 |     table ipv4_exact {
208 |         key = {
209 |             meta.classification: exact;
210 | }
211 |     
212 |     actions = {
213 |         ipv4_forward;
214 |             drop;
215 |                 NoAction;
216 | }
217 |     size = 1024;
218 |         default_action = drop();
219 |     }
220 | 
221 |     apply {
222 |         if (hdr.ipv4.isValid() ) {
223 |             if(hdr.ipv4.protocol ==6) {
224 |                 
225 |                 if(hdr.tcp.srcPort > 2500)
226 |             {meta.distancex = hdr.tcp.srcPort - 2500;}
227 |             else{meta.distancex = 2500-  hdr.tcp.srcPort;}
228 |                 
229 |                 if(hdr.tcp.dstPort > 2500)
230 |             {meta.distancey = hdr.tcp.dstPort - 2500;}
231 |             else{meta.distancey = 2500-  hdr.tcp.dstPort;}
232 |             
233 |             class1_exactx.apply();
234 |             class1_exacty.apply();
235 |             meta.action_select1 = meta.x + meta.y;
236 |             
237 |             if(hdr.tcp.srcPort > 37233)
238 |             {meta.distancex = hdr.tcp.srcPort - 37233;}
239 |             else{meta.distancex = 37233 -  hdr.tcp.srcPort;}
240 |                 
241 |                 if(hdr.tcp.dstPort > 37209)
242 |             {meta.distancey = hdr.tcp.dstPort - 37209;}
243 |             else{meta.distancey = 37209 -  hdr.tcp.dstPort;}
244 |             
245 |             
246 |             class2_exactx.apply();
247 |             class2_exacty.apply();
248 |             meta.action_select2 = meta.x + meta.y ;
249 | 
250 | if ( meta.action_select1 > meta.action_select2 )
251 |     {  meta.classification = 1; }
252 |         else { meta.classification = 2;}
253 | }
254 | 
255 | }
256 | 
257 | ipv4_exact.apply();
258 | 
259 | }
260 | }
261 | 
262 | /*************************************************************************
263 | ****************  E G R E S S   P R O C E S S I N G   *******************
264 | *************************************************************************/
265 | 
266 | control MyEgress(inout headers hdr,
267 |                  inout metadata meta,
268 |                  inout standard_metadata_t standard_metadata) {
269 |     apply {  }
270 | }
271 | 
272 | /*************************************************************************
273 | *************   C H E C K S U M    C O M P U T A T I O N   **************
274 | *************************************************************************/
275 | 
276 | control MyComputeChecksum(inout headers  hdr, inout metadata meta) {
277 |     apply {
278 |     update_checksum(
279 |                     hdr.ipv4.isValid(),
280 |                     { hdr.ipv4.version,
281 |                     hdr.ipv4.ihl,
282 |                     hdr.ipv4.diffserv,
283 |                     hdr.ipv4.totalLen,
284 |                     hdr.ipv4.identification,
285 |                     hdr.ipv4.flags,
286 |                     hdr.ipv4.fragOffset,
287 |                     hdr.ipv4.ttl,
288 |                     hdr.ipv4.protocol,
289 |                     hdr.ipv4.srcAddr,
290 |                     hdr.ipv4.dstAddr },
291 |                     hdr.ipv4.hdrChecksum,
292 |                     HashAlgorithm.csum16);
293 | }
294 | }
295 | 
296 | /*************************************************************************
297 | ***********************  D E P A R S E R  *******************************
298 | *************************************************************************/
299 | 
300 | control MyDeparser(packet_out packet, in headers hdr) {
301 |     apply {
302 |         packet.emit(hdr.ethernet);
303 |         packet.emit(hdr.ipv4);
304 |         packet.emit(hdr.tcp);
305 | }
306 | }
307 | 
308 | /*************************************************************************
309 | ***********************  S W I T C H  *******************************
310 | *************************************************************************/
311 | 
312 | V1Switch(
313 |          MyParser(),
314 |          MyVerifyChecksum(),
315 |          MyIngress(),
316 |          MyEgress(),
317 |          MyComputeChecksum(),
318 |          MyDeparser()
319 |          ) main;
320 | 


--------------------------------------------------------------------------------
/iisy_sw/framework/Runtime.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python3
  2 | #################################################################################
  3 | #
  4 | # Copyright (c) 2019 Zhaoqi Xiong
  5 | # All rights reserved.
  6 | #
  7 | #
  8 | # @NETFPGA_LICENSE_HEADER_START@
  9 | #
 10 | # Licensed to NetFPGA C.I.C. (NetFPGA) under one or more contributor
 11 | # license agreements.  See the NOTICE file distributed with this work for
 12 | # additional information regarding copyright ownership.  NetFPGA licenses this
 13 | # file to you under the NetFPGA Hardware-Software License, Version 1.0 (the
 14 | # "License"); you may not use this file except in compliance with the
 15 | # License.  You may obtain a copy of the License at:
 16 | #
 17 | #   http://www.netfpga-cic.org
 18 | #
 19 | # Unless required by applicable law or agreed to in writing, Work distributed
 20 | # under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
 21 | # CONDITIONS OF ANY KIND, either express or implied.  See the License for the
 22 | # specific language governing permissions and limitations under the License.
 23 | #
 24 | # @NETFPGA_LICENSE_HEADER_END@
 25 | #
 26 | ################################################################################# 
 27 | 
 28 | import json
 29 | import re
 30 | import argparse
 31 | 
 32 | # Add argument
 33 | parser = argparse.ArgumentParser()
 34 | parser.add_argument('-i1', required=True, help='path to text tree')
 35 | parser.add_argument('-i2', required=True, help='path to text action')
 36 | parser.add_argument('-o', required=True, help='output path')
 37 | args = parser.parse_args()
 38 | inputfile = args.i1
 39 | actionfile = args.i2
 40 | outputfile = args.o
 41 | 
 42 | # read the action.text, find the actions for different classes.
 43 | def find_action(textfile):
 44 |     action =[]
 45 |     f = open(textfile)
 46 |     for line in f:
 47 |         n = re.findall(r"class", line)
 48 |         if n:
 49 |             fea = re.findall(r"\d",line)
 50 |             action.append(int(fea[1]))
 51 |     f.close()
 52 |     return action
 53 | 
 54 | # read the tree model, search the threshold value
 55 | def find_feature(textfile):
 56 |     f = open(textfile)
 57 |     line = f.readline()
 58 |     proto = re.findall('\d+', line)
 59 |     line = f.readline()
 60 |     src = re.findall('\d+', line)
 61 |     line = f.readline()
 62 |     dst = re.findall('\d+', line)
 63 |     f.close
 64 |     proto = [int(i) for i in proto]
 65 |     src = [int(i) for i in src]
 66 |     dst = [int(i) for i in dst]
 67 |     return proto,src,dst
 68 | 
 69 | # read the leaf node description and find the corresponding ranges
 70 | def find_classification(textfile,proto,src,dst):
 71 |     fea = []
 72 |     sign =[]
 73 |     num =[]
 74 |     f = open(textfile,'r')
 75 |     for line in f:
 76 |         n = re.findall(r"when", line)
 77 |         if n:
 78 |             fea.append(re.findall(r"(proto|src|dst)",line))
 79 |             sign.append(re.findall(r"(<=|>)",line))
 80 |             num.append(re.findall(r"\d+\.?\d*", line))
 81 |     f.close()
 82 | 
 83 | 
 84 |     protocol =[]
 85 |     srouce = []
 86 |     dstination =[]
 87 |     classfication =[]
 88 | 
 89 | 
 90 |     for i in range(len(fea)):
 91 |         feature1 = [i for i in range(len(proto) + 1)]
 92 |         feature2 = [i for i in range(len(src) + 1)]
 93 |         feature3 = [i for i in range(len(dst) + 1)]
 94 |         for j,feature in enumerate(fea[i]):
 95 |             if feature == 'proto':
 96 |                 sig = sign[i][j]
 97 |                 thres = int(float(num[i][j]))
 98 |                 id = proto.index(thres)
 99 |                 if sig == '<=':
100 |                     while id < len(proto):
101 |                         if id + 1 in feature1:
102 |                             feature1.remove(id+1)
103 |                         id = id+1
104 |                 else:
105 |                     while id >= 0:
106 |                         if id  in feature1:
107 |                             feature1.remove(id)
108 |                         id = id-1
109 |             elif feature == 'src':
110 |                 sig = sign[i][j]
111 |                 thres = int(float(num[i][j]))
112 |                 id = src.index(thres)
113 |                 if sig == '<=':
114 |                     while id < len(src):
115 |                         if id+1 in feature2:
116 |                             feature2.remove(id+1)
117 |                         id = id+1
118 |                 else:
119 |                     while id >= 0:
120 |                         if id  in feature2:
121 |                             feature2.remove(id)
122 |                         id = id-1
123 |             else:
124 |                 sig = sign[i][j]
125 |                 thres = int(float(num[i][j]))
126 |                 id = dst.index(thres)
127 |                 if sig == '<=':
128 |                     while id < len(dst):
129 |                         if id + 1 in feature3:
130 |                             feature3.remove(id+1)
131 |                         id = id+1
132 |                 else:
133 |                     while id >= 0:
134 |                         if id  in feature3:
135 |                             feature3.remove(id)
136 |                         id = id-1
137 |         protocol.append(feature1)
138 |         srouce.append(feature2)
139 |         dstination.append(feature3)
140 |         a= len(num[i])
141 |         classfication.append(num[i][a-1])
142 |     return(protocol,srouce,dstination,classfication)
143 | 
144 | # write json file information 
145 | def write_info(file):
146 |     file.write("\"target\":\"bmv2\",\n")
147 |     file.write("\"p4info\":\"build/example.p4info\",\n")
148 |     file.write("\"bmv2_json\":\"build/example.json\",\n")
149 |     file.write("\"table_entries\":[\n")
150 | 
151 | # get action parameters 
152 | def get_actionpara(action):
153 |     para = {}
154 |     if action == 0 :
155 |         para = {}
156 |     elif action == 2:
157 |         para = {'dstAddr': '00:00:00:02:02:00','port': 2}
158 |     elif action == 3:
159 |         para = {'dstAddr': '00:00:00:03:03:00','port': 3}
160 |     elif action == 4:
161 |         para = {'dstAddr': '00:00:00:04:04:00','port': 4}
162 | 
163 |     return para
164 | 
165 | # write default action
166 | def write_ingress_default(file):
167 |     file.write("{\n")
168 |     file.write("    \"table\": \"MyIngress.ipv4_exact\",\n")
169 |     file.write("    \"default\": true ,\n")
170 |     file.write("    \"action_name\": \"MyIngress.drop\",\n")
171 |     file.write("    \"action_params\": {}\n")
172 |     file.write("}\n")
173 | 
174 | 
175 | # write the entries for decision table
176 | def write_ingress(file,a,b,c,action,port):
177 | 
178 |     para = get_actionpara(port)
179 | 
180 |     data = {'table': 'MyIngress.ipv4_exact',
181 |             'match': {'meta.action_select1': a,
182 |                       'meta.action_select2': b,
183 |                       'meta.action_select3': c },
184 |             'action_name': action,
185 |             'action_params': para
186 | 
187 |             }
188 | 
189 |     jsondata =json.dumps(data,
190 |                       indent=4,
191 |                       separators=(', ', ': '), ensure_ascii=False)
192 |     file.write(jsondata)
193 |     file.write(",\n")
194 | 
195 | # write the entries for feature1 table
196 | def write_feature1(file,a,ind):
197 |     data = {'table':'MyIngress.feature1_exact',
198 |             'match': { 'hdr.ipv4.protocol': a},
199 |             'action_name':'MyIngress.set_actionselect1',
200 |             'action_params':{'featurevalue1':ind}
201 |             }
202 | 
203 |     jsondata =json.dumps(data,
204 |                       indent=4, ensure_ascii=False)
205 |     file.write(jsondata)
206 |     file.write(",\n")
207 | 
208 | # write the entries for feature 2 table
209 | def write_feature2(file,a,ind):
210 |     data = {'table':'MyIngress.feature2_exact',
211 |             'match': { 'hdr.tcp.srcPort': a},
212 |             'action_name':'MyIngress.set_actionselect2',
213 |             'action_params':{'featurevalue2':ind}
214 |             }
215 | 
216 |     jsondata =json.dumps(data,
217 |                       indent=4, ensure_ascii=False)
218 |     file.write(jsondata)
219 |     file.write(",\n")
220 | 
221 | # write the entries for feature 3 table
222 | def write_feature3(file,a,ind):
223 |     data = {'table':'MyIngress.feature3_exact',
224 |             'match': { 'hdr.tcp.dstPort': a},
225 |             'action_name':'MyIngress.set_actionselect3',
226 |             'action_params':{'featurevalue3':ind}
227 |             }
228 | 
229 |     jsondata =json.dumps(data,
230 |                       indent=4, ensure_ascii=False)
231 |     file.write(jsondata)
232 |     file.write(",\n")
233 | 
234 | 
235 | proto,src,dst = find_feature(inputfile)
236 | protocol,srouce,dstination,classfication = find_classification(inputfile,proto,src,dst)
237 | action = find_action(actionfile)
238 | 
239 | 
240 | runtime = open(outputfile,"w+")
241 | runtime.write("{ \n")
242 | write_info(runtime)
243 | 
244 | # parameter for decision table
245 | for i in range(len(classfication)):
246 |     a = protocol[i]
247 |     id = len(a) - 1
248 |     del a[1:id]
249 |     if(len(a) == 1):
250 |         a.append(a[0])
251 |     b = srouce[i]
252 |     id = len(b) - 1
253 |     del b[1:id]
254 |     if (len(b) == 1):
255 |         b.append(b[0])
256 |     c = dstination[i]
257 |     id = len(c) - 1
258 |     del c[1:id]
259 |     if (len(c) == 1):
260 |         c.append(c[0])
261 | 
262 |     ind = int(classfication[i])
263 |     ac = action[ind]
264 |     a = [i+1 for i in a]
265 |     b = [i+1 for i in b]
266 |     c = [i+1 for i in c]
267 |     if ac == 0:
268 |         write_ingress(runtime, a, b, c, 'MyIngress.drop', 0)
269 |     else:
270 |         print(a,b,c,ac)
271 |         write_ingress(runtime, a, b, c,'MyIngress.ipv4_forward',ac)
272 | 
273 | #parameter in feature 1 table
274 | if len(proto)!= 0:
275 |     proto.append(0)
276 |     proto.append(32)
277 |     proto.sort()
278 |     for i in range(len(proto)-1):
279 |         write_feature1(runtime, proto[i:i + 2], i+1)
280 | else:
281 |     write_feature1(runtime,[0,32],1)
282 | #parameter in feature 2 table
283 | if len(src) != 0:
284 |     src.append(0)
285 |     src.append(65535)
286 |     src.sort()
287 |     for i in range(len(src)-1):
288 |         write_feature2(runtime, src[i:i + 2], i+1)
289 | #parameter in feature 3 table
290 | if len(dst) != 0:
291 |     dst.append(0)
292 |     dst.append(65535)
293 |     dst.sort()
294 |     for i in range(len(dst)-1):
295 |         write_feature3(runtime, dst[i:i + 2], i+1)
296 | 
297 | 
298 | 
299 | write_ingress_default(runtime)
300 | 
301 | runtime.write("] \n  }")
302 | runtime.close()
303 | 
304 | 
305 | 
306 | 


--------------------------------------------------------------------------------
/iisy_hw/iisy_svm.p4:
--------------------------------------------------------------------------------
  1 | //
  2 | // Copyright (c) 2019 Noa Zilberman
  3 | // All rights reserved.
  4 | //
  5 | // @NETFPGA_LICENSE_HEADER_START@
  6 | //
  7 | // Licensed to NetFPGA C.I.C. (NetFPGA) under one or more contributor
  8 | // license agreements.  See the NOTICE file distributed with this work for
  9 | // additional information regarding copyright ownership.  NetFPGA licenses this
 10 | // file to you under the NetFPGA Hardware-Software License, Version 1.0 (the
 11 | // "License"); you may not use this file except in compliance with the
 12 | // License.  You may obtain a copy of the License at:
 13 | //
 14 | //   http://www.netfpga-cic.org
 15 | //
 16 | // Unless required by applicable law or agreed to in writing, Work distributed
 17 | // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
 18 | // CONDITIONS OF ANY KIND, either express or implied.  See the License for the
 19 | // specific language governing permissions and limitations under the License.
 20 | //
 21 | // @NETFPGA_LICENSE_HEADER_END@
 22 | //
 23 | 
 24 | 
 25 | #include <core.p4>
 26 | #include <sume_switch.p4>
 27 | 
 28 | 
 29 | typedef bit<48> EthAddr_t; 
 30 | typedef bit<32> IPv4Addr_t;
 31 | typedef bit<16> TCPAddr_t;
 32 | 
 33 | #define IPV4_TYPE 0x0800
 34 | #define IPV6_TYPE 0x86DD
 35 | #define TCP_TYPE 6
 36 | 
 37 | 
 38 | 
 39 | //Standard Ethernet Header
 40 | header Ethernet_h {
 41 |     EthAddr_t dstAddr;
 42 |     EthAddr_t srcAddr;
 43 |     bit<16> etherType;
 44 | }
 45 | 
 46 | //IPv4 header without options
 47 | header IPv4_h {
 48 |     bit<4> version;
 49 |     bit<4> ihl;
 50 |     bit<8> tos;
 51 |     bit<16> totalLen;
 52 |     bit<16> identification;
 53 |     bit<3> flags;
 54 |     bit<13> fragOffset;
 55 |     bit<8> ttl;
 56 |     bit<8> protocol;
 57 |     bit<16> hdrChecksum;
 58 |     IPv4Addr_t srcAddr;
 59 |     IPv4Addr_t dstAddr;
 60 | }
 61 | 
 62 | //IPv6 header
 63 | header IPv6_h{
 64 |   bit<4> version;
 65 |   bit<8> trafficClass;
 66 |   bit<20> flowLabel;
 67 |   bit<16> payloadLen;
 68 |   bit<8> nxt;
 69 |   bit<8> hopLimit;
 70 |   bit<128> srcAddr;
 71 |   bit<128> dstAddr;
 72 | }
 73 | 
 74 | //TCP header without options
 75 | header TCP_h {
 76 |     bit<16> srcPort;
 77 |     bit<16> dstPort;
 78 |     bit<32> seqNo;
 79 |     bit<32> ackNo;
 80 |     bit<4> dataOffset;
 81 |     bit<4> res;
 82 |     bit<8> flags;
 83 |     bit<16> window;
 84 |     bit<16> checksum;
 85 |     bit<16> urgentPtr;
 86 | }
 87 | 
 88 | 
 89 | // List of all recognized headers
 90 | struct Parsed_packet {
 91 |     Ethernet_h ethernet;
 92 |     IPv4_h ip;
 93 |     IPv6_h ip6;
 94 |     TCP_h tcp;
 95 | }
 96 | 
 97 | 
 98 | // user defined metadata
 99 | // used for coding the decision 
100 | struct user_metadata_t {
101 |     bit<5> pkt_len_code;
102 |     bit<5> ip_proto_code;
103 |     bit<5> ip_flags_code;
104 |     bit<5> tcp_srcport_code;
105 |     bit<5> tcp_dstport_code;
106 |     bit<7> unused; 
107 | }
108 | 
109 | // digest_data, MUST be 256 bits
110 | struct digest_data_t {
111 |     bit<1> vhp01;
112 |     bit<1> vhp02;
113 | bit<1> vhp03;
114 | bit<1> vhp04;
115 | bit<1> vhp12;
116 | bit<1> vhp13;
117 | bit<1> vhp14;
118 | bit<1> vhp23;
119 | bit<1> vhp24;
120 | bit<1> vhp34;
121 | 
122 |     bit<246> unused;
123 | }
124 | 
125 | // Parser Implementation
126 | 
127 | 
128 | @Xilinx_MaxPacketRegion(8192)
129 | parser TopParser(packet_in b,
130 |                  out Parsed_packet p,
131 |                  out user_metadata_t user_metadata,
132 |                  out digest_data_t digest_data,
133 |                  inout sume_metadata_t sume_metadata) {
134 |     state start {
135 |         b.extract(p.ethernet);
136 |         user_metadata.unused = 0;
137 |         digest_data.unused = 0;
138 |         transition select(p.ethernet.etherType) {
139 |             IPV4_TYPE: parse_ipv4;
140 |             IPV6_TYPE: parse_ipv6;
141 |             default: accept;
142 |         }
143 |     }
144 | 
145 |     state parse_ipv4 {
146 |         b.extract(p.ip);
147 |         transition select(p.ip.protocol) {
148 |             TCP_TYPE: parse_tcp;
149 |             default: accept;
150 |         }
151 |     }
152 | 
153 |     state parse_ipv6 {
154 |         b.extract(p.ip6);
155 |         transition select(p.ip6.nxt) {
156 |             TCP_TYPE: parse_tcp;
157 |             default: accept;
158 |         }
159 |     }
160 | 
161 |     state parse_tcp {
162 |         b.extract(p.tcp);
163 |         transition accept;
164 |     }
165 | }
166 | 
167 | 
168 | // match-action pipeline
169 | control TopPipe(inout Parsed_packet p,
170 |                 inout user_metadata_t user_metadata, 
171 |                 inout digest_data_t digest_data,
172 |                 inout sume_metadata_t sume_metadata) {
173 | 
174 | 
175 |     action set_output_port(port_t port) {
176 |         sume_metadata.dst_port = port;
177 |     }
178 | 
179 |     
180 |     action set_default_port (){
181 |         sume_metadata.dst_port = 0x1;
182 |     }
183 | 
184 |  
185 |     action set_hp1_code(bit<1> code){
186 |         digest_data.vhp01 = code;
187 |     }
188 |     
189 |     action set_hp2_code(bit<1> code){
190 |         digest_data.vhp02 = code;
191 |     }
192 |     action set_hp3_code(bit<1> code){
193 |         digest_data.vhp03 = code;
194 |     }
195 |     action set_hp4_code(bit<1> code){
196 |         digest_data.vhp04 = code;
197 |     }
198 |     action set_hp5_code(bit<1> code){
199 |         digest_data.vhp12 = code;
200 |     }
201 |     action set_hp6_code(bit<1> code){
202 |         digest_data.vhp13 = code;
203 |     }
204 |     action set_hp7_code(bit<1> code){
205 |         digest_data.vhp14 = code;
206 |     }
207 |     action set_hp8_code(bit<1> code){
208 |         digest_data.vhp23 = code;
209 |     }
210 |     action set_hp9_code(bit<1> code){
211 |        digest_data.vhp24 = code;
212 |     }
213 |     action set_hp10_code(bit<1> code){
214 |         digest_data.vhp34 = code;
215 |     }
216 | 
217 | 
218 | 
219 | // Calculate hyperplane 1
220 |     table hp1 {
221 |         key = {  user_metadata.pkt_len_code++user_metadata.ip_proto_code++user_metadata.ip_flags_code++user_metadata.tcp_srcport_code++user_metadata.tcp_dstport_code:ternary @name("code"); }
222 | 
223 |          actions = {
224 |             set_hp1_code;
225 |             NoAction;
226 |         }
227 |         size = 63;
228 |         default_action = NoAction;
229 |     }
230 | 
231 | // Calculate hyperplane 2
232 |   table hp2 {
233 |         key = {  user_metadata.pkt_len_code++user_metadata.ip_proto_code++user_metadata.ip_flags_code++user_metadata.tcp_srcport_code++user_metadata.tcp_dstport_code:ternary @name("code"); }
234 | 
235 |          actions = {
236 |             set_hp2_code;
237 |             NoAction;
238 |         }
239 |         size = 63;
240 |         default_action = NoAction;
241 |     }
242 | 
243 | // Calculate hyperplane 3
244 |   table hp3 {
245 |         key = {  user_metadata.pkt_len_code++user_metadata.ip_proto_code++user_metadata.ip_flags_code++user_metadata.tcp_srcport_code++user_metadata.tcp_dstport_code:ternary @name("code"); }
246 | 
247 |          actions = {
248 |             set_hp3_code;
249 |             NoAction;
250 |         }
251 |         size = 63;
252 |         default_action = NoAction;
253 |     }
254 | 
255 | // Calculate hyperplane 4
256 |   table hp4 {
257 |         key = {  user_metadata.pkt_len_code++user_metadata.ip_proto_code++user_metadata.ip_flags_code++user_metadata.tcp_srcport_code++user_metadata.tcp_dstport_code:ternary @name("code"); }
258 | 
259 |          actions = {
260 |             set_hp4_code;
261 |             NoAction;
262 |         }
263 |         size = 63;
264 |         default_action = NoAction;
265 |     }
266 | 
267 | 
268 | // Calculate hyperplane 5
269 |   table hp5 {
270 |         key = {  user_metadata.pkt_len_code++user_metadata.ip_proto_code++user_metadata.ip_flags_code++user_metadata.tcp_srcport_code++user_metadata.tcp_dstport_code:ternary @name("code"); }
271 | 
272 |          actions = {
273 |             set_hp5_code;
274 |             NoAction;
275 |         }
276 |         size = 63;
277 |         default_action = NoAction;
278 |     }
279 | 
280 | // Calculate hyperplane 6
281 |   table hp6 {
282 |         key = {  user_metadata.pkt_len_code++user_metadata.ip_proto_code++user_metadata.ip_flags_code++user_metadata.tcp_srcport_code++user_metadata.tcp_dstport_code:ternary @name("code"); }
283 | 
284 |          actions = {
285 |             set_hp6_code;
286 |             NoAction;
287 |         }
288 |         size = 63;
289 |         default_action = NoAction;
290 |     }
291 | 
292 | // Calculate hyperplane 7
293 |   table hp7 {
294 |         key = {  user_metadata.pkt_len_code++user_metadata.ip_proto_code++user_metadata.ip_flags_code++user_metadata.tcp_srcport_code++user_metadata.tcp_dstport_code:ternary @name("code"); }
295 | 
296 |          actions = {
297 |             set_hp7_code;
298 |             NoAction;
299 |         }
300 |         size = 63;
301 |         default_action = NoAction;
302 |     }
303 | 
304 | // Calculate hyperplane 8
305 |   table hp8 {
306 |         key = {  user_metadata.pkt_len_code++user_metadata.ip_proto_code++user_metadata.ip_flags_code++user_metadata.tcp_srcport_code++user_metadata.tcp_dstport_code:ternary @name("code"); }
307 | 
308 |          actions = {
309 |             set_hp8_code;
310 |             NoAction;
311 |         }
312 |         size = 63;
313 |         default_action = NoAction;
314 |     }
315 | 
316 | // Calculate hyperplane 9
317 |   table hp9 {
318 |         key = {  user_metadata.pkt_len_code++user_metadata.ip_proto_code++user_metadata.ip_flags_code++user_metadata.tcp_srcport_code++user_metadata.tcp_dstport_code:ternary @name("code"); }
319 | 
320 |          actions = {
321 |             set_hp9_code;
322 |             NoAction;
323 |         }
324 |         size = 63;
325 |         default_action = NoAction;
326 |     }
327 | 
328 | // Calculate hyperplane 10
329 |   table hp10 {
330 |         key = {  user_metadata.pkt_len_code++user_metadata.ip_proto_code++user_metadata.ip_flags_code++user_metadata.tcp_srcport_code++user_metadata.tcp_dstport_code:ternary @name("code"); }
331 | 
332 |          actions = {
333 |             set_hp10_code;
334 |             NoAction;
335 |         }
336 |         size = 63;
337 |         default_action = NoAction;
338 |     }
339 | 
340 | // Lookup classification by votes
341 |      table lookup_code {
342 |         key = { digest_data.vhp01++digest_data.vhp02++digest_data.vhp03++digest_data.vhp04++digest_data.vhp12++digest_data.vhp13++digest_data.vhp14++digest_data.vhp23++digest_data.vhp24++digest_data.vhp34:exact @name("votes"); }
343 | 
344 |         actions = {
345 |             set_output_port;
346 |             set_default_port;
347 |         }
348 |         size = 1024;
349 |         default_action = set_default_port;
350 |     }
351 | 
352 | 
353 |     apply {
354 | 
355 |         user_metadata.pkt_len_code=0;
356 |         user_metadata.ip_proto_code=0;
357 |         user_metadata.ip_flags_code=0;
358 |         user_metadata.tcp_srcport_code=0;
359 |         user_metadata.tcp_dstport_code=0;
360 |        
361 |         hp1.apply();
362 |         hp2.apply(); 
363 |         hp3.apply();
364 |         hp4.apply();
365 |         hp5.apply();
366 |         hp6.apply();
367 |         hp7.apply();
368 |         hp8.apply();
369 |         hp9.apply();
370 |         hp10.apply();
371 | 
372 |         if (!lookup_code.apply().hit) {
373 |             sume_metadata.drop = 1;
374 |         }
375 |       }
376 | }
377 | 
378 | // Deparser Implementation
379 | @Xilinx_MaxPacketRegion(1024)
380 | control TopDeparser(packet_out b,
381 |                     in Parsed_packet p,
382 |                     in user_metadata_t user_metadata,
383 |                     inout digest_data_t digest_data,
384 |                     inout sume_metadata_t sume_metadata) { 
385 |     apply {
386 |         b.emit(p.ethernet); 
387 |         b.emit(p.ip);
388 |         b.emit(p.ip6);
389 | 	b.emit(p.tcp);
390 |     }
391 | }
392 | 
393 | 
394 | // Instantiate the switch
395 | SimpleSumeSwitch(TopParser(), TopPipe(), TopDeparser()) main;
396 | 
397 | 


--------------------------------------------------------------------------------
/iisy_sw/simple_example/decision_tree/mycontroller.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python2
  2 | #################################################################################
  3 | #
  4 | # Copyright (c) 2019 Zhaoqi Xiong
  5 | # All rights reserved.
  6 | #
  7 | #
  8 | # @NETFPGA_LICENSE_HEADER_START@
  9 | #
 10 | # Licensed to NetFPGA C.I.C. (NetFPGA) under one or more contributor
 11 | # license agreements.  See the NOTICE file distributed with this work for
 12 | # additional information regarding copyright ownership.  NetFPGA licenses this
 13 | # file to you under the NetFPGA Hardware-Software License, Version 1.0 (the
 14 | # "License"); you may not use this file except in compliance with the
 15 | # License.  You may obtain a copy of the License at:
 16 | #
 17 | #   http://www.netfpga-cic.org
 18 | #
 19 | # Unless required by applicable law or agreed to in writing, Work distributed
 20 | # under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
 21 | # CONDITIONS OF ANY KIND, either express or implied.  See the License for the
 22 | # specific language governing permissions and limitations under the License.
 23 | #
 24 | # @NETFPGA_LICENSE_HEADER_END@
 25 | #
 26 | #################################################################################   
 27 | 
 28 | import argparse
 29 | import os
 30 | import json
 31 | import re
 32 | import sys
 33 | from time import sleep
 34 | import grpc
 35 | import time
 36 | 
 37 | inputfile = './tree.txt'
 38 | actionfile = './action.txt'
 39 | 
 40 | # Import P4Runtime lib from parent utils dir
 41 | # Probably there's a better way of doing this.
 42 | sys.path.append(
 43 |     os.path.join(os.path.dirname(os.path.abspath(__file__)),
 44 |                  '../../utils/'))
 45 | import p4runtime_lib.bmv2
 46 | from p4runtime_lib.switch import ShutdownAllSwitchConnections
 47 | import p4runtime_lib.helper
 48 | 
 49 | 
 50 | def find_action(textfile):
 51 |     action = []
 52 |     f = open(textfile)
 53 |     for line in f:
 54 |         n = re.findall(r"class", line)
 55 |         if n:
 56 |             fea = re.findall(r"\d", line)
 57 |             action.append(int(fea[1]))
 58 |     f.close()
 59 |     return action
 60 | 
 61 | 
 62 | def find_feature(textfile):
 63 |     f = open(textfile)
 64 |     line = f.readline()
 65 |     proto = re.findall('\d+', line)
 66 |     line = f.readline()
 67 |     src = re.findall('\d+', line)
 68 |     line = f.readline()
 69 |     dst = re.findall('\d+', line)
 70 |     f.close
 71 |     proto = [int(i) for i in proto]
 72 |     src = [int(i) for i in src]
 73 |     dst = [int(i) for i in dst]
 74 |     return proto, src, dst
 75 | 
 76 | def find_classification(textfile, proto, src, dst):
 77 |     fea = []
 78 |     sign = []
 79 |     num = []
 80 |     f = open(textfile, 'r')
 81 |     for line in f:
 82 |         n = re.findall(r"when", line)
 83 |         if n:
 84 |             fea.append(re.findall(r"(proto|src|dst)", line))
 85 |             sign.append(re.findall(r"(<=|>)", line))
 86 |             num.append(re.findall(r"\d+\.?\d*", line))
 87 |     f.close()
 88 | 
 89 |     protocol = []
 90 |     srouce = []
 91 |     dstination = []
 92 |     classfication = []
 93 | 
 94 |     for i in range(len(fea)):
 95 |         feature1 = [k for k in range(len(proto) + 1)]
 96 |         feature2 = [k for k in range(len(src) + 1)]
 97 |         feature3 = [k for k in range(len(dst) + 1)]
 98 |         for j, feature in enumerate(fea[i]):
 99 |             if feature == 'proto':
100 |                 sig = sign[i][j]
101 |                 thres = int(float(num[i][j]))
102 |                 id = proto.index(thres)
103 |                 if sig == '<=':
104 |                     while id < len(proto):
105 |                         if id + 1 in feature1:
106 |                             feature1.remove(id + 1)
107 |                         id = id + 1
108 |                 else:
109 |                     while id >= 0:
110 |                         if id in feature1:
111 |                             feature1.remove(id)
112 |                         id = id - 1
113 |             elif feature == 'src':
114 |                 sig = sign[i][j]
115 |                 thres = int(float(num[i][j]))
116 |                 id = src.index(thres)
117 |                 if sig == '<=':
118 |                     while id < len(src):
119 |                         if id + 1 in feature2:
120 |                             feature2.remove(id + 1)
121 |                         id = id + 1
122 |                 else:
123 |                     while id >= 0:
124 |                         if id in feature2:
125 |                             feature2.remove(id)
126 |                         id = id - 1
127 |             else:
128 |                 sig = sign[i][j]
129 |                 thres = int(float(num[i][j]))
130 |                 id = dst.index(thres)
131 |                 if sig == '<=':
132 |                     while id < len(dst):
133 |                         if id + 1 in feature3:
134 |                             feature3.remove(id + 1)
135 |                         id = id + 1
136 |                 else:
137 |                     while id >= 0:
138 |                         if id in feature3:
139 |                             feature3.remove(id)
140 |                         id = id - 1
141 |         protocol.append(feature1)
142 |         srouce.append(feature2)
143 |         dstination.append(feature3)
144 |         a = len(num[i])
145 |         classfication.append(num[i][a - 1])
146 |     return (protocol, srouce, dstination, classfication)
147 | 
148 | def get_actionpara(action):
149 |     para = {}
150 |     if action == 0:
151 |         para = {}
152 |     elif action == 2:
153 |         para = {"dstAddr": "00:00:00:02:02:00", "port": 2}
154 |     elif action == 3:
155 |         para = {"dstAddr": "00:00:00:03:03:00", "port": 3}
156 |     elif action == 4:
157 |         para = {"dstAddr": "00:00:00:04:04:00", "port": 4}
158 | 
159 |     return para
160 | 
161 | 
162 | def writeactionrule(p4info_helper, switch, a, b, c, action, port):
163 |     para = get_actionpara(port)
164 |     table_entry = p4info_helper.buildTableEntry(
165 |         table_name="MyIngress.ipv4_exact",
166 |         match_fields={"meta.action_select1": a,
167 |                       "meta.action_select2": b,
168 |                       "meta.action_select3": c
169 | 
170 |                       },
171 |         action_name=action,
172 |         action_params=para
173 |     )
174 |     switch.WriteTableEntry(table_entry)
175 |     print("Installed action rule on %s" % switch.name)
176 | 
177 | 
178 | def writefeature1rule(p4info_helper, switch, range, ind):
179 |     table_entry = p4info_helper.buildTableEntry(
180 |         table_name="MyIngress.feature1_exact",
181 |         match_fields={
182 |             "hdr.ipv4.protocol": range},
183 |         action_name="MyIngress.set_actionselect1",
184 |         action_params={
185 |             "featurevalue1": ind,
186 |         })
187 |     switch.WriteTableEntry(table_entry)
188 |     print("Installed feature1 rule on %s" % switch.name)
189 | 
190 | 
191 | def writefeature2rule(p4info_helper, switch, range, ind):
192 |     table_entry = p4info_helper.buildTableEntry(
193 |         table_name="MyIngress.feature2_exact",
194 |         match_fields={
195 |             "hdr.tcp.srcPort": range},
196 |         action_name="MyIngress.set_actionselect2",
197 |         action_params={
198 |             "featurevalue2": ind,
199 |         })
200 |     switch.WriteTableEntry(table_entry)
201 |     print("Installed feature2 rule on %s" % switch.name)
202 | 
203 | 
204 | def writefeature3rule(p4info_helper, switch, range, ind):
205 |     table_entry = p4info_helper.buildTableEntry(
206 |         table_name="MyIngress.feature3_exact",
207 |         match_fields={
208 |             "hdr.tcp.dstPort": range},
209 |         action_name="MyIngress.set_actionselect3",
210 |         action_params={
211 |             "featurevalue3": ind,
212 |         })
213 |     switch.WriteTableEntry(table_entry)
214 |     print("Installed feature3 rule on %s" % switch.name)
215 | 
216 | 
217 | proto, src, dst = find_feature(inputfile)
218 | protocol, srouce, dstination, classfication = find_classification(inputfile, proto, src, dst)
219 | action = find_action(actionfile)
220 | 
221 | 
222 | def printGrpcError(e):
223 |     print("gRPC Error:", e.details(), )
224 |     status_code = e.code()
225 |     print("(%s)" % status_code.name, )
226 |     traceback = sys.exc_info()[2]
227 |     print("[%s:%d]" % (traceback.tb_frame.f_code.co_filename, traceback.tb_lineno))
228 | 
229 | 
230 | def main(p4info_file_path, bmv2_file_path):
231 |     p4info_helper = p4runtime_lib.helper.P4InfoHelper(p4info_file_path)
232 | 
233 |     try:
234 | 
235 |         s1 = p4runtime_lib.bmv2.Bmv2SwitchConnection(
236 |             name='s1',
237 |             address='127.0.0.1:50051',
238 |             device_id=0,
239 |             proto_dump_file='logs/s1-p4runtime-requests.txt')
240 | 
241 |         s1.MasterArbitrationUpdate()
242 | 
243 |         s1.SetForwardingPipelineConfig(p4info=p4info_helper.p4info,
244 |                                        bmv2_json_file_path=bmv2_file_path)
245 |         print("Installed P4 Program using SetForwardingPipelineConfig on s1")
246 | 
247 |         for i in range(len(classfication)):
248 |             a = protocol[i]
249 |             id = len(a) - 1
250 |             del a[1:id]
251 |             if (len(a) == 1):
252 |                 a.append(a[0])
253 |             b = srouce[i]
254 |             id = len(b) - 1
255 |             del b[1:id]
256 |             if (len(b) == 1):
257 |                 b.append(b[0])
258 |             c = dstination[i]
259 |             id = len(c) - 1
260 |             del c[1:id]
261 |             if (len(c) == 1):
262 |                 c.append(c[0])
263 | 
264 |             ind = int(classfication[i])
265 |             ac = action[ind]
266 |             a = [i + 1 for i in a]
267 |             b = [i + 1 for i in b]
268 |             c = [i + 1 for i in c]
269 | 
270 |             if ac == 0:
271 |                 writeactionrule(p4info_helper, s1, a, b, c, "MyIngress.drop", 0)
272 |             else:
273 |                 writeactionrule(p4info_helper, s1, a, b, c, "MyIngress.ipv4_forward", ac)
274 |    
275 | 
276 |  
277 |         if len(proto) != 0:
278 |             proto.append(0)
279 |             proto.append(32)
280 |             proto.sort()
281 |             for i in range(len(proto) - 1):
282 |                 writefeature1rule(p4info_helper, s1, proto[i:i + 2], i + 1)
283 |         else:
284 |             writefeature1rule(p4info_helper, s1, [0, 32], 1)
285 | 
286 |         if len(src) != 0:
287 |             src.append(0)
288 |             src.append(65535)
289 |             src.sort()
290 |             for i in range(len(src) - 1):
291 |                 writefeature2rule(p4info_helper, s1, src[i:i + 2], i + 1)
292 |         if len(dst) != 0:
293 |             dst.append(0)
294 |             dst.append(65535)
295 |             dst.sort()
296 |             for i in range(len(dst) - 1):
297 |                 writefeature3rule(p4info_helper, s1, dst[i:i + 2], i + 1)
298 | 
299 |     except KeyboardInterrupt:
300 |         print("Shutting down.")
301 |     except grpc.RpcError as e:
302 |         printGrpcError(e)
303 | 
304 |     ShutdownAllSwitchConnections()
305 | 
306 | 
307 | if __name__ == '__main__':
308 |     parser = argparse.ArgumentParser(description='P4Runtime Controller')
309 |     parser.add_argument('--p4info', help='p4info proto in text format from p4c',
310 |                         type=str, action="store", required=False,
311 |                         default='./build/advanced.p4info')
312 | 
313 |     parser.add_argument('--bmv2-json', help='BMv2 JSON file from p4c',
314 |                         type=str, action="store", required=False,
315 |                         default='./build/advanced.json')
316 | 
317 |     args = parser.parse_args()
318 | 
319 |     if not os.path.exists(args.p4info):
320 |         parser.print_help()
321 |         print("\np4info file not found: %s\nHave you run 'make'?" % args.p4info)
322 |         parser.exit(1)
323 | 
324 |     if not os.path.exists(args.bmv2_json):
325 |         parser.print_help()
326 |         print("\nBMv2 JSON file not found: %s\nHave you run 'make'?" % args.bmv2_json)
327 |         parser.exit(1)
328 |    
329 |     start = time.time()
330 |     main(args.p4info, args.bmv2_json)
331 |     end = time.time()
332 |     print("time to load the tables:", end-start)


--------------------------------------------------------------------------------
/iisy_sw/framework/mycontroller.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python2
  2 | #################################################################################
  3 | #
  4 | # Copyright (c) 2019 Zhaoqi Xiong
  5 | # All rights reserved.
  6 | #
  7 | #
  8 | # @NETFPGA_LICENSE_HEADER_START@
  9 | #
 10 | # Licensed to NetFPGA C.I.C. (NetFPGA) under one or more contributor
 11 | # license agreements.  See the NOTICE file distributed with this work for
 12 | # additional information regarding copyright ownership.  NetFPGA licenses this
 13 | # file to you under the NetFPGA Hardware-Software License, Version 1.0 (the
 14 | # "License"); you may not use this file except in compliance with the
 15 | # License.  You may obtain a copy of the License at:
 16 | #
 17 | #   http://www.netfpga-cic.org
 18 | #
 19 | # Unless required by applicable law or agreed to in writing, Work distributed
 20 | # under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
 21 | # CONDITIONS OF ANY KIND, either express or implied.  See the License for the
 22 | # specific language governing permissions and limitations under the License.
 23 | #
 24 | # @NETFPGA_LICENSE_HEADER_END@
 25 | #
 26 | ################################################################################# 
 27 | 
 28 | import argparse
 29 | import os
 30 | import json
 31 | import re
 32 | import sys
 33 | from time import sleep
 34 | import grpc
 35 | 
 36 | inputfile = './tree.txt'
 37 | actionfile = './action.txt'
 38 | 
 39 | # Import P4Runtime lib from parent utils dir
 40 | # Probably there's a better way of doing this.
 41 | sys.path.append(
 42 |     os.path.join(os.path.dirname(os.path.abspath(__file__)),
 43 |                  '../../utils/'))
 44 | import p4runtime_lib.bmv2
 45 | from p4runtime_lib.switch import ShutdownAllSwitchConnections
 46 | import p4runtime_lib.helper
 47 | 
 48 | # read the action.text, find the actions for different classes.
 49 | def find_action(textfile):
 50 |     action = []
 51 |     f = open(textfile)
 52 |     for line in f:
 53 |         n = re.findall(r"class", line)
 54 |         if n:
 55 |             fea = re.findall(r"\d", line)
 56 |             action.append(int(fea[1]))
 57 |     f.close()
 58 |     return action
 59 | 
 60 | # read the tree model, search the threshold value
 61 | def find_feature(textfile):
 62 |     f = open(textfile)
 63 |     line = f.readline()
 64 |     proto = re.findall('\d+', line)
 65 |     line = f.readline()
 66 |     src = re.findall('\d+', line)
 67 |     line = f.readline()
 68 |     dst = re.findall('\d+', line)
 69 |     f.close
 70 |     proto = [int(i) for i in proto]
 71 |     src = [int(i) for i in src]
 72 |     dst = [int(i) for i in dst]
 73 |     return proto, src, dst
 74 | 
 75 | # read the leaf node description and find the corresponding ranges
 76 | def find_classification(textfile, proto, src, dst):
 77 |     fea = []
 78 |     sign = []
 79 |     num = []
 80 |     f = open(textfile, 'r')
 81 |     for line in f:
 82 |         n = re.findall(r"when", line)
 83 |         if n:
 84 |             fea.append(re.findall(r"(proto|src|dst)", line))
 85 |             sign.append(re.findall(r"(<=|>)", line))
 86 |             num.append(re.findall(r"\d+\.?\d*", line))
 87 |     f.close()
 88 | 
 89 |     protocol = []
 90 |     srouce = []
 91 |     dstination = []
 92 |     classfication = []
 93 | 
 94 |     for i in range(len(fea)):
 95 |         feature1 = [k for k in range(len(proto) + 1)]
 96 |         feature2 = [k for k in range(len(src) + 1)]
 97 |         feature3 = [k for k in range(len(dst) + 1)]
 98 |         for j, feature in enumerate(fea[i]):
 99 |             if feature == 'proto':
100 |                 sig = sign[i][j]
101 |                 thres = int(float(num[i][j]))
102 |                 id = proto.index(thres)
103 |                 if sig == '<=':
104 |                     while id < len(proto):
105 |                         if id + 1 in feature1:
106 |                             feature1.remove(id + 1)
107 |                         id = id + 1
108 |                 else:
109 |                     while id >= 0:
110 |                         if id in feature1:
111 |                             feature1.remove(id)
112 |                         id = id - 1
113 |             elif feature == 'src':
114 |                 sig = sign[i][j]
115 |                 thres = int(float(num[i][j]))
116 |                 id = src.index(thres)
117 |                 if sig == '<=':
118 |                     while id < len(src):
119 |                         if id + 1 in feature2:
120 |                             feature2.remove(id + 1)
121 |                         id = id + 1
122 |                 else:
123 |                     while id >= 0:
124 |                         if id in feature2:
125 |                             feature2.remove(id)
126 |                         id = id - 1
127 |             else:
128 |                 sig = sign[i][j]
129 |                 thres = int(float(num[i][j]))
130 |                 id = dst.index(thres)
131 |                 if sig == '<=':
132 |                     while id < len(dst):
133 |                         if id + 1 in feature3:
134 |                             feature3.remove(id + 1)
135 |                         id = id + 1
136 |                 else:
137 |                     while id >= 0:
138 |                         if id in feature3:
139 |                             feature3.remove(id)
140 |                         id = id - 1
141 |         protocol.append(feature1)
142 |         srouce.append(feature2)
143 |         dstination.append(feature3)
144 |         a = len(num[i])
145 |         classfication.append(num[i][a - 1])
146 |     return (protocol, srouce, dstination, classfication)
147 | 
148 | # get action parameters 
149 | def get_actionpara(action):
150 |     para = {}
151 |     if action == 0:
152 |         para = {}
153 |     elif action == 2:
154 |         para = {"dstAddr": "00:00:00:02:02:00", "port": 2}
155 |     elif action == 3:
156 |         para = {"dstAddr": "00:00:00:03:03:00", "port": 3}
157 |     elif action == 4:
158 |         para = {"dstAddr": "00:00:00:04:04:00", "port": 4}
159 | 
160 |     return para
161 | 
162 | 
163 | # add an entry to decision table
164 | def writeactionrule(p4info_helper, switch, a, b, c, action, port):
165 |     para = get_actionpara(port)
166 |     table_entry = p4info_helper.buildTableEntry(
167 |         table_name="MyIngress.ipv4_exact",
168 |         match_fields={"meta.action_select1": a,
169 |                       "meta.action_select2": b,
170 |                       "meta.action_select3": c
171 | 
172 |                       },
173 |         action_name=action,
174 |         action_params=para
175 |     )
176 |     switch.WriteTableEntry(table_entry)
177 |     print("Installed action rule on %s" % switch.name)
178 | 
179 | 
180 | # add an entry to feature 1 table
181 | def writefeature1rule(p4info_helper, switch, range, ind):
182 |     table_entry = p4info_helper.buildTableEntry(
183 |         table_name="MyIngress.feature1_exact",
184 |         match_fields={
185 |             "hdr.ipv4.protocol": range},
186 |         action_name="MyIngress.set_actionselect1",
187 |         action_params={
188 |             "featurevalue1": ind,
189 |         })
190 |     switch.WriteTableEntry(table_entry)
191 |     print("Installed feature1 rule on %s" % switch.name)
192 | 
193 | # add an entry to feature 2 table
194 | def writefeature2rule(p4info_helper, switch, range, ind):
195 |     table_entry = p4info_helper.buildTableEntry(
196 |         table_name="MyIngress.feature2_exact",
197 |         match_fields={
198 |             "hdr.tcp.srcPort": range},
199 |         action_name="MyIngress.set_actionselect2",
200 |         action_params={
201 |             "featurevalue2": ind,
202 |         })
203 |     switch.WriteTableEntry(table_entry)
204 |     print("Installed feature2 rule on %s" % switch.name)
205 | 
206 | # add an entry to feature 3 table
207 | def writefeature3rule(p4info_helper, switch, range, ind):
208 |     table_entry = p4info_helper.buildTableEntry(
209 |         table_name="MyIngress.feature3_exact",
210 |         match_fields={
211 |             "hdr.tcp.dstPort": range},
212 |         action_name="MyIngress.set_actionselect3",
213 |         action_params={
214 |             "featurevalue3": ind,
215 |         })
216 |     switch.WriteTableEntry(table_entry)
217 |     print("Installed feature3 rule on %s" % switch.name)
218 | 
219 | 
220 | proto, src, dst = find_feature(inputfile)
221 | protocol, srouce, dstination, classfication = find_classification(inputfile, proto, src, dst)
222 | action = find_action(actionfile)
223 | 
224 | 
225 | def printGrpcError(e):
226 |     print("gRPC Error:", e.details(), )
227 |     status_code = e.code()
228 |     print("(%s)" % status_code.name, )
229 |     traceback = sys.exc_info()[2]
230 |     print("[%s:%d]" % (traceback.tb_frame.f_code.co_filename, traceback.tb_lineno))
231 | 
232 | 
233 | 
234 | def main(p4info_file_path, bmv2_file_path):
235 |     p4info_helper = p4runtime_lib.helper.P4InfoHelper(p4info_file_path)
236 |     # load p4 runtime and define the switch
237 |     try:
238 | 
239 |         s1 = p4runtime_lib.bmv2.Bmv2SwitchConnection(
240 |             name='s1',
241 |             address='127.0.0.1:50051',
242 |             device_id=0,
243 |             proto_dump_file='logs/s1-p4runtime-requests.txt')
244 | 
245 |         s1.MasterArbitrationUpdate()
246 | 
247 |         s1.SetForwardingPipelineConfig(p4info=p4info_helper.p4info,
248 |                                        bmv2_json_file_path=bmv2_file_path)
249 |         print("Installed P4 Program using SetForwardingPipelineConfig on s1")
250 |         
251 | 
252 |         # find the entries for decision table
253 |         for i in range(len(classfication)):
254 |             a = protocol[i]
255 |             id = len(a) - 1
256 |             del a[1:id]
257 |             if (len(a) == 1):
258 |                 a.append(a[0])
259 |             b = srouce[i]
260 |             id = len(b) - 1
261 |             del b[1:id]
262 |             if (len(b) == 1):
263 |                 b.append(b[0])
264 |             c = dstination[i]
265 |             id = len(c) - 1
266 |             del c[1:id]
267 |             if (len(c) == 1):
268 |                 c.append(c[0])
269 | 
270 |             ind = int(classfication[i])
271 |             ac = action[ind]
272 |             a = [i + 1 for i in a]
273 |             b = [i + 1 for i in b]
274 |             c = [i + 1 for i in c]
275 | 
276 |             if ac == 0:
277 |                 writeactionrule(p4info_helper, s1, a, b, c, "MyIngress.drop", 0)
278 |             else:
279 |                 writeactionrule(p4info_helper, s1, a, b, c, "MyIngress.ipv4_forward", ac)
280 |         # find the entries for feature table 1 2 3
281 |         if len(proto) != 0:
282 |             proto.append(0)
283 |             proto.append(32)
284 |             proto.sort()
285 |             for i in range(len(proto) - 1):
286 |                 writefeature1rule(p4info_helper, s1, proto[i:i + 2], i + 1)
287 |         else:
288 |             writefeature1rule(p4info_helper, s1, [0, 32], 1)
289 | 
290 |         if len(src) != 0:
291 |             src.append(0)
292 |             src.append(65535)
293 |             src.sort()
294 |             for i in range(len(src) - 1):
295 |                 writefeature2rule(p4info_helper, s1, src[i:i + 2], i + 1)
296 |         if len(dst) != 0:
297 |             dst.append(0)
298 |             dst.append(65535)
299 |             dst.sort()
300 |             for i in range(len(dst) - 1):
301 |                 writefeature3rule(p4info_helper, s1, dst[i:i + 2], i + 1)
302 | 
303 |     except KeyboardInterrupt:
304 |         print("Shutting down.")
305 |     except grpc.RpcError as e:
306 |         printGrpcError(e)
307 | 
308 |     ShutdownAllSwitchConnections()
309 | 
310 | # main function
311 | if __name__ == '__main__':
312 |     parser = argparse.ArgumentParser(description='P4Runtime Controller')
313 |     parser.add_argument('--p4info', help='p4info proto in text format from p4c',
314 |                         type=str, action="store", required=False,
315 |                         default='./build/advanced.p4info')
316 | 
317 |     parser.add_argument('--bmv2-json', help='BMv2 JSON file from p4c',
318 |                         type=str, action="store", required=False,
319 |                         default='./build/advanced.json')
320 | 
321 |     args = parser.parse_args()
322 |     # error management
323 |     if not os.path.exists(args.p4info):
324 |         parser.print_help()
325 |         print("\np4info file not found: %s\nHave you run 'make'?" % args.p4info)
326 |         parser.exit(1)
327 | 
328 |     if not os.path.exists(args.bmv2_json):
329 |         parser.print_help()
330 |         print("\nBMv2 JSON file not found: %s\nHave you run 'make'?" % args.bmv2_json)
331 |         parser.exit(1)
332 | 
333 |     main(args.p4info, args.bmv2_json)
334 | 


--------------------------------------------------------------------------------
/iisy_hw/commands.txt:
--------------------------------------------------------------------------------
  1 | //
  2 | // Copyright (c) BLINDED
  3 | // All rights reserved.
  4 | //
  5 | // This software was developed by Stanford University and the University of Cambridge Computer Laboratory 
  6 | // under National Science Foundation under Grant No. CNS-0855268,
  7 | // the University of Cambridge Computer Laboratory under EPSRC INTERNET Project EP/H040536/1 and
  8 | // by the University of Cambridge Computer Laboratory under DARPA/AFRL contract FA8750-11-C-0249 ("MRC2"), 
  9 | // as part of the DARPA MRC research programme.
 10 | //
 11 | // @NETFPGA_LICENSE_HEADER_START@
 12 | //
 13 | // Licensed to NetFPGA C.I.C. (NetFPGA) under one or more contributor
 14 | // license agreements.  See the NOTICE file distributed with this work for
 15 | // additional information regarding copyright ownership.  NetFPGA licenses this
 16 | // file to you under the NetFPGA Hardware-Software License, Version 1.0 (the
 17 | // "License"); you may not use this file except in compliance with the
 18 | // License.  You may obtain a copy of the License at:
 19 | //
 20 | //   http://www.netfpga-cic.org
 21 | //
 22 | // Unless required by applicable law or agreed to in writing, Work distributed
 23 | // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
 24 | // CONDITIONS OF ANY KIND, either express or implied.  See the License for the
 25 | // specific language governing permissions and limitations under the License.
 26 | //
 27 | // @NETFPGA_LICENSE_HEADER_END@
 28 | //
 29 | 
 30 | 
 31 | #note: else must be mapped to zero
 32 | 
 33 | #Frame Length
 34 | #155
 35 | table_tcam_add_entry lookup_len 0x0 set_len_code 0b10011010/32 => 0x00000001
 36 | table_tcam_add_entry lookup_len 0x1 set_len_code 0b10011000/31 => 0x00000001
 37 | table_tcam_add_entry lookup_len 0x2 set_len_code 0b10010000/29 => 0x00000001
 38 | table_tcam_add_entry lookup_len 0x3 set_len_code 0b10000000/28 => 0x00000001
 39 | table_tcam_add_entry lookup_len 0x4 set_len_code 0b00000000/25 => 0x00000001
 40 | table_tcam_add_entry lookup_len 0x5 set_len_code 0b10011011/32 => 0x00000001
 41 | #190
 42 | table_tcam_add_entry lookup_len 0x6 set_len_code 0b10111100/31 => 0x00000002
 43 | table_tcam_add_entry lookup_len 0x7 set_len_code 0b10111000/30 => 0x00000002
 44 | table_tcam_add_entry lookup_len 0x8 set_len_code 0b10110000/29 => 0x00000002
 45 | table_tcam_add_entry lookup_len 0x9 set_len_code 0b10100000/28 => 0x00000002
 46 | table_tcam_add_entry lookup_len 0xa set_len_code 0b10000000/27 => 0x00000002
 47 | table_tcam_add_entry lookup_len 0xb set_len_code 0b10111110/31 => 0x00000002
 48 | #380
 49 | table_tcam_add_entry lookup_len 0xc set_len_code 0b101111000/30 => 0x00000003
 50 | table_tcam_add_entry lookup_len 0xd set_len_code 0b101110000/29 => 0x00000003
 51 | table_tcam_add_entry lookup_len 0xe set_len_code 0b101100000/28 => 0x00000003
 52 | table_tcam_add_entry lookup_len 0xf set_len_code 0b101000000/27 => 0x00000003
 53 | table_tcam_add_entry lookup_len 0x10 set_len_code 0b100000000/26 => 0x00000003
 54 | table_tcam_add_entry lookup_len 0x11 set_len_code 0b000000000/24 => 0x00000003
 55 | table_tcam_add_entry lookup_len 0x12 set_len_code 0b101111100/30 => 0x00000003
 56 | #541
 57 | table_tcam_add_entry lookup_len 0x13 set_len_code 0b1000011100/32 => 0x00000004
 58 | table_tcam_add_entry lookup_len 0x14 set_len_code 0b1000011000/30 => 0x00000004
 59 | table_tcam_add_entry lookup_len 0x15 set_len_code 0b1000010000/29 => 0x00000004
 60 | table_tcam_add_entry lookup_len 0x16 set_len_code 0b1000000000/28 => 0x00000004
 61 | table_tcam_add_entry lookup_len 0x17 set_len_code 0b0000000000/23 => 0x00000004
 62 | table_tcam_add_entry lookup_len 0x18 set_len_code 0b1000011101/32 => 0x00000004
 63 | 
 64 | 
 65 | #IP Protocol
 66 | #11
 67 | table_tcam_add_entry lookup_ip_proto 0x0 set_ip_proto_code 0b1010/32 => 0x00000001
 68 | table_tcam_add_entry lookup_ip_proto 0x1 set_ip_proto_code 0b1000/31 => 0x00000001
 69 | table_tcam_add_entry lookup_ip_proto 0x2 set_ip_proto_code 0b0000/29 => 0x00000001
 70 | table_tcam_add_entry lookup_ip_proto 0x3 set_ip_proto_code 0b1011/32 => 0x00000001
 71 | 
 72 | #IP flags
 73 | #1
 74 | table_tcam_add_entry lookup_ip_flags 0x0 set_ip_flags_code 0b0/32 => 0x00000001
 75 | table_tcam_add_entry lookup_ip_flags 0x1 set_ip_flags_code 0b1/32 => 0x00000001
 76 | 
 77 | #TCP Src Port
 78 | #2503
 79 | table_tcam_add_entry lookup_tcp_srcport 0x0 set_tcp_srcport_code 0b100111000110/32 => 0x00000001
 80 | table_tcam_add_entry lookup_tcp_srcport 0x1 set_tcp_srcport_code 0b100111000100/31 => 0x00000001
 81 | table_tcam_add_entry lookup_tcp_srcport 0x2 set_tcp_srcport_code 0b100111000000/30 => 0x00000001
 82 | table_tcam_add_entry lookup_tcp_srcport 0x3 set_tcp_srcport_code 0b100110000000/26 => 0x00000001
 83 | table_tcam_add_entry lookup_tcp_srcport 0x4 set_tcp_srcport_code 0b100100000000/25 => 0x00000001
 84 | table_tcam_add_entry lookup_tcp_srcport 0x5 set_tcp_srcport_code 0b100000000000/24 => 0x00000001
 85 | table_tcam_add_entry lookup_tcp_srcport 0x6 set_tcp_srcport_code 0b000000000000/21 => 0x00000001
 86 | table_tcam_add_entry lookup_tcp_srcport 0x7 set_tcp_srcport_code 0b100111000111/32 => 0x00000001
 87 | #5110
 88 | table_tcam_add_entry lookup_tcp_srcport 0x8 set_tcp_srcport_code 0b1001111110100/31 => 0x00000002
 89 | table_tcam_add_entry lookup_tcp_srcport 0x9 set_tcp_srcport_code 0b1001111110000/30 => 0x00000002
 90 | table_tcam_add_entry lookup_tcp_srcport 0xa set_tcp_srcport_code 0b1001111100000/28 => 0x00000002
 91 | table_tcam_add_entry lookup_tcp_srcport 0xb set_tcp_srcport_code 0b1001111000000/27 => 0x00000002
 92 | table_tcam_add_entry lookup_tcp_srcport 0xc set_tcp_srcport_code 0b1001110000000/26 => 0x00000002
 93 | table_tcam_add_entry lookup_tcp_srcport 0xd set_tcp_srcport_code 0b1001100000000/25 => 0x00000002
 94 | table_tcam_add_entry lookup_tcp_srcport 0xe set_tcp_srcport_code 0b1001000000000/24 => 0x00000002
 95 | table_tcam_add_entry lookup_tcp_srcport 0xf set_tcp_srcport_code 0b1000000000000/23 => 0x00000002
 96 | table_tcam_add_entry lookup_tcp_srcport 0x10 set_tcp_srcport_code 0b0000000000000/20 => 0x00000002
 97 | table_tcam_add_entry lookup_tcp_srcport 0x11 set_tcp_srcport_code 0b1001111110110/31 => 0x00000002
 98 | #38144
 99 | table_tcam_add_entry lookup_tcp_srcport 0x12 set_tcp_srcport_code 0b1001010000000000/24 => 0x00000003
100 | table_tcam_add_entry lookup_tcp_srcport 0x13 set_tcp_srcport_code 0b1001000000000000/22 => 0x00000003
101 | table_tcam_add_entry lookup_tcp_srcport 0x14 set_tcp_srcport_code 0b1000000000000000/20 => 0x00000003
102 | table_tcam_add_entry lookup_tcp_srcport 0x15 set_tcp_srcport_code 0b0000000000000000/17 => 0x00000003
103 | table_tcam_add_entry lookup_tcp_srcport 0x16 set_tcp_srcport_code 0b1001010100000000/24 => 0x00000003
104 | #49152
105 | table_tcam_add_entry lookup_tcp_srcport 0x17 set_tcp_srcport_code 0b1000000000000000/18 => 0x00000004
106 | table_tcam_add_entry lookup_tcp_srcport 0x18 set_tcp_srcport_code 0b1100000000000000/18 => 0x00000004
107 | #51385
108 | table_tcam_add_entry lookup_tcp_srcport 0x19 set_tcp_srcport_code 0b1100100010111000/32 => 0x00000005
109 | table_tcam_add_entry lookup_tcp_srcport 0x1a set_tcp_srcport_code 0b1100100010110000/29 => 0x00000005
110 | table_tcam_add_entry lookup_tcp_srcport 0x1b set_tcp_srcport_code 0b1100100010100000/28 => 0x00000005
111 | table_tcam_add_entry lookup_tcp_srcport 0x1c set_tcp_srcport_code 0b1100100010000000/27 => 0x00000005
112 | table_tcam_add_entry lookup_tcp_srcport 0x1d set_tcp_srcport_code 0b1100100000000000/25 => 0x00000005
113 | table_tcam_add_entry lookup_tcp_srcport 0x1e set_tcp_srcport_code 0b1100000000000000/21 => 0x00000005
114 | table_tcam_add_entry lookup_tcp_srcport 0x1f set_tcp_srcport_code 0b1000000000000000/18 => 0x00000005
115 | table_tcam_add_entry lookup_tcp_srcport 0x20 set_tcp_srcport_code 0b1100100010111001/32 => 0x00000005
116 | #52420
117 | table_tcam_add_entry lookup_tcp_srcport 0x21 set_tcp_srcport_code 0b1100110011000000/30 => 0x00000006
118 | table_tcam_add_entry lookup_tcp_srcport 0x22 set_tcp_srcport_code 0b1100110010000000/26 => 0x00000006
119 | table_tcam_add_entry lookup_tcp_srcport 0x23 set_tcp_srcport_code 0b1100110000000000/25 => 0x00000006
120 | table_tcam_add_entry lookup_tcp_srcport 0x24 set_tcp_srcport_code 0b1100100000000000/22 => 0x00000006
121 | table_tcam_add_entry lookup_tcp_srcport 0x25 set_tcp_srcport_code 0b1100000000000000/21 => 0x00000006
122 | table_tcam_add_entry lookup_tcp_srcport 0x26 set_tcp_srcport_code 0b1000000000000000/18 => 0x00000006
123 | table_tcam_add_entry lookup_tcp_srcport 0x27 set_tcp_srcport_code 0b1100110011000100/30 => 0x00000006
124 | 
125 | #TCP Dst Port
126 | #261
127 | table_tcam_add_entry lookup_tcp_dstport 0x0 set_tcp_dstport_code 0b100000100/32 => 0x00000001
128 | table_tcam_add_entry lookup_tcp_dstport 0x1 set_tcp_dstport_code 0b100000000/30 => 0x00000001
129 | table_tcam_add_entry lookup_tcp_dstport 0x2 set_tcp_dstport_code 0b000000000/24 => 0x00000001
130 | table_tcam_add_entry lookup_tcp_dstport 0x3 set_tcp_dstport_code 0b100000101/32 => 0x00000001
131 | #454
132 | table_tcam_add_entry lookup_tcp_dstport 0x4 set_tcp_dstport_code 0b111000100/31 => 0x00000002
133 | table_tcam_add_entry lookup_tcp_dstport 0x5 set_tcp_dstport_code 0b111000000/30 => 0x00000002
134 | table_tcam_add_entry lookup_tcp_dstport 0x6 set_tcp_dstport_code 0b110000000/26 => 0x00000002
135 | table_tcam_add_entry lookup_tcp_dstport 0x7 set_tcp_dstport_code 0b100000000/25 => 0x00000002
136 | table_tcam_add_entry lookup_tcp_dstport 0x8 set_tcp_dstport_code 0b000000000/24 => 0x00000002
137 | table_tcam_add_entry lookup_tcp_dstport 0x9 set_tcp_dstport_code 0b111000110/31 => 0x00000002
138 | #718
139 | table_tcam_add_entry lookup_tcp_dstport 0xa set_tcp_dstport_code 0b1011001100/31 => 0x00000003
140 | table_tcam_add_entry lookup_tcp_dstport 0xb set_tcp_dstport_code 0b1011001000/30 => 0x00000003
141 | table_tcam_add_entry lookup_tcp_dstport 0xc set_tcp_dstport_code 0b1011000000/29 => 0x00000003
142 | table_tcam_add_entry lookup_tcp_dstport 0xd set_tcp_dstport_code 0b1010000000/26 => 0x00000003
143 | table_tcam_add_entry lookup_tcp_dstport 0xe set_tcp_dstport_code 0b1000000000/25 => 0x00000003
144 | table_tcam_add_entry lookup_tcp_dstport 0xf set_tcp_dstport_code 0b0000000000/23 => 0x00000003
145 | table_tcam_add_entry lookup_tcp_dstport 0x10 set_tcp_dstport_code 0b1011001110/31 => 0x00000003
146 | #729
147 | table_tcam_add_entry lookup_tcp_dstport 0x11 set_tcp_dstport_code 0b1011011000/32 => 0x00000004
148 | table_tcam_add_entry lookup_tcp_dstport 0x12 set_tcp_dstport_code 0b1011010000/29 => 0x00000004
149 | table_tcam_add_entry lookup_tcp_dstport 0x13 set_tcp_dstport_code 0b1011000000/28 => 0x00000004
150 | table_tcam_add_entry lookup_tcp_dstport 0x14 set_tcp_dstport_code 0b1010000000/26 => 0x00000004
151 | table_tcam_add_entry lookup_tcp_dstport 0x15 set_tcp_dstport_code 0b1000000000/25 => 0x00000004
152 | table_tcam_add_entry lookup_tcp_dstport 0x16 set_tcp_dstport_code 0b1011011001/32 => 0x00000004
153 | #2503
154 | table_tcam_add_entry lookup_tcp_dstport 0x17 set_tcp_dstport_code 0b100111000110/32 => 0x00000005
155 | table_tcam_add_entry lookup_tcp_dstport 0x18 set_tcp_dstport_code 0b100111000100/31 => 0x00000005
156 | table_tcam_add_entry lookup_tcp_dstport 0x19 set_tcp_dstport_code 0b100111000000/30 => 0x00000005
157 | table_tcam_add_entry lookup_tcp_dstport 0x1a set_tcp_dstport_code 0b100110000000/26 => 0x00000005
158 | table_tcam_add_entry lookup_tcp_dstport 0x1b set_tcp_dstport_code 0b100100000000/25 => 0x00000005
159 | table_tcam_add_entry lookup_tcp_dstport 0x1c set_tcp_dstport_code 0b100000000000/24 => 0x00000005
160 | table_tcam_add_entry lookup_tcp_dstport 0x1d set_tcp_dstport_code 0b000000000000/21 => 0x00000005
161 | table_tcam_add_entry lookup_tcp_dstport 0x1e set_tcp_dstport_code 0b100111000111/32 => 0x00000005
162 | #5110
163 | table_tcam_add_entry lookup_tcp_dstport 0x1f set_tcp_dstport_code 0b1001111110100/31 => 0x00000006
164 | table_tcam_add_entry lookup_tcp_dstport 0x20 set_tcp_dstport_code 0b1001111110000/30 => 0x00000006
165 | table_tcam_add_entry lookup_tcp_dstport 0x21 set_tcp_dstport_code 0b1001111100000/28 => 0x00000006
166 | table_tcam_add_entry lookup_tcp_dstport 0x22 set_tcp_dstport_code 0b1001111000000/27 => 0x00000006
167 | table_tcam_add_entry lookup_tcp_dstport 0x23 set_tcp_dstport_code 0b1001110000000/26 => 0x00000006
168 | table_tcam_add_entry lookup_tcp_dstport 0x24 set_tcp_dstport_code 0b1001100000000/25 => 0x00000006
169 | table_tcam_add_entry lookup_tcp_dstport 0x25 set_tcp_dstport_code 0b1001000000000/24 => 0x00000006
170 | table_tcam_add_entry lookup_tcp_dstport 0x26 set_tcp_dstport_code 0b1000000000000/23 => 0x00000006
171 | table_tcam_add_entry lookup_tcp_dstport 0x27 set_tcp_dstport_code 0b0000000000000/20 => 0x00000006
172 | table_tcam_add_entry lookup_tcp_dstport 0x28 set_tcp_dstport_code 0b1001111110110/31 => 0x00000006
173 | #16441
174 | table_tcam_add_entry lookup_tcp_dstport 0x29 set_tcp_dstport_code 0b100000000111000/32 => 0x00000007
175 | table_tcam_add_entry lookup_tcp_dstport 0x2a set_tcp_dstport_code 0b100000000110000/29 => 0x00000007
176 | table_tcam_add_entry lookup_tcp_dstport 0x2b set_tcp_dstport_code 0b100000000100000/28 => 0x00000007
177 | table_tcam_add_entry lookup_tcp_dstport 0x2c set_tcp_dstport_code 0b100000000000000/27 => 0x00000007
178 | table_tcam_add_entry lookup_tcp_dstport 0x2d set_tcp_dstport_code 0b000000000000000/18 => 0x00000007
179 | table_tcam_add_entry lookup_tcp_dstport 0x2e set_tcp_dstport_code 0b100000000111001/32 => 0x00000007
180 | 
181 | #code to decision
182 | table_cam_add_entry lookup_code set_output_port 0b0000000000000010001100000 => 0x00000001
183 | table_cam_add_entry lookup_code set_output_port 0b0000000000000010010000000 => 0x00000100
184 | table_cam_add_entry lookup_code set_output_port 0b0000000000000010010100000 => 0x00010000
185 | 
186 | #Else go to port 0
187 | table_cam_add_entry lookup_code set_output_port 0b00000000000000000 => 0b01000000
188 | 
189 | 


--------------------------------------------------------------------------------