stuff from netpfga

netpfga/minip4/testdata/Makefile

@@ -0,0 +1,9 @@
+# Makefile to build the testdata
+
+all:
+	./gen_testdata.py
+	${SUME_SDNET}/bin/pcap2axi --output Packet_in.axi --bus_width 256 src.pcap
+	${SUME_SDNET}/bin/pcap2axi --output Packet_expect.axi --bus_width 256 dst.pcap
+
+clean:
+	rm -f *.pcap *.txt *.pyc *.axi config_writes.* *_reg_defines.py

netpfga/minip4/testdata/SimpleSumeSwitch_extern_defines.json

@@ -0,0 +1 @@
+{}

netpfga/minip4/testdata/sss_sdnet_tuples.py

@@ -0,0 +1,178 @@
+#!/usr/bin/env python
+
+#
+# Copyright (c) 2017 Stephen Ibanez
+# All rights reserved.
+#
+# This software was developed by Stanford University and the University of Cambridge Computer Laboratory 
+# under National Science Foundation under Grant No. CNS-0855268,
+# the University of Cambridge Computer Laboratory under EPSRC INTERNET Project EP/H040536/1 and
+# by the University of Cambridge Computer Laboratory under DARPA/AFRL contract FA8750-11-C-0249 ("MRC2"), 
+# as part of the DARPA MRC research programme.
+#
+# @NETFPGA_LICENSE_HEADER_START@
+#
+# Licensed to NetFPGA C.I.C. (NetFPGA) under one or more contributor
+# license agreements.  See the NOTICE file distributed with this work for
+# additional information regarding copyright ownership.  NetFPGA licenses this
+# file to you under the NetFPGA Hardware-Software License, Version 1.0 (the
+# "License"); you may not use this file except in compliance with the
+# License.  You may obtain a copy of the License at:
+#
+#   http://www.netfpga-cic.org
+#
+# Unless required by applicable law or agreed to in writing, Work distributed
+# under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+# CONDITIONS OF ANY KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations under the License.
+#
+# @NETFPGA_LICENSE_HEADER_END@
+#
+
+
+"""
+Used to create the Tuple_in.txt and Tuple_out.txt files for the
+SDNet simulations 
+"""
+
+import argparse, collections, sys
+
+# this defines the common sume_metadata
+from sss_sume_metadata import *
+
+tuple_in_file = "Tuple_in.txt"
+tuple_expect_file = "Tuple_expect.txt"
+
+# Diget Data MUST be 256 bits
+""" Digest Data:
+   unused         (256 bits)
+"""
+
+dig_field_len = collections.OrderedDict()
+dig_field_len['unused'] = 256
+
+#initialize tuple_expect
+dig_tuple_expect = collections.OrderedDict()
+dig_tuple_expect['unused'] = 0
+
+"""
+Clear the tuple files
+"""
+def clear_tuple_files():
+    with open(tuple_in_file, "w") as f:
+        f.write("")
+    
+    with open(tuple_expect_file, "w") as f:
+        f.write("")
+
+
+"""
+Return a binary string with length = field_len_dic[field_name] 
+"""
+def get_bin_val(field_name, value, field_len_dic):
+    format_string = "{0:0%db}" % field_len_dic[field_name] 
+    bin_string = format_string.format(value)
+    return bin_string
+
+"""
+Given a binary string, return the hex version
+"""
+def bin_to_hex(bin_string):
+    hex_string = ''
+    assert(len(bin_string) % 4 == 0)
+    for i in range(0,len(bin_string),4):
+        hex_string += "{0:1x}".format(int(bin_string[i:i+4], 2))
+    return hex_string 
+
+"""
+Write the next line of the Tuple_in.txt and Tuple_expect.txt
+"""
+def write_tuples():
+    with open("Tuple_in.txt", "a") as f:
+        tup_bin_string = ''
+        for field_name, value in sume_tuple_in.iteritems():
+            bin_val = get_bin_val(field_name, value, sume_field_len)
+            tup_bin_string += bin_val
+        f.write(bin_to_hex(tup_bin_string) + '\n')
+
+    with open("Tuple_expect.txt", "a") as f:
+        tup_bin_string = ''
+        for field_name, value in dig_tuple_expect.iteritems():
+            bin_val = get_bin_val(field_name, value, dig_field_len)
+            tup_bin_string += bin_val
+        f.write(bin_to_hex(tup_bin_string) + ' ')
+
+        tup_bin_string = ''
+        for field_name, value in sume_tuple_expect.iteritems():
+            bin_val = get_bin_val(field_name, value, sume_field_len)
+            tup_bin_string += bin_val
+        f.write(bin_to_hex(tup_bin_string) + '\n')
+
+
+###############################
+## Functions to parse tuples ##
+###############################
+
+def find_tup_len(field_len_dic):
+    num_bits = 0
+    for length in field_len_dic.values():
+        num_bits += length
+    return num_bits
+
+"""
+Given a hex string, convert it to a binary string
+"""
+def hex_to_bin(hex_string, length):
+    fmat_string = '{0:0%db}' % length
+    bin_string = fmat_string.format(int(hex_string, 16))
+    return bin_string
+
+def check_length(bin_string, field_len_dic):
+    num_bits = find_tup_len(field_len_dic)
+    try:
+        assert(len(bin_string) == num_bits)
+    except:
+        print 'ERROR: unexpected input'
+        print 'len(bin_string) = ', len(bin_string)
+        print 'num_bits = ', num_bits
+        sys.exit(1)
+
+"""
+Given hex string representation of a tuple, return the parsed version of it
+"""
+def parse_tup_string(tup_string, field_len_dic):
+    tup_len = find_tup_len(field_len_dic)
+    bin_string = hex_to_bin(tup_string, tup_len)
+    check_length(bin_string, field_len_dic)
+    tup = collections.OrderedDict()   
+    i = 0
+    for (field,length) in field_len_dic.iteritems():
+        tup[field] = int(bin_string[i:i+length], 2)
+        i += length
+    return tup
+
+def parse_line(line, tuple_type):
+    if tuple_type == 'sume':
+        field_len = sume_field_len
+    elif tuple_type == 'digest':
+        field_len = dig_field_len
+    else:
+        print >> sys.stderr, "ERROR: unsupported tuple_type, must one of: [sume, digest]"
+        sys.exit(1)
+    tup_string = line.strip()
+    tup = parse_tup_string(tup_string, field_len)
+    print "Parsed Tuple:\n", '-----------------------'
+    for (key, val) in tup.items():
+        if (key in ['src_port', 'dst_port']):
+            print key, " = {0:08b}".format(val)
+        else:
+            print key, " = ", val
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--parse', type=str, help="A tuple line to parse")
+    parser.add_argument('tuple_type', type=str, help="Which tuple type to parse: sume, digest")
+    args = parser.parse_args()
+
+    parse_line(args.parse, args.tuple_type)
+

netpfga/minip4/testdata/switch_calc_headers.py

@@ -0,0 +1,25 @@
+from scapy.all import *
+import sys, os
+
+CALC_TYPE = 0x1212
+
+ADD_OP     =  0
+SUB_OP     =  1
+LOOKUP_OP  =  2
+ADD_REG_OP =  3
+SET_REG_OP =  4
+
+class Calc(Packet):
+    name = "Calc"
+    fields_desc = [
+        IntField("op1", 0),
+        ByteEnumField("opCode", 0, {ADD_OP:"ADD", SUB_OP:"SUB", LOOKUP_OP:"LOOKUP", ADD_REG_OP:"ADD_REG", SET_REG_OP:"SET_REG"}),
+        IntField("op2", 0),
+        IntField("result", 0)
+    ]
+    def mysummary(self):
+        return self.sprintf("op1=%op1% %opCode% op2=%op2% result=%result%")
+
+
+bind_layers(Ether, Calc, type=CALC_TYPE)
+bind_layers(Calc, Raw)